vike 0.4.147 → 0.4.148-commit-7596dcd

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

@@ -2,10 +2,9 @@ export { getVikeConfig };
 export { reloadVikeConfig };
 export { vikeConfigDependencies };
 export { isVikeConfigFile };
-import { assertPosixPath, assert, isObject, assertUsage, toPosixPath, assertWarning, objectEntries, hasProp, arrayIncludes, assertIsNotProductionRuntime, getMostSimilar, isNpmPackageImport, joinEnglish, lowerFirst, scriptFileExtensions, mergeCumulativeValues, requireResolve, getOutDirs, deepEqual, assertKeys } from '../../../utils.js';
+import { assertPosixPath, assert, isObject, assertUsage, assertWarning, objectEntries, hasProp, arrayIncludes, assertIsNotProductionRuntime, getMostSimilar, isNpmPackageImport, joinEnglish, lowerFirst, mergeCumulativeValues, requireResolve, getOutDirs, deepEqual, assertKeys } from '../../../utils.js';
 import path from 'path';
 import { configDefinitionsBuiltIn, configDefinitionsBuiltInGlobal } from './getVikeConfig/configDefinitionsBuiltIn.js';
-import glob from 'fast-glob';
 import { getLocationId, getFilesystemRouteString, getFilesystemRouteDefinedBy, isInherited, sortAfterInheritanceOrder, isGlobalLocation, applyFilesystemRoutingRootEffect } from './getVikeConfig/filesystemRouting.js';
 import { isTmpFile, transpileAndExecuteFile } from './transpileAndExecuteFile.js';
 import { parseImportData } from './replaceImportStatements.js';
@@ -18,6 +17,7 @@ import { getConfigDefinedAtString } from '../../../../../shared/page-configs/hel
 import { assertExportsOfConfigFile, assertExportsOfValueFile } from '../../../../../shared/page-configs/assertExports.js';
 import { getConfigVike } from '../../../../shared/getConfigVike.js';
 import { assertConfigValueIsSerializable } from './getConfigValuesSerialized.js';
+import { crawlPlusFiles } from './getVikeConfig/crawlPlusFiles.js';
 assertIsNotProductionRuntime();
 let devServerIsCorrupt = false;
 let wasConfigInvalid = null;
@@ -70,7 +70,7 @@ async function getVikeConfig(config, isDev, tolerateInvalidConfig = false, exten
     return await vikeConfigPromise;
 }
 async function loadInterfaceFiles(userRootDir, outDirRoot, isDev, extensions) {
-    const plusFiles = await findPlusFiles(userRootDir, [outDirRoot], isDev, extensions);
+    const plusFiles = await findPlusFiles(userRootDir, outDirRoot, isDev, extensions);
     const configFiles = [];
     const valueFiles = [];
     plusFiles.forEach((f) => {
@@ -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);
@@ -776,39 +794,9 @@ function getComputed(configValueSources, configDefinitionsRelevant) {
     });
     return configValuesComputed;
 }
