vike 0.4.147-commit-f9a91f3 → 0.4.148-commit-7596dcd

package/dist/cjs/shared/route/loadPageRoutes.js

@@ -7,6 +7,7 @@ const deduceRouteStringFromFilesystemPath_js_1 = require("./deduceRouteStringFro
 const utils_js_2 = require("../utils.js");
 const helpers_js_1 = require("../page-configs/helpers.js");
 const resolveRouteFunction_js_1 = require("./resolveRouteFunction.js");
+const getHook_js_1 = require("../hooks/getHook.js");
 async function loadPageRoutes(
 // Remove all arguments and use GlobalContext instead?
 pageFilesAll, pageConfigs, pageConfigGlobal, allPageIds) {
@@ -139,20 +140,8 @@ function getPageRoutes(filesystemRoots, pageFilesAll, pageConfigs, allPageIds) {
 function getGlobalHooks(pageFilesAll, pageConfigs, pageConfigGlobal) {
     // V1 Design
     if (pageConfigs.length > 0) {
-        const hookName = 'onBeforeRoute';
-        if (pageConfigGlobal.configValues[hookName]?.value) {
-            const configValue = pageConfigGlobal.configValues[hookName];
-            const { value: hookFn } = configValue;
-            const hookFilePath = (0, helpers_js_1.getHookFilePathToShowToUser)(configValue);
-            const hookDefinedAt = (0, helpers_js_1.getConfigDefinedAtString)('Hook', hookName, configValue);
-            (0, utils_js_1.assertUsage)((0, utils_js_2.isCallable)(hookFn), `${hookDefinedAt} should be a function.`);
-            const onBeforeRouteHook = {
-                hookFilePath: hookFilePath,
-                onBeforeRoute: hookFn
-            };
-            return { onBeforeRouteHook, filesystemRoots: null };
-        }
-        return { onBeforeRouteHook: null, filesystemRoots: null };
+        const hook = (0, getHook_js_1.getHookFromPageConfigGlobal)(pageConfigGlobal, 'onBeforeRoute');
+        return { onBeforeRouteHook: hook, filesystemRoots: null };
     }
     // Old design
     // TODO/v1-release: remove
@@ -165,7 +154,13 @@ function getGlobalHooks(pageFilesAll, pageConfigs, pageConfigGlobal) {
         if ('onBeforeRoute' in fileExports) {
             (0, utils_js_1.assertUsage)((0, utils_js_1.hasProp)(fileExports, 'onBeforeRoute', 'function'), `\`export { onBeforeRoute }\` of ${filePath} should be a function.`);
             const { onBeforeRoute } = fileExports;
-            onBeforeRouteHook = { hookFilePath: `${filePath} > \`export { onBeforeRoute }\``, onBeforeRoute };
+            const hookName = 'onBeforeRoute';
+            onBeforeRouteHook = {
+                hookFilePath: filePath,
+                hookFn: onBeforeRoute,
+                hookName,
+                hookTimeout: (0, getHook_js_1.getHookTimeoutDefault)(hookName)
+            };
         }
         if ('filesystemRoutingRoot' in fileExports) {
             (0, utils_js_1.assertUsage)((0, utils_js_1.hasProp)(fileExports, 'filesystemRoutingRoot', 'string'), `\`export { filesystemRoutingRoot }\` of ${filePath} should be a string.`);

package/dist/cjs/utils/projectInfo.js

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PROJECT_VERSION = exports.projectInfo = void 0;
 const assertSingleInstance_js_1 = require("./assertSingleInstance.js");
-const PROJECT_VERSION = '0.4.147-commit-f9a91f3';
+const PROJECT_VERSION = '0.4.148-commit-7596dcd';
 exports.PROJECT_VERSION = PROJECT_VERSION;
 const projectInfo = {
     projectName: 'Vike',

package/dist/esm/client/client-routing-runtime/createPageContext.d.ts

@@ -11,7 +11,7 @@ declare function createPageContext(urlOriginal: string): Promise<{
     _pageConfigGlobal: import("../../shared/page-configs/PageConfig.js").PageConfigGlobalRuntime;
     _allPageIds: string[];
     _pageRoutes: import("../../shared/route/loadPageRoutes.js").PageRoutes;
-    _onBeforeRouteHook: import("../../shared/route/executeOnBeforeRouteHook.js").OnBeforeRouteHook | null;
+    _onBeforeRouteHook: import("../../shared/hooks/getHook.js").Hook | null;
 } & import("../../shared/addUrlComputedProps.js").PageContextUrlComputedPropsClient & {
     _urlRewrite: string | null;
 }>;

package/dist/esm/client/client-routing-runtime/getPageContextFromHooks.js

@@ -132,7 +132,7 @@ async function executeOnBeforeRenderHookClientSide(pageContext) {
         ...pageContext,
         ...pageContextFromOnBeforeRender
     }, true);
-    const hookResult = await executeHook(() => onBeforeRender(pageContextForUserConsumption), 'onBeforeRender', hook.hookFilePath);
+    const hookResult = await executeHook(() => onBeforeRender(pageContextForUserConsumption), hook);
     assertOnBeforeRenderHookReturn(hookResult, hook.hookFilePath);
     const pageContextFromHook = hookResult?.pageContext;
     objectAssign(pageContextFromOnBeforeRender, pageContextFromHook);

package/dist/esm/client/client-routing-runtime/renderPageClientSide.js

@@ -7,7 +7,7 @@ import { createPageContext } from './createPageContext.js';
 import { addLinkPrefetchHandlers } from './prefetch.js';
 import { assertInfo, assertWarning, isReact } from './utils.js';
 import { executeOnRenderClientHook } from '../shared/executeOnRenderClientHook.js';
-import { assertHook } from '../../shared/hooks/getHook.js';
+import { assertHook, getHook } from '../../shared/hooks/getHook.js';
 import { isErrorFetchingStaticAssets } from '../shared/loadPageFilesClientSide.js';
 import { pushHistory } from './history.js';
 import { assertNoInfiniteAbortLoop, getPageContextFromAllRewrites, isAbortError, logAbortErrorHandled } from '../../shared/route/abort.js';
@@ -85,7 +85,11 @@ async function renderPageClientSide(renderArgs) {
     const callTransitionHooks = !isFirstRender;
     if (callTransitionHooks) {
         if (!globalObject.isTransitioning) {
-            await globalObject.onPageTransitionStart?.(pageContext);
+            if (globalObject.onPageTransitionStart) {
+                const hook = globalObject.onPageTransitionStart;
+                const { hookFn } = hook;
+                await executeHook(() => hookFn(pageContext), hook);
+            }
             globalObject.isTransitioning = true;
             if (abortRender())
                 return;
@@ -207,13 +211,14 @@ async function renderPageClientSide(renderArgs) {
     objectAssign(pageContext, pageContextFromHooks);
     // Set global onPageTransitionStart()
     assertHook(pageContext, 'onPageTransitionStart');
-    globalObject.onPageTransitionStart = pageContext.exports.onPageTransitionStart;
+    const onPageTransitionStartHook = getHook(pageContext, 'onPageTransitionStart');
+    globalObject.onPageTransitionStart = onPageTransitionStartHook;
     // Set global hydrationCanBeAborted
     if (pageContext.exports.hydrationCanBeAborted) {
         setHydrationCanBeAborted();
     }
     else {
-        assertWarning(!isReact(), 'You seem to be using React; we recommend setting hydrationCanBeAborted to true, see https://vike.dev/clientRouting', { onlyOnce: true });
+        assertWarning(!isReact(), 'You seem to be using React; we recommend setting hydrationCanBeAborted to true, see https://vike.dev/hydrationCanBeAborted', { onlyOnce: true });
     }
     // There wasn't any `await` but result may change because we just called setHydrationCanBeAborted()
     if (abortRender())
@@ -242,11 +247,10 @@ async function renderPageClientSide(renderArgs) {
     // onHydrationEnd()
     if (isFirstRender) {
         assertHook(pageContext, 'onHydrationEnd');
-        const { onHydrationEnd } = pageContext.exports;
-        if (onHydrationEnd) {
-            const hookFilePath = pageContext.exportsAll.onHydrationEnd[0].exportSource;
-            assert(hookFilePath);
-            await executeHook(() => onHydrationEnd(pageContext), 'onHydrationEnd', hookFilePath);
+        const hook = getHook(pageContext, 'onHydrationEnd');
+        if (hook) {
+            const { hookFn } = hook;
+            await executeHook(() => hookFn(pageContext), hook);
             if (abortRender(true))
                 return;
         }
@@ -256,9 +260,11 @@ async function renderPageClientSide(renderArgs) {
         return;
     // onPageTransitionEnd()
     if (callTransitionHooks) {
-        if (pageContext.exports.onPageTransitionEnd) {
-            assertHook(pageContext, 'onPageTransitionEnd');
-            await pageContext.exports.onPageTransitionEnd(pageContext);
+        assertHook(pageContext, 'onPageTransitionEnd');
+        const hook = getHook(pageContext, 'onPageTransitionEnd');
+        if (hook) {
+            const { hookFn } = hook;
+            await executeHook(() => hookFn(pageContext), hook);
             if (abortRender(true))
                 return;
         }

package/dist/esm/client/shared/executeOnRenderClientHook.js

@@ -45,7 +45,7 @@ async function executeOnRenderClientHook(pageContext, isClientRouting) {
     const renderHook = hook.hookFn;
     assert(hookName);
     // We don't use a try-catch wrapper because rendering errors are usually handled by the UI framework. (E.g. React's Error Boundaries.)
-    const hookResult = await executeHook(() => renderHook(pageContextForUserConsumption), hookName, hook.hookFilePath);
+    const hookResult = await executeHook(() => renderHook(pageContextForUserConsumption), hook);
     assertUsage(hookResult === undefined, `The ${hookName}() hook defined by ${hook.hookFilePath} isn't allowed to return a value`);
 }
 function getUrlToShowToUser(pageContext) {

package/dist/esm/node/plugin/plugins/importUserCode/v1-design/getConfigValuesSerialized.js

@@ -1,7 +1,7 @@
 export { getConfigValuesSerialized };
 export { assertConfigValueIsSerializable };
 import { assert, assertUsage, getPropAccessNotation } from '../../../utils.js';
-import { isJsonSerializerError, stringify } from '@brillout/json-serializer/stringify';
+import { stringify } from '@brillout/json-serializer/stringify';
 import pc from '@brillout/picocolors';
 import { getConfigValueFilePathToShowToUser } from '../../../../../shared/page-configs/helpers.js';
 import { serializeConfigValue } from '../../../../../shared/page-configs/serialize/serializeConfigValue.js';
@@ -47,22 +47,27 @@ function getConfigValueSerialized(value, configName, definedAt) {
         configValueSerialized = stringify(value, { valueName, forbidReactElements: true });
     }
     catch (err) {
-        let serializationErrMsg = '';
+        /*
+        let serializationErrMsg = ''
         if (isJsonSerializerError(err)) {
-            serializationErrMsg = err.messageCore;
-        }
-        else {
-            // When a property getter throws an error
-            console.error('Serialization error:');
-            console.error(err);
-            serializationErrMsg = 'see serialization error printed above';
+          serializationErrMsg = err.messageCore
+        } else {
+          // When a property getter throws an error
+          console.error('Serialization error:')
+          console.error(err)
+          serializationErrMsg = 'see serialization error printed above'
         }
+        */
         const configValueFilePathToShowToUser = getConfigValueFilePathToShowToUser({ definedAt });
         assert(configValueFilePathToShowToUser);
         assertUsage(false, [
-            `The value of the config ${pc.cyan(configName)} cannot be defined inside the file ${configValueFilePathToShowToUser}:`,
-            `its value must be defined in an another file and then imported by ${configValueFilePathToShowToUser}. (Because its value isn't serializable: ${serializationErrMsg}.)`,
-            `Only serializable config values can be defined inside +config.h.js files, see https://vike.dev/header-file.`
+            `The code of ${pc.cyan(configName)} cannot live inside ${configValueFilePathToShowToUser},`,
+            'see https://vike.dev/header-file#runtime-code'
+            /* I guess showing this is more confusing than adding value.
+            `(technically speaking: the value of ${pc.cyan(
+              configName
+            )} isn't serializable (${serializationErrMsg}) and it's therefore runtime code that needs to be imported).`
+            //*/
         ].join(' '));
     }
     configValueSerialized = JSON.stringify(configValueSerialized);

package/dist/esm/node/plugin/plugins/importUserCode/v1-design/getVikeConfig/configDefinitionsBuiltIn.js

@@ -75,6 +75,9 @@ const configDefinitionsBuiltIn = {
     onBeforeRenderEnv: {
         env: { client: true },
         _computed: (configValueSources) => !isConfigSet(configValueSources, 'onBeforeRender') ? null : getConfigEnv(configValueSources, 'onBeforeRender')
+    },
+    hooksTimeout: {
+        env: { server: true, client: true }
     }
 };
 const configDefinitionsBuiltInGlobal = {

package/dist/esm/node/plugin/plugins/importUserCode/v1-design/getVikeConfig/crawlPlusFiles.js

@@ -45,6 +45,18 @@ async function crawlPlusFiles(userRootDir, outDirAbsoluteFilesystem, isDev) {
 }
 // Same as fastGlob() but using `$ git ls-files`
 async function gitLsFiles(userRootDir, outDir) {
+    // Test if Git is installed
+    {
+        let stdout;
+        try {
+            const res = await execA('git --version', { cwd: userRootDir });
+            stdout = res.stdout;
+        }
+        catch {
+            return null;
+        }
+        assert(stdout.startsWith('git version '));
+    }
     const cmd = [
         'git ls-files',
         ...scriptFileExtensionList.map((ext) => `"**/+*.${ext}"`),

package/dist/esm/node/plugin/plugins/importUserCode/v1-design/getVikeConfig.js

@@ -122,6 +122,7 @@ async function loadInterfaceFiles(userRootDir, outDirRoot, isDev, extensions) {
             interfaceFilesByLocationId[locationId].push(interfaceFile);
         }
     }));
+    assertAllConfigsAreKnown(interfaceFilesByLocationId);
     return interfaceFilesByLocationId;
 }
 function getConfigDefinition(configDefinitionsRelevant, configName, filePathToShowToUser) {
@@ -175,6 +176,18 @@ function getInterfaceFileFromConfigFile(configFile, isConfigExtend) {
     });
     return interfaceFile;
 }
+/** Show error message upon unknown config */
+function assertAllConfigsAreKnown(interfaceFilesByLocationId) {
+    Object.entries(interfaceFilesByLocationId).forEach(([locationId, interfaceFiles]) => {
+        const interfaceFilesRelevant = getInterfaceFilesRelevant(interfaceFilesByLocationId, locationId);
+        const configDefinitionsRelevant = getConfigDefinitions(interfaceFilesRelevant);
+        interfaceFiles.forEach((interfaceFile) => {
+            Object.keys(interfaceFile.configMap).forEach((configName) => {
+                assertConfigExists(configName, Object.keys(configDefinitionsRelevant), interfaceFile.filePath.filePathToShowToUser);
+            });
+        });
+    });
+}
 async function loadVikeConfig_withErrorHandling(userRootDir, outDirRoot, isDev, extensions, tolerateInvalidConfig) {
     let hasError = false;
     let ret;
@@ -265,18 +278,23 @@ async function loadVikeConfig(userRootDir, outDirRoot, isDev, extensions) {
         };
         return pageConfig;
     }));
-    // Show error message upon unknown config
-    Object.entries(interfaceFilesByLocationId).forEach(([locationId, interfaceFiles]) => {
-        const interfaceFilesRelevant = getInterfaceFilesRelevant(interfaceFilesByLocationId, locationId);
-        const configDefinitionsRelevant = getConfigDefinitions(interfaceFilesRelevant);
-        interfaceFiles.forEach((interfaceFile) => {
-            Object.keys(interfaceFile.configMap).forEach((configName) => {
-                assertConfigExists(configName, Object.keys(configDefinitionsRelevant), interfaceFile.filePath.filePathToShowToUser);
-            });
-        });
-    });
+    assertPageConfigs(pageConfigs);
     return { pageConfigs, pageConfigGlobal, globalVikeConfig };
 }
+function assertPageConfigs(pageConfigs) {
+    pageConfigs.forEach((pageConfig) => {
+        assertOnBeforeRenderEnv(pageConfig);
+    });
+}
+function assertOnBeforeRenderEnv(pageConfig) {
+    const onBeforeRenderConfig = pageConfig.configValueSources.onBeforeRender?.[0];
+    if (!onBeforeRenderConfig)
+        return;
+    const onBeforeRenderEnv = onBeforeRenderConfig.configEnv;
+    const isClientRouting = !!pageConfig.configValues.clientRouting?.value;
+    // When using Server Routing, loading a onBeforeRender() hook on the client-side hasn't any effect (the Server Routing's client runtime never calls it); it unnecessarily bloats client bundle sizes
+    assertUsage(!(onBeforeRenderEnv.client && !isClientRouting), `Page ${pageConfig.pageId} has an onBeforeRender() hook with env ${pc.cyan(JSON.stringify(onBeforeRenderEnv))} which doesn't make sense because the page is using Server Routing: onBeforeRender() can be run in the client only when using Client Routing.`);
+}
 function interfacefileIsAlreaydLoaded(interfaceFile) {
     const configMapValues = Object.values(interfaceFile.configMap);
     const isAlreadyLoaded = configMapValues.some((conf) => 'configValue' in conf);

package/dist/esm/node/prerender/runPrerender.js

@@ -16,14 +16,14 @@ import { getConfigVike } from '../shared/getConfigVike.js';
 import { getPageFilesServerSide } from '../../shared/getPageFiles.js';
 import { getPageContextRequestUrl } from '../../shared/getPageContextRequestUrl.js';
 import { getUrlFromRouteString } from '../../shared/route/resolveRouteString.js';
-import { getConfigValue, getConfigValueFilePathToShowToUser, getHookFilePathToShowToUser } from '../../shared/page-configs/helpers.js';
+import { getConfigValue, getConfigValueFilePathToShowToUser } from '../../shared/page-configs/helpers.js';
 import { loadConfigValues } from '../../shared/page-configs/loadConfigValues.js';
 import { isErrorPage } from '../../shared/error-page.js';
 import { addUrlComputedProps } from '../../shared/addUrlComputedProps.js';
 import { assertPathIsFilesystemAbsolute } from '../../utils/assertPathIsFilesystemAbsolute.js';
 import { isAbortError } from '../../shared/route/abort.js';
 import { loadPageFilesServerSide } from '../runtime/renderPage/loadPageFilesServerSide.js';
-import { assertHookFn } from '../../shared/hooks/getHook.js';
+import { getHookFromPageConfig, getHookFromPageConfigGlobal, getHookTimeoutDefault } from '../../shared/hooks/getHook.js';
 import { noRouteMatch } from '../../shared/route/noRouteMatch.js';
 import { getVikeConfig } from '../plugin/plugins/importUserCode/v1-design/getVikeConfig.js';
 async function prerenderFromAPI(options = {}) {
@@ -157,18 +157,16 @@ async function callOnBeforePrerenderStartHooks(prerenderContext, renderContext,
     await Promise.all(renderContext.pageConfigs.map((pageConfig) => concurrencyLimit(async () => {
         const hookName = 'onBeforePrerenderStart';
         const pageConfigLoaded = await loadConfigValues(pageConfig, false);
-        const configValue = getConfigValue(pageConfigLoaded, hookName);
-        if (!configValue)
+        const hook = getHookFromPageConfig(pageConfigLoaded, hookName);
+        if (!hook)
             return;
-        const hookFn = configValue.value;
-        const hookFilePath = getHookFilePathToShowToUser(configValue);
-        assert(hookFilePath);
-        assertHookFn(hookFn, { hookName, hookFilePath });
+        const { hookFn, hookFilePath, hookTimeout } = hook;
         onBeforePrerenderStartHooks.push({
             hookFn,
             hookName: 'onBeforePrerenderStart',
             hookFilePath,
-            pageId: pageConfig.pageId
+            pageId: pageConfig.pageId,
+            hookTimeout
         });
     })));
     // 0.4 design
@@ -192,14 +190,15 @@ async function callOnBeforePrerenderStartHooks(prerenderContext, renderContext,
             hookFn,
             hookName: 'prerender',
             hookFilePath,
-            pageId: p.pageId
+            pageId: p.pageId,
+            hookTimeout: getHookTimeoutDefault('onBeforePrerenderStart')
         });
     })));
-    await Promise.all(onBeforePrerenderStartHooks.map(({ hookFn, hookName, hookFilePath, pageId }) => concurrencyLimit(async () => {
+    await Promise.all(onBeforePrerenderStartHooks.map(({ hookFn, hookName, hookFilePath, pageId, hookTimeout }) => concurrencyLimit(async () => {
         if (doNotPrerenderList.find((p) => p.pageId === pageId)) {
             return;
         }
-        const prerenderResult = await hookFn();
+        const prerenderResult = await executeHook(() => hookFn(), { hookName, hookFilePath, hookTimeout });
         const result = normalizeOnPrerenderHookResult(prerenderResult, hookFilePath, hookName);
         result.forEach(({ url, pageContext }) => {
             {
@@ -298,23 +297,21 @@ async function callOnPrerenderStartHook(prerenderContext, renderContext) {
     let onPrerenderStartHook;
     // V1 design
     if (renderContext.pageConfigs.length > 0) {
-        const { pageConfigGlobal } = renderContext;
-        const configValue = pageConfigGlobal.configValues.onPrerenderStart;
-        if (configValue?.value) {
-            const { value: hookFn } = configValue;
-            // config.onPrerenderStart isn't a computed nor a cumulative config => definedAt should always be defined
-            const hookFilePath = getHookFilePathToShowToUser(configValue);
-            assert(hookFilePath);
+        const hookName = 'onPrerenderStart';
+        const hook = getHookFromPageConfigGlobal(renderContext.pageConfigGlobal, hookName);
+        if (hook) {
+            assert(hook.hookName === 'onPrerenderStart');
             onPrerenderStartHook = {
-                hookFn,
-                hookName: 'onPrerenderStart',
-                hookFilePath
+                ...hook,
+                // Make TypeScript happy
+                hookName
             };
         }
     }
     // Old design
     // TODO/v1-release: remove
     if (renderContext.pageConfigs.length === 0) {
+        const hookTimeout = getHookTimeoutDefault('onBeforePrerender');
         const pageFilesWithOnBeforePrerenderHook = renderContext.pageFilesAll.filter((p) => {
             assertExportNames(p);
             if (!p.exportNames?.includes('onBeforePrerender'))
@@ -340,7 +337,8 @@ async function callOnPrerenderStartHook(prerenderContext, renderContext) {
         onPrerenderStartHook = {
             hookFn: hook.onBeforePrerender,
             hookFilePath: hook.hookFilePath,
-            hookName: 'onBeforePrerender'
+            hookName: 'onBeforePrerender',
+            hookTimeout
         };
     }
     if (!onPrerenderStartHook) {
@@ -375,7 +373,7 @@ async function callOnPrerenderStartHook(prerenderContext, renderContext) {
             });
             return prerenderContext.pageContexts;
         }
-    }), hookName, hookFilePath);
+    }), onPrerenderStartHook);
     if (result === null || result === undefined) {
         return;
     }

package/dist/esm/node/runtime/html/renderHtml.js

@@ -174,7 +174,7 @@ async function renderTemplate(templateContent, pageContext) {
         };
         assertUsage(!isPromise(templateVar), getErrMsg('a promise', `Did you forget to ${pc.cyan('await')} the promise?`));
         if (templateVar === undefined || templateVar === null) {
-            assertWarning(false, getErrMsg(`${pc.cyan(String(templateVar))} which will be converted to an empty string`, `Pass an empty string instead of ${pc.cyan(String(templateVar))} to remove this warning.`), { onlyOnce: false });
+            assertWarning(false, getErrMsg(`${pc.cyan(String(templateVar))} which will be converted to an empty string`, `Pass the empty string ${pc.cyan("''")} instead of ${pc.cyan(String(templateVar))} to remove this warning.`), { onlyOnce: false });
             templateVar = '';
         }
         {

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

@@ -13,7 +13,7 @@ async function executeOnBeforeRenderHooks(pageContext) {
     }
     const onBeforeRender = hook.hookFn;
     preparePageContextForUserConsumptionServerSide(pageContext);
-    const hookResult = await executeHook(() => onBeforeRender(pageContext), 'onBeforeRender', hook.hookFilePath);
+    const hookResult = await executeHook(() => onBeforeRender(pageContext), hook);
     assertOnBeforeRenderHookReturn(hookResult, hook.hookFilePath);
     const pageContextFromHook = hookResult?.pageContext;
     Object.assign(pageContext, pageContextFromHook);

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

@@ -1,13 +1,13 @@
 export { executeOnRenderHtmlHook };
 export type { RenderHook };
 import { type HtmlRender } from '../html/renderHtml.js';
+import { type Hook } from '../../../shared/hooks/getHook.js';
 import type { PageAsset } from './getPageAssets.js';
 import { type PageContextForUserConsumptionServerSide } from './preparePageContextForUserConsumptionServerSide.js';
 import type { PageConfigRuntime } from '../../../shared/page-configs/PageConfig.js';
 import type { PageContextSerialization } from '../html/serializePageContextClientSide.js';
 type GetPageAssets = () => Promise<PageAsset[]>;
-type RenderHook = {
-    hookFilePath: string;
+type RenderHook = Hook & {
     hookName: HookName;
 };
 type HookName = 'onRenderHtml' | 'render';

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

@@ -12,7 +12,7 @@ async function executeOnRenderHtmlHook(pageContext) {
     const { renderHook, hookFn } = getRenderHook(pageContext);
     objectAssign(pageContext, { _renderHook: renderHook });
     preparePageContextForUserConsumptionServerSide(pageContext);
-    const hookReturnValue = await executeHook(() => hookFn(pageContext), renderHook.hookName, renderHook.hookFilePath);
+    const hookReturnValue = await executeHook(() => hookFn(pageContext), renderHook);
     const { documentHtml, pageContextProvidedByRenderHook, pageContextPromise, injectFilter } = processHookReturnValue(hookReturnValue, renderHook);
     Object.assign(pageContext, pageContextProvidedByRenderHook);
     objectAssign(pageContext, { _pageContextPromise: pageContextPromise });
@@ -50,10 +50,10 @@ function getRenderHook(pageContext) {
         }
         if (hook) {
             assert(hookName);
-            const { hookFilePath, hookFn } = hook;
+            const { hookFilePath, hookFn, hookTimeout } = hook;
             hookFound = {
                 hookFn,
-                renderHook: { hookFilePath, hookName }
+                renderHook: { hookFn, hookFilePath, hookName, hookTimeout }
             };
         }
     }

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

@@ -12,7 +12,7 @@ import { HttpResponse } from './createHttpResponseObject.js';
 import { PageContext_loadPageFilesServerSide, type PageFiles } from './loadPageFilesServerSide.js';
 import type { PageConfigRuntime, PageConfigGlobalRuntime } from '../../../shared/page-configs/PageConfig.js';
 import { type PageRoutes } from '../../../shared/route/loadPageRoutes.js';
-import type { OnBeforeRouteHook } from '../../../shared/route/executeOnBeforeRouteHook.js';
+import type { Hook } from '../../../shared/hooks/getHook.js';
 type PageContextAfterRender = {
     httpResponse: null | HttpResponse;
     errorWhileRendering: null | Error;
@@ -46,7 +46,7 @@ declare function prerenderPage(pageContext: PageContextInitEnhanced & PageFiles
         _pageConfigGlobal: PageConfigGlobalRuntime;
         _allPageIds: string[];
         _pageRoutes: PageRoutes;
-        _onBeforeRouteHook: OnBeforeRouteHook | null;
+        _onBeforeRouteHook: Hook | null;
         _pageContextInit: {
             urlOriginal: string;
         };
@@ -93,7 +93,7 @@ declare function prerenderPage(pageContext: PageContextInitEnhanced & PageFiles
         _pageConfigGlobal: PageConfigGlobalRuntime;
         _allPageIds: string[];
         _pageRoutes: PageRoutes;
-        _onBeforeRouteHook: OnBeforeRouteHook | null;
+        _onBeforeRouteHook: Hook | null;
         _pageContextInit: {
             urlOriginal: string;
         };
@@ -141,7 +141,7 @@ declare function prerender404Page(renderContext: RenderContext, pageContextInit_
         _pageConfigGlobal: PageConfigGlobalRuntime;
         _allPageIds: string[];
         _pageRoutes: PageRoutes;
-        _onBeforeRouteHook: OnBeforeRouteHook | null;
+        _onBeforeRouteHook: Hook | null;
         _pageContextInit: {
             urlOriginal: string;
         };
@@ -188,7 +188,7 @@ declare function prerender404Page(renderContext: RenderContext, pageContextInit_
         _pageConfigGlobal: PageConfigGlobalRuntime;
         _allPageIds: string[];
         _pageRoutes: PageRoutes;
-        _onBeforeRouteHook: OnBeforeRouteHook | null;
+        _onBeforeRouteHook: Hook | null;
         _pageContextInit: {
             urlOriginal: string;
         };
@@ -243,7 +243,7 @@ declare function getPageContextInitEnhanced(pageContextInit: {
     _pageConfigGlobal: PageConfigGlobalRuntime;
     _allPageIds: string[];
     _pageRoutes: PageRoutes;
-    _onBeforeRouteHook: OnBeforeRouteHook | null;
+    _onBeforeRouteHook: Hook | null;
     _pageContextInit: {
         urlOriginal: string;
     };
@@ -260,6 +260,6 @@ type RenderContext = {
     pageConfigGlobal: PageConfigGlobalRuntime;
     allPageIds: string[];
     pageRoutes: PageRoutes;
-    onBeforeRouteHook: OnBeforeRouteHook | null;
+    onBeforeRouteHook: Hook | null;
 };
 declare function getRenderContext(): Promise<RenderContext>;

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

@@ -6,7 +6,7 @@ export { getRenderContext };
 import { getErrorPageId } from '../../../shared/error-page.js';
 import { getHtmlString } from '../html/renderHtml.js';
 import { getPageFilesAll } from '../../../shared/getPageFiles.js';
-import { assert, assertUsage, hasProp, isNotNullish, objectAssign, unique } from '../utils.js';
+import { assert, assertUsage, assertWarning, hasProp, isNotNullish, objectAssign, unique } from '../utils.js';
 import { serializePageContextClientSide } from '../html/serializePageContextClientSide.js';
 import { addUrlComputedProps } from '../../../shared/addUrlComputedProps.js';
 import { getGlobalContext } from '../globalContext.js';
@@ -150,7 +150,7 @@ async function getRenderContext() {
     const globalContext = getGlobalContext();
     const { pageFilesAll, allPageIds, pageConfigs, pageConfigGlobal } = await getPageFilesAll(false, globalContext.isProduction);
     const { pageRoutes, onBeforeRouteHook } = await loadPageRoutes(pageFilesAll, pageConfigs, pageConfigGlobal, allPageIds);
-    assertNonMixedDesign(pageFilesAll, pageConfigs);
+    assertV1Design(pageFilesAll, pageConfigs);
     const renderContext = {
         pageFilesAll: pageFilesAll,
         pageConfigs,
@@ -161,21 +161,24 @@ async function getRenderContext() {
     };
     return renderContext;
 }
-function assertNonMixedDesign(pageFilesAll, pageConfigs) {
-    if (pageFilesAll.length === 0 || pageConfigs.length === 0)
-        return;
-    const indent = '- ';
-    const v1Files = unique(pageConfigs
-        .map((p) => Object.values(p.configValues)
-        .map(getConfigValueFilePathToShowToUser)
-        .filter(isNotNullish)
-        .map((filePathToShowToUser) => indent + filePathToShowToUser))
-        .flat(2));
-    assertUsage(false, [
-        'Mixing the new V1 design with the old V0.4 design is forbidden.',
-        'V1 files:',
-        ...v1Files,
-        'V0.4 files:',
-        ...pageFilesAll.map((p) => indent + p.filePath)
-    ].join('\n'));
+function assertV1Design(pageFilesAll, pageConfigs) {
+    const isV1Design = pageConfigs.length !== 0;
+    const isDesignOld = pageFilesAll.length !== 0;
+    if (isV1Design && isDesignOld) {
+        const indent = '- ';
+        const v1Files = unique(pageConfigs
+            .map((p) => Object.values(p.configValues)
+            .map(getConfigValueFilePathToShowToUser)
+            .filter(isNotNullish)
+            .map((filePathToShowToUser) => indent + filePathToShowToUser))
+            .flat(2));
+        assertUsage(false, [
+            'Mixing the new V1 design with the old V0.4 design is forbidden.',
+            'V1 files:',
+            ...v1Files,
+            'V0.4 files:',
+            ...pageFilesAll.map((p) => indent + p.filePath)
+        ].join('\n'));
+    }
+    assertWarning(!isDesignOld, 'You are using the old deprecated design, update to the new V1 design, see https://vike.dev/migration/v1-design', { onlyOnce: true });
 }

package/dist/esm/shared/getPageFiles/parseGlobResults.js

@@ -3,7 +3,7 @@ import { assert, hasProp, isCallable, isObject, cast, assertUsage } from '../uti
 import { assertExportValues } from './assert_exports_old_design.js';
 import { getPageFileObject } from './getPageFileObject.js';
 import { fileTypes } from './fileTypes.js';
-import { assertPageConfigGlobalSerialized, assertPageConfigsSerialized } from '../page-configs/serialize/assertPageConfigs.js';
+import { assertPageConfigGlobalSerialized, assertPageConfigsSerialized } from '../page-configs/serialize/assertPageConfigsSerialized.js';
 import { parsePageConfigs } from '../page-configs/serialize/parsePageConfigs.js';
 function parseGlobResults(pageFilesExports) {
     assert(hasProp(pageFilesExports, 'isGeneratedFile'));

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

@@ -1,5 +1,5 @@
 export { executeHook };
 export { isUserHookError };
-import type { HookLoc, HookName } from './getHook.js';
+import type { Hook, HookLoc } from './getHook.js';
 declare function isUserHookError(err: unknown): false | HookLoc;
-declare function executeHook<T = unknown>(hookFn: () => T, hookName: HookName, hookFilePath: string): Promise<T>;
+declare function executeHook<T = unknown>(hookFnCaller: () => T, hook: Omit<Hook, 'hookFn'>): Promise<T>;