vike 0.4.152-commit-6f928f9 → 0.4.153-commit-159c659

package/dist/esm/node/plugin/index.js

@@ -23,7 +23,7 @@ import { extensionsAssets } from './plugins/extensionsAssets.js';
 import { baseUrls } from './plugins/baseUrls.js';
 import { envVarsPlugin } from './plugins/envVars.js';
 import pc from '@brillout/picocolors';
-import { assertFileEnv } from './plugins/assertFileEnv.js';
+import { fileEnv } from './plugins/fileEnv.js';
 markEnvAsVite();
 // Return as `any` to avoid Plugin type mismatches when there are multiple Vite versions installed
 function plugin(vikeConfig) {
@@ -46,7 +46,7 @@ function plugin(vikeConfig) {
         extensionsAssets(),
         baseUrls(vikeConfig),
         envVarsPlugin(),
-        assertFileEnv()
+        fileEnv()
     ];
     return plugins;
 }

package/dist/esm/node/plugin/plugins/autoFullBuild.js

@@ -1,7 +1,7 @@
 export { autoFullBuild };
 import { build } from 'vite';
 import { assertWarning } from '../utils.js';
-import { prerenderFromAutoFullBuild, prerenderForceExit } from '../../prerender/runPrerender.js';
+import { runPrerenderFromAutoFullBuild, runPrerender_forceExit } from '../../prerender/runPrerender.js';
 import { getConfigVike } from '../../shared/getConfigVike.js';
 import { isViteCliCall, getViteConfigFromCli } from '../shared/isViteCliCall.js';
 import pc from '@brillout/picocolors';
@@ -45,7 +45,7 @@ function autoFullBuild() {
                 order: 'post',
                 handler() {
                     if (forceExit) {
-                        prerenderForceExit();
+                        runPrerender_forceExit();
                     }
                 }
             }
@@ -78,7 +78,7 @@ async function triggerFullBuild(config, configVike, bundle) {
         }
     });
     if (configVike.prerender && !configVike.prerender.disableAutoRun) {
-        await prerenderFromAutoFullBuild({ viteConfig: configInline });
+        await runPrerenderFromAutoFullBuild({ viteConfig: configInline });
         forceExit = true;
     }
 }

package/dist/esm/node/plugin/plugins/envVars.js