-async function findPlusFiles(userRootDir, ignoreDirs, isDev, extensions) {
-    const timeBase = new Date().getTime();
-    assertPosixPath(userRootDir);
-    const ignorePatterns = [];
-    for (const dir of ignoreDirs) {
-        assertPosixPath(dir);
-        ignorePatterns.push(`${path.posix.relative(userRootDir, dir)}/**`);
-    }
-    const result = await glob(`**/+*.${scriptFileExtensions}`, {
-        ignore: [
-            '**/node_modules/**',
-            // Allow:
-            // ```
-            // +Page.js
-            // +Page.telefunc.js
-            // ```
-            '**/*.telefunc.*',
-            ...ignorePatterns
-        ],
-        cwd: userRootDir,
-        dot: false
-    });
-    const time = new Date().getTime() - timeBase;
-    if (isDev) {
-        // We only warn in dev, because while building it's expected to take a long time as fast-glob is competing for resources with other tasks
-        assertWarning(time < 2 * 1000, `Crawling your user files took an unexpected long time (${time}ms). Create a new issue on Vike's GitHub.`, {
-            onlyOnce: 'slow-page-files-search'
-        });
-    }
-    const plusFiles = result.map((p) => {
-        p = toPosixPath(p);
-        const filePathRelativeToUserRootDir = path.posix.join('/', p);
-        const filePathAbsoluteFilesystem = path.posix.join(userRootDir, p);
+async function findPlusFiles(userRootDir, outDirRoot, isDev, extensions) {
+    const files = await crawlPlusFiles(userRootDir, outDirRoot, isDev);
+    const plusFiles = files.map(({ filePathRelativeToUserRootDir, filePathAbsoluteFilesystem }) => {
         return {
             filePathRelativeToUserRootDir,
             filePathAbsoluteVite: filePathRelativeToUserRootDir,

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 = {}) {
@@ -74,16 +74,22 @@ async function runPrerender(options, manuallyTriggered) {
     await callOnBeforePrerenderStartHooks(prerenderContext, renderContext, concurrencyLimit, doNotPrerenderList);
     await handlePagesWithStaticRoutes(prerenderContext, renderContext, doNotPrerenderList, concurrencyLimit);
     await callOnPrerenderStartHook(prerenderContext, renderContext);
-    const prerenderedPages = {};
-    const htmlFiles = [];
-    await routeAndPrerender(prerenderContext, htmlFiles, prerenderedPages, concurrencyLimit);
-    warnContradictoryNoPrerenderList(prerenderedPages, doNotPrerenderList);
-    await prerender404(htmlFiles, renderContext, prerenderContext);
+    const prerenderedPageContexts = {};
+    let prerenderedCount = 0;
+    const onComplete = async (htmlFile) => {
+        prerenderedCount++;
+        if (htmlFile.pageId) {
+            prerenderedPageContexts[htmlFile.pageId] = htmlFile.pageContext;
+        }
+        await writeFiles(htmlFile, root, outDirClient, options.onPagePrerender, logLevel);
+    };
+    await routeAndPrerender(prerenderContext, concurrencyLimit, onComplete);
+    warnContradictoryNoPrerenderList(prerenderedPageContexts, doNotPrerenderList);
+    await prerender404(prerenderedPageContexts, renderContext, prerenderContext, onComplete);
     if (logLevel === 'info') {
-        console.log(`${pc.green(`✓`)} ${htmlFiles.length} HTML documents pre-rendered.`);
+        console.log(`${pc.green(`✓`)} ${prerenderedCount} HTML documents pre-rendered.`);
     }
-    await Promise.all(htmlFiles.map((htmlFile) => writeHtmlFile(htmlFile, root, outDirClient, concurrencyLimit, options.onPagePrerender, logLevel)));
-    warnMissingPages(prerenderedPages, doNotPrerenderList, renderContext, partial);
+    warnMissingPages(prerenderedPageContexts, doNotPrerenderList, renderContext, partial);
 }
 async function collectDoNoPrerenderList(renderContext, pageConfigs, doNotPrerenderList, concurrencyLimit) {
     // V1 design
@@ -151,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
@@ -186,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 }) => {
             {
@@ -292,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'))
@@ -334,7 +337,8 @@ async function callOnPrerenderStartHook(prerenderContext, renderContext) {
         onPrerenderStartHook = {
             hookFn: hook.onBeforePrerender,
             hookFilePath: hook.hookFilePath,
-            hookName: 'onBeforePrerender'
+            hookName: 'onBeforePrerender',
+            hookTimeout
         };
     }
     if (!onPrerenderStartHook) {
@@ -369,7 +373,7 @@ async function callOnPrerenderStartHook(prerenderContext, renderContext) {
             });
             return prerenderContext.pageContexts;
         }
-    }), hookName, hookFilePath);
+    }), onPrerenderStartHook);
     if (result === null || result === undefined) {
         return;
     }
@@ -411,7 +415,7 @@ async function callOnPrerenderStartHook(prerenderContext, renderContext) {
         addUrlComputedProps(pageContext);
     });
 }
-async function routeAndPrerender(prerenderContext, htmlFiles, prerenderedPages, concurrencyLimit) {
+async function routeAndPrerender(prerenderContext, concurrencyLimit, onComplete) {
     const globalContext = getGlobalContext();
     assert(globalContext.isPrerendering);
     // Route all URLs
@@ -471,7 +475,7 @@ async function routeAndPrerender(prerenderContext, htmlFiles, prerenderedPages,
             throw err;
         }
         const { documentHtml, pageContextSerialized } = res;
-        htmlFiles.push({
+        await onComplete({
             urlOriginal,
             pageContext,
             htmlString: documentHtml,
@@ -479,11 +483,10 @@ async function routeAndPrerender(prerenderContext, htmlFiles, prerenderedPages,
             doNotCreateExtraDirectory: prerenderContext._noExtraDir,
             pageId
         });
-        prerenderedPages[pageId] = pageContext;
     })));
 }
-function warnContradictoryNoPrerenderList(prerenderedPages, doNotPrerenderList) {
-    Object.entries(prerenderedPages).forEach(([pageId, pageContext]) => {
+function warnContradictoryNoPrerenderList(prerenderedPageContexts, doNotPrerenderList) {
+    Object.entries(prerenderedPageContexts).forEach(([pageId, pageContext]) => {
         const doNotPrerenderListEntry = doNotPrerenderList.find((p) => p.pageId === pageId);
         const { urlOriginal, _providedByHook: providedByHook } = pageContext;
         {
@@ -495,7 +498,7 @@ function warnContradictoryNoPrerenderList(prerenderedPages, doNotPrerenderList)
         assertWarning(false, `The ${providedByHook.hookName}() hook defined by ${providedByHook.hookFilePath} returns the URL ${pc.cyan(urlOriginal)}, while ${setByConfigFile} sets the config ${pc.cyan(setByConfigName)} to ${pc.cyan(String(setByConfigValue))}. This is contradictory: either don't set the config ${pc.cyan(setByConfigName)} to ${pc.cyan(String(setByConfigValue))} or remove the URL ${pc.cyan(urlOriginal)} from the list of URLs to be pre-rendered.`, { onlyOnce: true });
     });
 }
-function warnMissingPages(prerenderedPages, doNotPrerenderList, renderContext, partial) {
+function warnMissingPages(prerenderedPageContexts, doNotPrerenderList, renderContext, partial) {
     const isV1 = renderContext.pageConfigs.length > 0;
     const hookName = isV1 ? 'onBeforePrerenderStart' : 'prerender';
     /* TODO/after-v1-design-release: document setting `prerender: false` as an alternative to using prerender.partial (both in the warnings and the docs)
@@ -503,7 +506,7 @@ function warnMissingPages(prerenderedPages, doNotPrerenderList, renderContext, p
     const msgAddendum = `Explicitly opt-out by setting the config ${optOutName} to ${isV1 ? 'false' : 'true'} or use the option prerender.partial`
     */
     renderContext.allPageIds
-        .filter((pageId) => !prerenderedPages[pageId])
+        .filter((pageId) => !prerenderedPageContexts[pageId])
         .filter((pageId) => !doNotPrerenderList.find((p) => p.pageId === pageId))
         .filter((pageId) => !isErrorPage(pageId, renderContext.pageConfigs))
         .forEach((pageId) => {
@@ -511,8 +514,8 @@ function warnMissingPages(prerenderedPages, doNotPrerenderList, renderContext, p
         assertWarning(partial, `Cannot pre-render page ${pageAt} because it has a non-static route, while no ${hookName}() hook returned any URL matching the page's route. You need to use a ${hookName}() hook (https://vike.dev/${hookName}) providing a list of URLs for ${pageAt} that should be pre-rendered. If you don't want to pre-render ${pageAt} then use the option prerender.partial (https://vike.dev/prerender-config#partial) to suppress this warning.`, { onlyOnce: true });
     });
 }
-async function prerender404(htmlFiles, renderContext, prerenderContext) {
-    if (!htmlFiles.find(({ urlOriginal }) => urlOriginal === '/404')) {
+async function prerender404(prerenderedPageContexts, renderContext, prerenderContext, onComplete) {
+    if (!Object.values(prerenderedPageContexts).find(({ urlOriginal }) => urlOriginal === '/404')) {
         let result;
         try {
             result = await prerender404Page(renderContext, prerenderContext.pageContextInit);
@@ -524,7 +527,7 @@ async function prerender404(htmlFiles, renderContext, prerenderContext) {
         if (result) {
             const urlOriginal = '/404';
             const { documentHtml, pageContext } = result;
-            htmlFiles.push({
+            await onComplete({
                 urlOriginal,
                 pageContext,
                 htmlString: documentHtml,
@@ -535,59 +538,57 @@ async function prerender404(htmlFiles, renderContext, prerenderContext) {
         }
     }
 }
-async function writeHtmlFile({ urlOriginal, pageContext, htmlString, pageContextSerialized, doNotCreateExtraDirectory }, root, outDirClient, concurrencyLimit, onPagePrerender, logLevel) {
+async function writeFiles({ urlOriginal, pageContext, htmlString, pageContextSerialized, doNotCreateExtraDirectory }, root, outDirClient, onPagePrerender, logLevel) {
     assert(urlOriginal.startsWith('/'));
     const writeJobs = [
-        write(urlOriginal, pageContext, '.html', htmlString, root, outDirClient, doNotCreateExtraDirectory, concurrencyLimit, onPagePrerender, logLevel)
+        write(urlOriginal, pageContext, '.html', htmlString, root, outDirClient, doNotCreateExtraDirectory, onPagePrerender, logLevel)
     ];
     if (pageContextSerialized !== null) {
-        writeJobs.push(write(urlOriginal, pageContext, '.pageContext.json', pageContextSerialized, root, outDirClient, doNotCreateExtraDirectory, concurrencyLimit, onPagePrerender, logLevel));
+        writeJobs.push(write(urlOriginal, pageContext, '.pageContext.json', pageContextSerialized, root, outDirClient, doNotCreateExtraDirectory, onPagePrerender, logLevel));
     }
     await Promise.all(writeJobs);
 }
-function write(urlOriginal, pageContext, fileExtension, fileContent, root, outDirClient, doNotCreateExtraDirectory, concurrencyLimit, onPagePrerender, logLevel) {
-    return concurrencyLimit(async () => {
-        let fileUrl;
-        if (fileExtension === '.html') {
-            fileUrl = urlToFile(urlOriginal, '.html', doNotCreateExtraDirectory);
-        }
-        else {
-            fileUrl = getPageContextRequestUrl(urlOriginal);
-        }
-        assertPosixPath(fileUrl);
-        assert(fileUrl.startsWith('/'));
-        const filePathRelative = fileUrl.slice(1);
-        assert(!filePathRelative.startsWith('/'));
-        assertPosixPath(outDirClient);
-        assertPosixPath(filePathRelative);
-        const filePath = path.posix.join(outDirClient, filePathRelative);
-        if (onPagePrerender) {
-            const prerenderPageContext = {};
-            objectAssign(prerenderPageContext, pageContext);
-            objectAssign(prerenderPageContext, {
-                _prerenderResult: {
-                    filePath,
-                    fileContent
-                }
-            });
-            await onPagePrerender(prerenderPageContext);
-        }
-        else {
-            const { promises } = await import('fs');
-            const { writeFile, mkdir } = promises;
-            await mkdir(path.posix.dirname(filePath), { recursive: true });
-            await writeFile(filePath, fileContent);
-            if (logLevel === 'info') {
-                assertPosixPath(root);
-                assertPosixPath(outDirClient);
-                let outDirClientRelative = path.posix.relative(root, outDirClient);
-                if (!outDirClientRelative.endsWith('/')) {
-                    outDirClientRelative = outDirClientRelative + '/';
-                }
-                console.log(`${pc.dim(outDirClientRelative)}${pc.blue(filePathRelative)}`);
+async function write(urlOriginal, pageContext, fileExtension, fileContent, root, outDirClient, doNotCreateExtraDirectory, onPagePrerender, logLevel) {
+    let fileUrl;
+    if (fileExtension === '.html') {
+        fileUrl = urlToFile(urlOriginal, '.html', doNotCreateExtraDirectory);
+    }
+    else {
+        fileUrl = getPageContextRequestUrl(urlOriginal);
+    }
+    assertPosixPath(fileUrl);
+    assert(fileUrl.startsWith('/'));
+    const filePathRelative = fileUrl.slice(1);
+    assert(!filePathRelative.startsWith('/'));
+    assertPosixPath(outDirClient);
+    assertPosixPath(filePathRelative);
+    const filePath = path.posix.join(outDirClient, filePathRelative);
+    if (onPagePrerender) {
+        const prerenderPageContext = {};
+        objectAssign(prerenderPageContext, pageContext);
+        objectAssign(prerenderPageContext, {
+            _prerenderResult: {
+                filePath,
+                fileContent
+            }
+        });
+        await onPagePrerender(prerenderPageContext);
+    }
+    else {
+        const { promises } = await import('fs');
+        const { writeFile, mkdir } = promises;
+        await mkdir(path.posix.dirname(filePath), { recursive: true });
+        await writeFile(filePath, fileContent);
+        if (logLevel === 'info') {
+            assertPosixPath(root);
+            assertPosixPath(outDirClient);
+            let outDirClientRelative = path.posix.relative(root, outDirClient);
+            if (!outDirClientRelative.endsWith('/')) {
+                outDirClientRelative = outDirClientRelative + '/';
             }
+            console.log(`${pc.dim(outDirClientRelative)}${pc.blue(filePathRelative)}`);
         }
-    });
+    }
 }
 function normalizeOnPrerenderHookResult(prerenderResult, prerenderHookFile, hookName) {
     if (Array.isArray(prerenderResult)) {

package/dist/esm/node/runtime/html/injectAssets/injectAssets__public.js

@@ -1,7 +1,7 @@
 export { injectAssets__public };
 import { assertUsage, assertWarning, castProp, hasProp } from '../../utils.js';
 import { injectHtmlTagsToString } from '../injectAssets.js';
-// TODO: remove this on next semver major
+// TODO/v1-release: remove
 async function injectAssets__public(htmlString, pageContext) {
     assertWarning(false, '`_injectAssets()` is deprecated and will be removed.', { onlyOnce: true, showStackTrace: true });
     assertUsage(typeof htmlString === 'string', '[injectAssets(htmlString, pageContext)]: Argument `htmlString` should be a string.', { showStackTrace: true });

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/createHttpResponseObject/assertNoInfiniteHttpRedirect.d.ts

@@ -1,2 +1,2 @@
 export { assertNoInfiniteHttpRedirect };
-declare function assertNoInfiniteHttpRedirect(urlRedirectOriginal: string, urlRedirectPathnameLogical: string): void;
+declare function assertNoInfiniteHttpRedirect(urlRedirectTarget: string, urlLogical: string): void;

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

@@ -1,24 +1,24 @@
 export { assertNoInfiniteHttpRedirect };
-import { assert, assertUsage, getGlobalObject } from '../../utils.js';
+import { assert, assertUsage, getGlobalObject, isUriWithProtocol } from '../../utils.js';
 import pc from '@brillout/picocolors';
 const globalObject = getGlobalObject('assertNoInfiniteHttpRedirect.ts', {
     redirectGraph: {}
 });
-function assertNoInfiniteHttpRedirect(urlRedirectOriginal, urlRedirectPathnameLogical) {
-    if (urlRedirectOriginal.startsWith('http')) {
-        // We assume that the redirect points to an external origin, and we can therefore assume that the app doesn't define an infinite loop (in itself).
-        //  - There isn't a reliable way to check whether the redirect points to an external origin or the same origin: the user usually passes the URL without origin.
+function assertNoInfiniteHttpRedirect(urlRedirectTarget, urlLogical) {
+    if (isUriWithProtocol(urlRedirectTarget)) {
+        // We assume that urlRedirectTarget points to an origin that is external (not the same origin), and we can therefore assume that the app doesn't define an infinite loop (in itself).
+        //  - There isn't a reliable way to check whether the redirect points to an external origin or the same origin. For same origins, we assume/hope the user to pass the URL without origin.
         //    ```js
-        //    // URL origin is usually missing
+        //    // For same-origin, the user usually/hopefully passes a URL without origin
         //    renderPage({ urlOriginal: '/some/pathname' })
         //    ```
         return;
     }
-    assert(urlRedirectOriginal.startsWith('/'));
-    assert(urlRedirectPathnameLogical.startsWith('/'));
+    assert(urlRedirectTarget.startsWith('/'));
+    assert(urlLogical.startsWith('/'));
     const graph = copy(globalObject.redirectGraph);
-    graph[urlRedirectOriginal] ?? (graph[urlRedirectOriginal] = new Set());
-    graph[urlRedirectOriginal].add(urlRedirectPathnameLogical);
+    graph[urlRedirectTarget] ?? (graph[urlRedirectTarget] = new Set());
+    graph[urlRedirectTarget].add(urlLogical);
     validate(graph);
     globalObject.redirectGraph = graph;
 }
@@ -26,6 +26,9 @@ function copy(G) {
     return Object.fromEntries(Object.entries(G).map(([key, val]) => [key, new Set(val)]));
 }
 // Adapted from: https://stackoverflow.com/questions/60904464/detect-cycle-in-directed-graph/60907076#60907076
+function validate(G) {
+    Object.keys(G).forEach((n) => check(G, n, []));
+}
 function check(G, n, path) {
     if (path.includes(n)) {
         const cycle = path.slice(path.indexOf(n)).concat(n);
@@ -33,6 +36,3 @@ function check(G, n, path) {
     }
     G[n]?.forEach((node) => check(G, node, [...path, n]));
 }
-function validate(G) {
-    Object.keys(G).forEach((n) => check(G, n, []));
-}

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

@@ -25,4 +25,4 @@ declare function createHttpResponseObject(htmlRender: null | HtmlRender, renderH
     abortStatusCode?: AbortStatusCode;
 }): Promise<HttpResponse | null>;
 declare function createHttpResponsePageContextJson(pageContextSerialized: string): Promise<HttpResponse>;
-declare function createHttpResponseObjectRedirect({ url, statusCode }: UrlRedirect, urlPathnameLogical: string): HttpResponse;
+declare function createHttpResponseObjectRedirect({ url, statusCode }: UrlRedirect, urlLogical: string): HttpResponse;

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

@@ -33,9 +33,9 @@ async function createHttpResponsePageContextJson(pageContextSerialized) {
     return httpResponse;
 }
 function createHttpResponseObjectRedirect({ url, statusCode }, 
-// The URL pathname we assume the redirect to be logically based on
-urlPathnameLogical) {
-    assertNoInfiniteHttpRedirect(url, urlPathnameLogical);
+// The URL we assume the redirect to be logically based on
+urlLogical) {
+    assertNoInfiniteHttpRedirect(url, urlLogical);
     assert(url);
     assert(statusCode);
     assert(300 <= statusCode && statusCode <= 399);

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/getHttpResponseBody.js

@@ -7,7 +7,7 @@ import pc from '@brillout/picocolors';
 const streamDocs = 'See https://vike.dev/stream for more information.';
 function getHttpResponseBody(htmlRender, renderHook) {
     if (typeof htmlRender !== 'string') {
-        assertUsage(false, getErrMsg(htmlRender, renderHook, 'body', `Use ${pc.cyan('pageContext.httpResponse.pipe()')} or ${pc.cyan('pageContext.httpResponse.getBody()')} instead`));
+        assertUsage(false, getErrMsg(htmlRender, renderHook, 'body', `Use ${pc.cyan('pageContext.httpResponse.pipe()')} instead`));
     }
     const body = htmlRender;
     return body;