@@ -7,7 +7,7 @@ function envVarsPlugin() {
     let envsAll;
     let config;
     return {
-        name: 'vike:env',
+        name: 'vike:envVars',
         enforce: 'post',
         configResolved(config_) {
             config = config_;

package/dist/esm/node/plugin/plugins/fileEnv.d.ts

@@ -0,0 +1,3 @@
+export { fileEnv };
+import type { Plugin } from 'vite';
+declare function fileEnv(): Plugin;

package/dist/esm/node/plugin/plugins/{assertFileEnv.js → fileEnv.js}

@@ -1,13 +1,13 @@
-export { assertFileEnv };
+export { fileEnv };
 import { assert, assertUsage, assertWarning, capitalizeFirstLetter, getFilePathRelativeToUserRootDir } from '../utils.js';
 import { extractAssetsRE } from './extractAssetsPlugin.js';
 import { extractExportNamesRE } from './extractExportNamesPlugin.js';
 import pc from '@brillout/picocolors';
-function assertFileEnv() {
+function fileEnv() {
     let config;
     let isDev = false;
     return {
-        name: 'vike:assertFileEnv',
+        name: 'vike:fileEnv',
         // - We need to set `enforce: 'pre'` because, otherwise, the resolvedId() hook of Vite's internal plugin `vite:resolve` is called before and it doesn't seem to call `this.resolve()` which means that the resolveId() hook below is never called.
         //   - Vite's `vite:resolve` plugin: https://github.com/vitejs/vite/blob/d649daba7682791178b711d9a3e44a6b5d00990c/packages/vite/src/node/plugins/resolve.ts#L105
         // - It's actually a good thing if the resolveId() hook below is the first one to be called because it doesn't actually resolve any ID, so all other resolveId() hooks will be called as normal. And with `this.resolve()` we get the information we want from all other resolvedId() hooks.

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

@@ -829,7 +829,7 @@ function getConfigName(filePath) {
     if (isTmpFile(filePath))
         return null;
     const fileName = path.posix.basename(filePath);
-    assertNoUnexpectedPlusSign(filePath, fileName);
+    // assertNoUnexpectedPlusSign(filePath, fileName)
     const basename = fileName.split('.')[0];
     if (!basename.startsWith('+')) {
         return null;
@@ -839,14 +839,6 @@ function getConfigName(filePath) {
         return configName;
     }
 }
-function assertNoUnexpectedPlusSign(filePath, fileName) {
-    const dirs = path.posix.dirname(filePath).split('/');
-    dirs.forEach((dir, i) => {
-        const dirPath = dirs.slice(0, i + 1).join('/');
-        assertUsage(!dir.includes('+'), `Character '+' is a reserved character: remove '+' from the directory name ${dirPath}/`);
-    });
-    assertUsage(!fileName.slice(1).includes('+'), `Character '+' is only allowed at the beginning of filenames: make sure ${filePath} doesn't contain any '+' in its filename other than its first letter`);
-}
 async function loadConfigFile(configFilePath, userRootDir, visited) {
     const { filePathAbsoluteFilesystem } = configFilePath;
     assertNoInfiniteLoop(visited, filePathAbsoluteFilesystem);

package/dist/esm/node/prerender/index.d.ts

@@ -1 +1 @@
-export { prerenderFromAPI as prerender } from './runPrerender.js';
+export { runPrerenderFromAPI as prerender } from './runPrerender.js';

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

@@ -1 +1 @@
-export { prerenderFromAPI as prerender } from './runPrerender.js';
+export { runPrerenderFromAPI as prerender } from './runPrerender.js';

package/dist/esm/node/prerender/runPrerender.d.ts

@@ -1,7 +1,7 @@
-export { prerenderFromAPI };
-export { prerenderFromCLI };
-export { prerenderFromAutoFullBuild };
-export { prerenderForceExit };
+export { runPrerenderFromAPI };
+export { runPrerenderFromCLI };
+export { runPrerenderFromAutoFullBuild };
+export { runPrerender_forceExit };
 export type { PrerenderOptions };
 import '../runtime/page-files/setup.js';
 import type { InlineConfig } from 'vite';
@@ -47,7 +47,7 @@ type PrerenderOptions = {
     /** @deprecated */
     base?: string;
 };
-declare function prerenderFromAPI(options?: PrerenderOptions): Promise<void>;
-declare function prerenderFromCLI(options: PrerenderOptions): Promise<void>;
-declare function prerenderFromAutoFullBuild(options: PrerenderOptions): Promise<void>;
-declare function prerenderForceExit(): void;
+declare function runPrerenderFromAPI(options?: PrerenderOptions): Promise<void>;
+declare function runPrerenderFromCLI(options: PrerenderOptions): Promise<void>;
+declare function runPrerenderFromAutoFullBuild(options: PrerenderOptions): Promise<void>;
+declare function runPrerender_forceExit(): void;

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

@@ -1,11 +1,11 @@
-export { prerenderFromAPI };
-export { prerenderFromCLI };
-export { prerenderFromAutoFullBuild };
-export { prerenderForceExit };
+export { runPrerenderFromAPI };
+export { runPrerenderFromCLI };
+export { runPrerenderFromAutoFullBuild };
+export { runPrerender_forceExit };
 import '../runtime/page-files/setup.js';
 import path from 'path';
 import { route } from '../../shared/route/index.js';
-import { assert, assertUsage, assertWarning, hasProp, projectInfo, objectAssign, isObjectWithKeys, isCallable, getOutDirs, isPropertyGetter, assertPosixPath, urlToFile, executeHook, isPlainObject, setNodeEnvToProduction } from './utils.js';
+import { assert, assertUsage, assertWarning, hasProp, projectInfo, objectAssign, isObjectWithKeys, isCallable, getOutDirs, isPropertyGetter, assertPosixPath, urlToFile, executeHook, isPlainObject, setNodeEnvToProduction, isUserHookError } from './utils.js';
 import { pLimit } from '../../utils/pLimit.js';
 import { prerenderPage, prerender404Page, getRenderContext, getPageContextInitEnhanced } from '../runtime/renderPage/renderPageAlreadyRouted.js';
 import pc from '@brillout/picocolors';
@@ -22,21 +22,22 @@ 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 { getHookFromPageConfig, getHookFromPageConfigGlobal, getHookTimeoutDefault } from '../../shared/hooks/getHook.js';
+import { loadUserFilesServerSide } from '../runtime/renderPage/loadUserFilesServerSide.js';
+import { getHookFromPageConfig, getHookFromPageConfigGlobal, getHookTimeoutDefault, setIsPrerenderering } 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 = {}) {
+async function runPrerenderFromAPI(options = {}) {
     await runPrerender(options, 'prerender()');
 }
-async function prerenderFromCLI(options) {
+async function runPrerenderFromCLI(options) {
     await runPrerender(options, '$ vike prerender');
 }
-async function prerenderFromAutoFullBuild(options) {
+async function runPrerenderFromAutoFullBuild(options) {
     await runPrerender(options, null);
 }
 async function runPrerender(options, manuallyTriggered) {
     checkOutdatedOptions(options);
+    setIsPrerenderering();
     const logLevel = !!options.onPagePrerender ? 'warn' : 'info';
     if (logLevel === 'info') {
         console.log(`${pc.cyan(`vike v${projectInfo.projectVersion}`)} ${pc.green('pre-rendering HTML...')}`);
@@ -269,7 +270,7 @@ async function handlePagesWithStaticRoutes(prerenderContext, renderContext, doNo
                 }
             ]
         });
-        objectAssign(pageContext, await loadPageFilesServerSide(pageContext));
+        objectAssign(pageContext, await loadUserFilesServerSide(pageContext));
         prerenderContext.pageContexts.push(pageContext);
     })));
 }
@@ -449,7 +450,7 @@ async function routeAndPrerender(prerenderContext, concurrencyLimit, onComplete)
         assert(pageContextFromRoute._pageId);
         objectAssign(pageContext, pageContextFromRoute);
         const { _pageId: pageId } = pageContext;
-        objectAssign(pageContext, await loadPageFilesServerSide(pageContext));
+        objectAssign(pageContext, await loadUserFilesServerSide(pageContext));
         let usesClientRouter;
         {
             if (pageContext._pageConfigs.length > 0) {
@@ -672,7 +673,7 @@ function isSameUrl(url1, url2) {
 function normalizeUrl(url) {
     return '/' + url.split('/').filter(Boolean).join('/');
 }
-function prerenderForceExit() {
+function runPrerender_forceExit() {
     // Force exit; known situations where pre-rendering is hanging:
     //  - https://github.com/vikejs/vike/discussions/774#discussioncomment-5584551
     //  - https://github.com/vikejs/vike/issues/807#issuecomment-1519010902
@@ -686,5 +687,12 @@ function assertIsNotAbort(err, urlOr404) {
     if (!isAbortError(err))
         return;
     const pageContextAbort = err._pageContextAbort;
-    assertUsage(false, `${pc.cyan(pageContextAbort._abortCall)} intercepted while pre-rendering ${urlOr404} but ${pc.cyan(pageContextAbort._abortCaller)} isn't supported for pre-rendered pages`);
+    const hookLoc = isUserHookError(err);
+    assert(hookLoc);
+    const thrownBy = ` by ${pc.cyan(`${hookLoc.hookName}()`)} hook defined at ${hookLoc.hookFilePath}`;
+    const abortCaller = pageContextAbort._abortCaller;
+    assert(abortCaller);
+    const abortCall = pageContextAbort._abortCall;
+    assert(abortCall);
+    assertUsage(false, `${pc.cyan(abortCall)} thrown${thrownBy} while pre-rendering ${urlOr404} but ${pc.cyan(abortCaller)} isn't supported for pre-rendered pages`);
 }

package/dist/esm/node/runtime/html/serializePageContextClientSide.d.ts

@@ -9,7 +9,6 @@ type PageContextSerialization = {
     _pageConfigs: PageConfigRuntime[];
     is404: null | boolean;
     pageProps?: Record<string, unknown>;
-    _isError?: true;
     _pageContextInit: Record<string, unknown>;
 };
 declare function serializePageContextClientSide(pageContext: PageContextSerialization): string;

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

@@ -6,6 +6,8 @@ import { isErrorPage } from '../../../shared/error-page.js';
 import { addIs404ToPageProps } from '../../../shared/addIs404ToPageProps.js';
 import pc from '@brillout/picocolors';
 import { notSerializable } from '../../../shared/notSerializable.js';
+import { pageContextInitIsPassedToClient } from '../../../shared/misc/pageContextInitIsPassedToClient.js';
+import { isRenderFailure } from '../../../shared/misc/isRenderFailure.js';
 const PASS_TO_CLIENT = [
     'abortReason',
     '_urlRewrite',
@@ -15,11 +17,11 @@ const PASS_TO_CLIENT = [
     /* Not needed on the client-side
     '_abortCaller',
     */
-    '_pageContextInitHasClientData',
+    pageContextInitIsPassedToClient,
     '_pageId',
     'data' // for data() hook
 ];
-const PASS_TO_CLIENT_ERROR_PAGE = ['pageProps', 'is404', '_isError'];
+const PASS_TO_CLIENT_ERROR_PAGE = ['pageProps', 'is404', isRenderFailure];
 function serializePageContextClientSide(pageContext) {
     const passToClient = getPassToClient(pageContext);
     const pageContextClient = {};
@@ -28,7 +30,7 @@ function serializePageContextClientSide(pageContext) {
         pageContextClient[prop] = pageContext[prop];
     });
     if (Object.keys(pageContext._pageContextInit).some((p) => passToClient.includes(p))) {
-        pageContextClient._pageContextInitHasClientData = true;
+        pageContextClient._pageContextInitIsPassedToClient = true;
     }
     let pageContextSerialized;
     try {

package/dist/esm/node/runtime/renderPage/{loadPageFilesServerSide.d.ts → loadUserFilesServerSide.d.ts}

@@ -1,20 +1,20 @@
-export { loadPageFilesServerSide };
+export { loadUserFilesServerSide };
 export type { PageFiles };
-export type { PageContext_loadPageFilesServerSide };
+export type { PageContext_loadUserFilesServerSide };
 import { type PageFile } from '../../../shared/getPageFiles.js';
 import { PromiseType } from '../utils.js';
 import { PageContextGetPageAssets, type PageAsset } from './getPageAssets.js';
 import { type PageContextDebugRouteMatches } from './debugPageFiles.js';
 import type { PageConfigRuntime } from '../../../shared/page-configs/PageConfig.js';
-type PageContext_loadPageFilesServerSide = PageContextGetPageAssets & PageContextDebugRouteMatches & {
+type PageContext_loadUserFilesServerSide = PageContextGetPageAssets & PageContextDebugRouteMatches & {
     urlOriginal: string;
     _pageFilesAll: PageFile[];
     _pageConfigs: PageConfigRuntime[];
 };
-type PageFiles = PromiseType<ReturnType<typeof loadPageFilesServerSide>>;
-declare function loadPageFilesServerSide(pageContext: {
+type PageFiles = PromiseType<ReturnType<typeof loadUserFilesServerSide>>;
+declare function loadUserFilesServerSide(pageContext: {
     _pageId: string;
-} & PageContext_loadPageFilesServerSide): Promise<{
+} & PageContext_loadUserFilesServerSide): Promise<{
     config: Record<string, unknown>;
     configEntries: import("../../../shared/getPageFiles/getExports.js").ConfigEntries;
     exports: Record<string, unknown>;

package/dist/esm/node/runtime/renderPage/{loadPageFilesServerSide.js → loadUserFilesServerSide.js}

@@ -1,4 +1,4 @@
-export { loadPageFilesServerSide };
+export { loadUserFilesServerSide };
 import { getExportUnion, getPageFilesServerSide, getExports } from '../../../shared/getPageFiles.js';
 import { analyzePageClientSideInit } from '../../../shared/getPageFiles/analyzePageClientSide.js';
 import { assertWarning, objectAssign } from '../utils.js';
@@ -8,10 +8,10 @@ import { findPageConfig } from '../../../shared/page-configs/findPageConfig.js';
 import { analyzePage } from './analyzePage.js';
 import { getGlobalContext } from '../globalContext.js';
 import { loadConfigValues } from '../../../shared/page-configs/loadConfigValues.js';
-async function loadPageFilesServerSide(pageContext) {
+async function loadUserFilesServerSide(pageContext) {
     const pageConfig = findPageConfig(pageContext._pageConfigs, pageContext._pageId); // Make pageConfig globally available as pageContext._pageConfig?
     const [{ config, configEntries, exports, exportsAll, pageExports, pageFilesLoaded, pageConfigLoaded }] = await Promise.all([
-        loadPageFiles(pageContext._pageFilesAll, pageConfig, pageContext._pageId, !getGlobalContext().isProduction),
+        loadPageUserFiles(pageContext._pageFilesAll, pageConfig, pageContext._pageId, !getGlobalContext().isProduction),
         analyzePageClientSideInit(pageContext._pageFilesAll, pageContext._pageId, { sharedPageFilesAlreadyLoaded: true })
     ]);
     const { isHtmlOnly, isClientRouting, clientEntries, clientDependencies, pageFilesClientSide, pageFilesServerSide } = analyzePage(pageContext._pageFilesAll, pageConfig, pageContext._pageId);
@@ -80,7 +80,7 @@ async function loadPageFilesServerSide(pageContext) {
     }
     return pageContextAddendum;
 }
-async function loadPageFiles(pageFilesAll, pageConfig, pageId, isDev) {
+async function loadPageUserFiles(pageFilesAll, pageConfig, pageId, isDev) {
     const pageFilesServerSide = getPageFilesServerSide(pageFilesAll, pageId);
     const pageConfigLoaded = !pageConfig ? null : await loadConfigValues(pageConfig, isDev);
     await Promise.all(pageFilesServerSide.map((p) => p.loadFile?.()));

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

@@ -9,7 +9,7 @@ export type { PageContextInitEnhanced };
 import { type PageFile } from '../../../shared/getPageFiles.js';
 import { type PageContextUrlComputedPropsInternal } from '../../../shared/addUrlComputedProps.js';
 import { HttpResponse } from './createHttpResponseObject.js';
-import { PageContext_loadPageFilesServerSide, type PageFiles } from './loadPageFilesServerSide.js';
+import { PageContext_loadUserFilesServerSide, type PageFiles } from './loadUserFilesServerSide.js';
 import type { PageConfigRuntime, PageConfigGlobalRuntime } from '../../../shared/page-configs/PageConfig.js';
 import { type PageRoutes } from '../../../shared/route/loadPageRoutes.js';
 import type { Hook } from '../../../shared/hooks/getHook.js';
@@ -24,7 +24,7 @@ declare function renderPageAlreadyRouted<PageContext extends {
     routeParams: Record<string, string>;
     errorWhileRendering: null | Error;
     _httpRequestId: number;
-} & PageContextInitEnhanced & PageContextUrlComputedPropsInternal & PageContext_loadPageFilesServerSide>(pageContext: PageContext): Promise<PageContext & PageContextAfterRender>;
+} & PageContextInitEnhanced & PageContextUrlComputedPropsInternal & PageContext_loadUserFilesServerSide>(pageContext: PageContext): Promise<PageContext & PageContextAfterRender>;
 declare function prerenderPage(pageContext: PageContextInitEnhanced & PageFiles & {
     routeParams: Record<string, string>;
     _pageId: string;

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

@@ -11,7 +11,7 @@ import { serializePageContextClientSide } from '../html/serializePageContextClie
 import { addUrlComputedProps } from '../../../shared/addUrlComputedProps.js';
 import { getGlobalContext } from '../globalContext.js';
 import { createHttpResponseObject, createHttpResponsePageContextJson } from './createHttpResponseObject.js';
-import { loadPageFilesServerSide } from './loadPageFilesServerSide.js';
+import { loadUserFilesServerSide } from './loadUserFilesServerSide.js';
 import { executeOnRenderHtmlHook } from './executeOnRenderHtmlHook.js';
 import { executeOnBeforeRenderAndDataHooks } from './executeOnBeforeRenderAndDataHooks.js';
 import { logRuntimeError } from './loggerRuntime.js';
@@ -21,6 +21,7 @@ import { executeGuardHook } from '../../../shared/route/executeGuardHook.js';
 import { loadPageRoutes } from '../../../shared/route/loadPageRoutes.js';
 import pc from '@brillout/picocolors';
 import { getConfigValueFilePathToShowToUser } from '../../../shared/page-configs/helpers.js';
+import { isRenderFailure } from '../../../shared/misc/isRenderFailure.js';
 async function renderPageAlreadyRouted(pageContext) {
     // pageContext._pageId can either be the:
     //  - ID of the page matching the routing, or the
@@ -28,7 +29,7 @@ async function renderPageAlreadyRouted(pageContext) {
     assert(hasProp(pageContext, '_pageId', 'string'));
     const isError = pageContext.is404 || !!pageContext.errorWhileRendering;
     assert(isError === (pageContext._pageId === getErrorPageId(pageContext._pageFilesAll, pageContext._pageConfigs)));
-    objectAssign(pageContext, await loadPageFilesServerSide(pageContext));
+    objectAssign(pageContext, await loadUserFilesServerSide(pageContext));
     if (!isError) {
         await executeGuardHook(pageContext, (pageContext) => preparePageContextForUserConsumptionServerSide(pageContext));
     }
@@ -47,7 +48,7 @@ async function renderPageAlreadyRouted(pageContext) {
     }
     if (pageContext.isClientSideNavigation) {
         if (isError) {
-            objectAssign(pageContext, { _isError: true });
+            objectAssign(pageContext, { [isRenderFailure]: true });
         }
         const pageContextSerialized = serializePageContextClientSide(pageContext);
         const httpResponse = await createHttpResponsePageContextJson(pageContextSerialized);
@@ -112,7 +113,7 @@ async function prerender404Page(renderContext, pageContextInit_) {
         const pageContextInitEnhanced = getPageContextInitEnhanced(pageContextInit, renderContext);
         objectAssign(pageContext, pageContextInitEnhanced);
     }
-    objectAssign(pageContext, await loadPageFilesServerSide(pageContext));
+    objectAssign(pageContext, await loadUserFilesServerSide(pageContext));
     return prerenderPage(pageContext);
 }
 function getPageContextInitEnhanced(pageContextInit, renderContext, { urlComputedPropsNonEnumerable = false, ssr: { urlRewrite, urlHandler, isClientSideNavigation } = {

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

@@ -16,7 +16,7 @@ import pc from '@brillout/picocolors';
 import { serializePageContextAbort, serializePageContextClientSide } from './html/serializePageContextClientSide.js';
 import { getErrorPageId } from '../../shared/error-page.js';
 import { handleErrorWithoutErrorPage } from './renderPage/handleErrorWithoutErrorPage.js';
-import { loadPageFilesServerSide } from './renderPage/loadPageFilesServerSide.js';
+import { loadUserFilesServerSide } from './renderPage/loadUserFilesServerSide.js';
 import { resolveRedirects } from '../../shared/route/resolveRedirects.js';
 const globalObject = getGlobalObject('runtime/renderPage.ts', {
     httpRequestsCount: 0,
@@ -384,7 +384,7 @@ async function handleAbortError(errAbort, pageContextsFromRewrite, pageContextIn
                 ...pageContextErrorPageInit,
                 ...renderContext
             };
-            objectAssign(pageContext, await loadPageFilesServerSide(pageContext));
+            objectAssign(pageContext, await loadUserFilesServerSide(pageContext));
             // We include pageContextInit: we don't only serialize pageContextAbort because the error page may need to access pageContextInit
             pageContextSerialized = serializePageContextClientSide(pageContext);
         }

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

@@ -2,6 +2,7 @@ export { getHook };
 export { getHookFromPageConfig };
 export { getHookFromPageConfigGlobal };
 export { assertHook };
+export { setIsPrerenderering };
 export type { Hook };
 export type { HookName };
 export type { HookLoc };
@@ -32,3 +33,4 @@ declare function assertHook<TPageContext extends PageContextExports, THookName e
     exports: Record<THookName, Function | undefined>;
 };
 declare function getHookTimeoutDefault(hookName: HookName): HookTimeout;
+declare function setIsPrerenderering(): void;

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

@@ -2,12 +2,17 @@ export { getHook };
 export { getHookFromPageConfig };
 export { getHookFromPageConfigGlobal };
 export { assertHook };
+export { setIsPrerenderering };
 // TODO/v1-release: remove
 // We export for old V0.4 design which doesn't support config.hooksTimeout
 export { getHookTimeoutDefault };
+import { getGlobalObject } from '../../utils/getGlobalObject.js';
 import { getConfigValue, getHookFilePathToShowToUser } from '../page-configs/helpers.js';
 import { assert, assertUsage, checkType, isCallable, isObject } from '../utils.js';
 import pc from '@brillout/picocolors';
+const globalObject = getGlobalObject('getHook.ts', {
+    isPrerendering: false
+});
 function getHook(pageContext, hookName) {
     if (!(hookName in pageContext.exports)) {
         return null;
@@ -110,19 +115,20 @@ function getHookTimeoutDefault(hookName) {
             warning: 1 * 1000
         };
     }
-    if (hookName === 'onPrerenderStart' ||
-        hookName === 'onBeforePrerenderStart' ||
-        // TODO/v1-release: remove
-        // Old V0.4 design hooks (https://vike.dev/migration/v1-design#renamed-hooks)
-        hookName === 'onBeforePrerender' ||
-        hookName === 'prerender') {
+    if (globalObject.isPrerendering) {
         return {
-            error: 10 * 60 * 1000,
+            error: 2 * 60 * 1000,
             warning: 30 * 1000
         };
     }
+    else {
+        assert(!hookName.toLowerCase().includes('prerender'));
+    }
     return {
         error: 30 * 1000,
         warning: 4 * 1000
     };
 }
+function setIsPrerenderering() {
+    globalObject.isPrerendering = true;
+}

package/dist/esm/shared/misc/isRenderFailure.d.ts

@@ -0,0 +1 @@
+export declare const isRenderFailure = "_isRenderFailure";

package/dist/esm/shared/misc/isRenderFailure.js

@@ -0,0 +1 @@
+export const isRenderFailure = '_isRenderFailure';

package/dist/esm/shared/misc/pageContextInitIsPassedToClient.d.ts

@@ -0,0 +1 @@
+export declare const pageContextInitIsPassedToClient = "_pageContextInitIsPassedToClient";

package/dist/esm/shared/misc/pageContextInitIsPassedToClient.js

@@ -0,0 +1 @@
+export const pageContextInitIsPassedToClient = '_pageContextInitIsPassedToClient';

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

@@ -57,7 +57,7 @@ declare function render(abortStatusCode: 401 | 403 | 404 | 410 | 429 | 500 | 503
  * @param abortReason Sets `pageContext.abortReason` which is used by the error page to show a message to the user, see https://vike.dev/error-page
  */
 declare function render(url: `/${string}`, abortReason?: AbortReason): Error;
-type AbortCall = `throw redirect(${string})` | `throw render(${string})` | `throw RenderErrorPage()`;
+type AbortCall = `redirect(${string})` | `render(${string})` | `RenderErrorPage()`;
 type PageContextAbort = {
     _abortCall: AbortCall;
 } & (({

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

@@ -7,7 +7,7 @@ export { logAbortErrorHandled };
 export { getPageContextFromAllRewrites };
 export { AbortRender };
 export { assertNoInfiniteAbortLoop };
-import { assert, assertInfo, assertUsage, assertWarning, checkType, hasProp, joinEnglish, objectAssign, projectInfo, truncateString } from './utils.js';
+import { assert, assertInfo, assertUsage, assertWarning, checkType, hasProp, isUserHookError, joinEnglish, objectAssign, projectInfo, truncateString } from './utils.js';
 import pc from '@brillout/picocolors';
 /**
  * Abort the rendering of the current page, and redirect the user to another URL instead.
@@ -30,7 +30,7 @@ function redirect(url, statusCode) {
     const pageContextAbort = {};
     objectAssign(pageContextAbort, {
         _abortCaller: abortCaller,
-        _abortCall: `throw redirect(${args.join(', ')})`,
+        _abortCall: `redirect(${args.join(', ')})`,
         _urlRedirect: {
             url,
             statusCode
@@ -43,7 +43,7 @@ function render(value, abortReason) {
     if (abortReason !== undefined)
         args.push(truncateString(JSON.stringify(abortReason), 30));
     const abortCaller = 'throw render()';
-    const abortCall = `throw render(${args.join(', ')})`;
+    const abortCall = `render(${args.join(', ')})`;
     return render_(value, abortReason, abortCall, abortCaller);
 }
 function render_(value, abortReason, abortCall, abortCaller, pageContextAddendum) {
@@ -92,7 +92,7 @@ function RenderErrorPage({ pageContext = {} } = {}) {
         abortReason = 'Something went wrong';
     }
     objectAssign(pageContext, { _isLegacyRenderErrorPage: true });
-    return render_(abortStatusCode, abortReason, 'throw RenderErrorPage()', 'throw RenderErrorPage()', pageContext);
+    return render_(abortStatusCode, abortReason, 'RenderErrorPage()', 'throw RenderErrorPage()', pageContext);
 }
 const stamp = '_isAbortError';
 function isAbortError(thing) {
@@ -115,7 +115,18 @@ function logAbortErrorHandled(err, isProduction, pageContext) {
     const urlCurrent = pageContext._urlRewrite ?? pageContext.urlOriginal;
     assert(urlCurrent);
     const abortCall = err._pageContextAbort._abortCall;
-    assertInfo(false, `${pc.cyan(abortCall)} intercepted while rendering ${pc.cyan(urlCurrent)}`, { onlyOnce: false });
+    assert(abortCall);
+    const hookLoc = isUserHookError(err);
+    let thrownBy = '';
+    if (hookLoc) {
+        thrownBy = ` by ${pc.cyan(`${hookLoc.hookName}()`)} hook defined at ${hookLoc.hookFilePath}`;
+    }
+    else {
+        // hookLoc is missing when serializing abort errors from server to client
+    }
+    assertInfo(false, `${pc.cyan(abortCall)} thrown${thrownBy} while rendering ${pc.cyan(urlCurrent)}`, {
+        onlyOnce: false
+    });
 }
 function assertStatusCode(statusCode, expected, caller) {
     const expectedEnglish = joinEnglish(expected.map((s) => s.toString()), 'or');

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

@@ -16,7 +16,6 @@ pageFilesAll, pageConfigs, pageConfigGlobal, allPageIds) {
 }
 function getPageRoutes(filesystemRoots, pageFilesAll, pageConfigs, allPageIds) {
     const pageRoutes = [];
-    let pageIds = [...allPageIds];
     // V1 Design
     if (pageConfigs.length > 0) {
         assert(filesystemRoots === null);
@@ -25,7 +24,6 @@ function getPageRoutes(filesystemRoots, pageFilesAll, pageConfigs, allPageIds) {
             .filter((p) => !p.isErrorPage)
             .forEach((pageConfig) => {
             const pageId = pageConfig.pageId;
-            pageIds = removePageId(pageIds, pageId);
             let pageRoute = null;
             {
                 const configName = 'route';
@@ -79,7 +77,7 @@ function getPageRoutes(filesystemRoots, pageFilesAll, pageConfigs, allPageIds) {
     if (pageConfigs.length === 0) {
         assert(filesystemRoots);
         const comesFromV1PageConfig = false;
-        pageIds
+        allPageIds
             .filter((pageId) => !isErrorPageId(pageId, false))
             .forEach((pageId) => {
             const pageRouteFile = pageFilesAll.find((p) => p.pageId === pageId && p.fileType === '.page.route');
@@ -179,9 +177,3 @@ function dirname(filePath) {
     assert(!dirPath.endsWith('/') || dirPath === '/');
     return dirPath;
 }
-function removePageId(pageIds, pageId) {
-    const { length } = pageIds;
-    pageIds = pageIds.filter((id) => id !== pageId);
-    assert(pageIds.length === length - 1);
-    return pageIds;
-}

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

@@ -1,13 +1,13 @@
 export { projectInfo };
 export type { ProjectTag };
 export { PROJECT_VERSION };
-declare const PROJECT_VERSION: "0.4.152-commit-6f928f9";
+declare const PROJECT_VERSION: "0.4.153-commit-159c659";
 type PackageName = typeof projectInfo.npmPackageName;
 type ProjectVersion = typeof projectInfo.projectVersion;
 type ProjectTag = `[${PackageName}]` | `[${PackageName}@${ProjectVersion}]`;
 declare const projectInfo: {
     projectName: "Vike";
-    projectVersion: "0.4.152-commit-6f928f9";
+    projectVersion: "0.4.153-commit-159c659";
     npmPackageName: "vike";
     githubRepository: "https://github.com/vikejs/vike";
 };

package/dist/esm/utils/projectInfo.js

@@ -1,7 +1,7 @@
 export { projectInfo };
 export { PROJECT_VERSION };
 import { onProjectInfo } from './assertSingleInstance.js';
-const PROJECT_VERSION = '0.4.152-commit-6f928f9';
+const PROJECT_VERSION = '0.4.153-commit-159c659';
 const projectInfo = {
     projectName: 'Vike',
     projectVersion: PROJECT_VERSION,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vike",
-  "version": "0.4.152-commit-6f928f9",
+  "version": "0.4.153-commit-159c659",
   "scripts": {
     "dev": "tsc --watch",
     "build": "rimraf dist/ && pnpm run build:esm && pnpm run build:cjs",

package/dist/esm/node/plugin/plugins/assertFileEnv.d.ts

@@ -1,3 +0,0 @@
-export { assertFileEnv };
-import type { Plugin } from 'vite';
-declare function assertFileEnv(): Plugin;