vike 0.4.250-commit-193dea3 → 0.4.250-commit-2686732

package/dist/shared-server-client/hooks/execHook.js

@@ -1,3 +1,4 @@
+// TODO: rename all exports
 export { execHook };
 export { execHookGlobal };
 export { execHookDirect };
@@ -5,10 +6,12 @@ export { execHookDirectSingle };
 export { execHookDirectSingleWithReturn };
 export { execHookDirectWithoutPageContext };
 export { execHookDirectSync };
+export { execHookBase };
 export { getPageContext_sync };
 export { providePageContext };
 export { isUserHookError };
-import { getProjectError, assertWarning, assertUsage } from '../../utils/assert.js';
+// TODO: minor refactor — maybe completely remove (some) utils.js files?
+import { assert, getProjectError, assertWarning, assertUsage } from '../../utils/assert.js';
 import { getGlobalObject } from '../../utils/getGlobalObject.js';
 import { humanizeTime } from '../../utils/humanizeTime.js';
 import { isObject } from '../../utils/isObject.js';
@@ -18,15 +21,16 @@ const globalObject = getGlobalObject('utils/execHook.ts', {
     userHookErrors: new WeakMap(),
     pageContext: null,
 });
+// TODO/refactor: export new type PageContextExecHookMinimum instead of PageContextPrepareMinimum ?
 async function execHook(hookName, pageContext, preparePageContextForPublicUsage) {
     const hooks = getHookFromPageContextNew(hookName, pageContext);
     return await execHookDirect(hooks, pageContext, preparePageContextForPublicUsage);
 }
-async function execHookGlobal(hookName, pageConfigGlobal, pageContext, hookArg, prepareForPublicUsage) {
-    const hooks = getHookFromPageConfigGlobalCumulative(pageConfigGlobal, hookName);
+async function execHookGlobal(hookName, globalContext, pageContext, hookArg, prepareForPublicUsage) {
+    const hooks = getHookFromPageConfigGlobalCumulative(globalContext._pageConfigGlobal, hookName);
     const hookArgForPublicUsage = prepareForPublicUsage(hookArg);
     await Promise.all(hooks.map(async (hook) => {
-        await execHookDirectAsync(() => hook.hookFn(hookArgForPublicUsage), hook, pageContext);
+        await execHookDirectAsync(() => hook.hookFn(hookArgForPublicUsage), hook, globalContext, pageContext);
     }));
 }
 async function execHookDirect(hooks, pageContext, preparePageContextForPublicUsage) {
@@ -34,7 +38,7 @@ async function execHookDirect(hooks, pageContext, preparePageContextForPublicUsa
         return [];
     const pageContextForPublicUsage = preparePageContextForPublicUsage(pageContext);
     const hooksWithResult = await Promise.all(hooks.map(async (hook) => {
-        const hookReturn = await execHookDirectAsync(() => hook.hookFn(pageContextForPublicUsage), hook, pageContextForPublicUsage);
+        const hookReturn = await execHookDirectAsync(() => hook.hookFn(pageContextForPublicUsage), hook, pageContext._globalContext, pageContextForPublicUsage);
         return { ...hook, hookReturn };
     }));
     return hooksWithResult;
@@ -54,12 +58,12 @@ function isUserHookError(err) {
         return false;
     return globalObject.userHookErrors.get(err) ?? false;
 }
-async function execHookDirectWithoutPageContext(hookFnCaller, hook) {
+async function execHookDirectWithoutPageContext(hookFnCaller, hook, globalContext) {
     const { hookName, hookFilePath, hookTimeout } = hook;
-    const hookReturn = await execHookDirectAsync(hookFnCaller, { hookName, hookFilePath, hookTimeout }, null);
+    const hookReturn = await execHookDirectAsync(hookFnCaller, { hookName, hookFilePath, hookTimeout }, globalContext, null);
     return hookReturn;
 }
-function execHookDirectAsync(hookFnCaller, hook, pageContextForPublicUsage) {
+function execHookDirectAsync(hookFnCaller, hook, globalContext, pageContextForPublicUsage) {
     const { hookName, hookFilePath, hookTimeout: { error: timeoutErr, warning: timeoutWarn }, } = hook;
     let resolve;
     let reject;
@@ -90,8 +94,7 @@ function execHookDirectAsync(hookFnCaller, hook, pageContextForPublicUsage) {
         }, timeoutErr);
     (async () => {
         try {
-            providePageContextInternal(pageContextForPublicUsage);
-            const ret = await hookFnCaller();
+            const ret = await execHookBase(hookFnCaller, hook, globalContext, pageContextForPublicUsage);
             resolve(ret);
         }
         catch (err) {
@@ -105,10 +108,72 @@ function execHookDirectAsync(hookFnCaller, hook, pageContextForPublicUsage) {
 }
 function execHookDirectSync(hook, pageContext, preparePageContextForPublicUsage) {
     const pageContextForPublicUsage = preparePageContextForPublicUsage(pageContext);
-    providePageContextInternal(pageContextForPublicUsage);
-    const hookReturn = hook.hookFn(pageContextForPublicUsage);
+    const hookReturn = execHookBase(() => hook.hookFn(pageContextForPublicUsage), hook, pageContext._globalContext, pageContextForPublicUsage);
     return { hookReturn };
 }
+// Every execHook* variant should call this
+function execHookBase(hookFnCaller, hook, globalContext, pageContext) {
+    const { hookName, hookFilePath } = hook;
+    assert(hookName !== 'onHookCall'); // ensure no infinite loop
+    const configValue = globalContext._pageConfigGlobal.configValues['onHookCall'];
+    const callOriginal = () => {
+        providePageContextInternal(pageContext);
+        return hookFnCaller();
+    };
+    // +onHookCall doesn't exist
+    if (!configValue?.value)
+        return callOriginal();
+    // +onHookCall wrapping
+    let originalCalled = false;
+    let originalReturn;
+    let originalError;
+    let call = () => {
+        originalCalled = true;
+        try {
+            originalReturn = callOriginal();
+        }
+        catch (err) {
+            originalError = err;
+        }
+        return originalReturn;
+    };
+    for (const onHookCall of configValue.value) {
+        const hookPublic = { name: hookName, filePath: hookFilePath, call };
+        // Recursively wrap callOriginal() so +onHookCall can use async hooks. (E.g. vike-react-sentry integrates Sentry's `Tracer.startActiveSpan()`.)
+        call = () => {
+            ;
+            (async () => {
+                try {
+                    await onHookCall(hookPublic, pageContext);
+                }
+                catch (err) {
+                    console.error(err);
+                    /* TO-DO/eventually: use dependency injection to be able to use logErrorServer() when this function runs on the server-side.
+                    if (
+                      !globalThis.__VIKE__IS_CLIENT &&
+                      pageContext &&
+                      // Avoid infinite loop
+                      hookName !== 'onError'
+                    ) {
+                      assert(!pageContext.isClientSide)
+                      logErrorServer(err, pageContext)
+                    } else {
+                      logErrorClient(err)
+                    }
+                    //*/
+                }
+            })();
+            // +onHookCall must run hook.call() before any `await` — https://github.com/vikejs/vike/pull/2978#discussion_r2645232953
+            assertUsage(originalCalled, 'onHookCall() must run hook.call()');
+            return originalReturn;
+        };
+    }
+    // Start the call() chain
+    call();
+    if (originalError)
+        throw originalError;
+    return originalReturn;
+}
 function isNotDisabled(timeout) {
     return !!timeout && timeout !== Infinity;
 }

package/dist/shared-server-client/prepareGlobalContextForPublicUsage.d.ts

@@ -1,8 +1,10 @@
 export { prepareGlobalContextForPublicUsage };
 export type { GlobalContextPrepareMinimum };
+import type { PageConfigGlobalRuntime } from '../types/PageConfig.js';
 type GlobalContextPrepareMinimum = {
     _isOriginalObject: true;
     isGlobalContext: true;
+    _pageConfigGlobal: PageConfigGlobalRuntime;
 };
 declare function prepareGlobalContextForPublicUsage<GlobalContext extends GlobalContextPrepareMinimum>(globalContext: GlobalContext): GlobalContext & {
     _isProxyObject: true;

package/dist/shared-server-client/preparePageContextForPublicUsage.d.ts

@@ -2,11 +2,10 @@ export { preparePageContextForPublicUsage };
 export { assertPropertyGetters };
 export type { PageContextPrepareMinimum };
 import { type GlobalContextPrepareMinimum } from './prepareGlobalContextForPublicUsage.js';
+import type { PageContextCreatedBase } from './createPageContextShared.js';
 type PageContextPrepareMinimum = {
-    _isOriginalObject: true;
-    isPageContext: true;
     _globalContext: GlobalContextPrepareMinimum;
-};
+} & PageContextCreatedBase;
 declare function preparePageContextForPublicUsage<PageContext extends PageContextPrepareMinimum>(pageContext: PageContext): PageContext & {
     _isProxyObject: true;
     _originalObject: PageContext;

package/dist/types/Config.d.ts

@@ -51,7 +51,7 @@ import type { ImportStringList } from '../node/vite/shared/importString.js';
 type HookNameOld = HookName | HookNameOldDesign;
 type HookName = HookNamePage | HookNameGlobal;
 type HookNamePage = 'onHydrationEnd' | 'onBeforePrerenderStart' | 'onBeforeRender' | 'onPageTransitionStart' | 'onPageTransitionEnd' | 'onRenderHtml' | 'onRenderClient' | 'guard' | 'data' | 'onData' | 'route';
-type HookNameGlobal = 'onBeforeRoute' | 'onPrerenderStart' | 'onCreatePageContext' | 'onCreateGlobalContext' | 'onError';
+type HookNameGlobal = 'onBeforeRoute' | 'onPrerenderStart' | 'onCreatePageContext' | 'onCreateGlobalContext' | 'onError' | 'onHookCall';
 type HookNameOldDesign = 'render' | 'prerender' | 'onBeforePrerender';
 type ConfigNameBuiltIn = Exclude<keyof ConfigBuiltIn, keyof VikeVitePluginOptions | 'onBeforeRoute' | 'onPrerenderStart' | 'vite' | 'redirects'> | 'prerender' | 'hasServerOnlyHook' | 'isClientRuntimeLoaded' | 'onBeforeRenderEnv' | 'dataEnv' | 'guardEnv' | 'hooksTimeout' | 'clientHooks' | 'middleware';
 type ConfigNameGlobal = 'onPrerenderStart' | 'onBeforeRoute' | 'prerender' | 'disableAutoFullBuild' | 'includeAssetsImportedByServer' | 'baseAssets' | 'baseServer' | 'redirects' | 'trailingSlash' | 'disableUrlNormalization' | 'vite';
@@ -265,76 +265,7 @@ type ConfigBuiltIn = {
      *
      * @default false
      */
-    prerender?: boolean | ImportStringList | {
-        /**
-         * Allow only some of your pages to be pre-rendered.
-         *
-         * This setting doesn't affect the pre-rendering process: it merely suppresses the warnings when some of your pages cannot be pre-rendered.
-         *
-         * https://vike.dev/prerender#partial
-         *
-         * @default false
-         */
-        partial?: boolean;
-        /**
-         * Whether +redirects should be pre-rendered to HTML documents that redirect the user.
-         *
-         * https://vike.dev/prerender#redirects
-         */
-        redirects?: boolean;
-        /**
-         * Don't create a new directory for each HTML file.
-         *
-         * For example, generate `dist/client/about.html` instead of `dist/client/about/index.html`.
-         *
-         * https://vike.dev/prerender#noextradir
-         *
-         * @default false
-         */
-        noExtraDir?: boolean;
-        /**
-         * Number of concurrent pre-render jobs.
-         *
-         * Set to `false` to disable concurrency.
-         *
-         * https://vike.dev/prerender#parallel
-         *
-         * @default os.cpus().length
-         */
-        parallel?: boolean | number;
-        /**
-         * Disable the automatic initiation of the pre-rendering process when running `$ vike build`.
-         *
-         * Use this if you want to programmatically initiate the pre-rendering process instead.
-         *
-         * https://vike.dev/prerender#disableautorun
-         *
-         * @default false
-         */
-        disableAutoRun?: boolean;
-        /**
-         * Whether to enable pre-rendering.
-         *
-         * Setting `enable: null` enables you to set prerender settings without enabling pre-rendering by default.
-         *
-         * This is useful, for example, if you want pre-rendering to stay opt-in instead of opt-out while setting pre-render settings globally.
-         *
-         * https://vike.dev/prerender#enable
-         *
-         * @default true
-         */
-        enable?: boolean | null;
-        /**
-         * If you pre-render all your pages then Vike removes the `dist/server/` directory after pre-rendering has finished.
-         *
-         * If you set this setting to `true` then Vike won't remove the `dist/server/` directory.
-         *
-         * https://vike.dev/prerender#keepDistServer
-         *
-         * @default false
-         */
-        keepDistServer?: boolean;
-    };
+    prerender?: PrerenderSetting | (() => PrerenderSetting | Promise<PrerenderSetting>) | ImportStringList;
     /**
      * Install Vike extensions.
      *
@@ -361,6 +292,15 @@ type ConfigBuiltIn = {
      *  https://vike.dev/onCreateGlobalContext
      */
     onCreateGlobalContext?: ((globalContext: GlobalContext) => void) | ImportStringList | null;
+    /** Called whenever a hook is called.
+     *
+     *  https://vike.dev/onHookCall
+     */
+    onHookCall?: ((hook: {
+        name: HookName;
+        filePath: string;
+        call: () => void | Promise<void>;
+    }, pageContext: PageContextClient | PageContextServer | null) => void | Promise<void>) | ImportStringList;
     /** Hook for fetching data.
      *
      *  https://vike.dev/data
@@ -595,6 +535,76 @@ type ConfigBuiltIn = {
      */
     staticReplace?: StaticReplace[];
 };
+type PrerenderSetting = boolean | {
+    /**
+     * Allow only some of your pages to be pre-rendered.
+     *
+     * This setting doesn't affect the pre-rendering process: it merely suppresses the warnings when some of your pages cannot be pre-rendered.
+     *
+     * https://vike.dev/prerender#partial
+     *
+     * @default false
+     */
+    partial?: boolean;
+    /**
+     * Whether +redirects should be pre-rendered to HTML documents that redirect the user.
+     *
+     * https://vike.dev/prerender#redirects
+     */
+    redirects?: boolean;
+    /**
+     * Don't create a new directory for each HTML file.
+     *
+     * For example, generate `dist/client/about.html` instead of `dist/client/about/index.html`.
+     *
+     * https://vike.dev/prerender#noextradir
+     *
+     * @default false
+     */
+    noExtraDir?: boolean;
+    /**
+     * Number of concurrent pre-render jobs.
+     *
+     * Set to `false` to disable concurrency.
+     *
+     * https://vike.dev/prerender#parallel
+     *
+     * @default os.cpus().length
+     */
+    parallel?: boolean | number;
+    /**
+     * Disable the automatic initiation of the pre-rendering process when running `$ vike build`.
+     *
+     * Use this if you want to programmatically initiate the pre-rendering process instead.
+     *
+     * https://vike.dev/prerender#disableautorun
+     *
+     * @default false
+     */
+    disableAutoRun?: boolean;
+    /**
+     * Whether to enable pre-rendering.
+     *
+     * Setting `enable: null` enables you to set prerender settings without enabling pre-rendering by default.
+     *
+     * This is useful, for example, if you want pre-rendering to stay opt-in instead of opt-out while setting pre-render settings globally.
+     *
+     * https://vike.dev/prerender#enable
+     *
+     * @default true
+     */
+    enable?: boolean | null;
+    /**
+     * If you pre-render all your pages then Vike removes the `dist/server/` directory after pre-rendering has finished.
+     *
+     * If you set this setting to `true` then Vike won't remove the `dist/server/` directory.
+     *
+     * https://vike.dev/prerender#keepDistServer
+     *
+     * @default false
+     */
+    keepDistServer?: boolean;
+};
 type ConfigBuiltInResolved = {
     passToClient?: string[][];
     redirects?: Record<string, string>[];

package/dist/types/Config.js

@@ -1 +1,2 @@
+// TODO: rename 'Hook called' Called
 export {};

package/dist/types/PageContext.d.ts

@@ -7,6 +7,7 @@ export type { PageContextInternalServer };
 export type { PageContextInternalClient };
 export type { PageContextInternalClient_ServerRouting };
 export type { PageContextInternalClient_ClientRouting };
+export type { PageContextInit };
 export type { PageContextBuiltInServer_deprecated as PageContextBuiltInServer };
 export type { PageContextBuiltInClientWithClientRouting_deprecated as PageContextBuiltInClientWithClientRouting };
 export type { PageContextBuiltInClientWithServerRouting_deprecated as PageContextBuiltInClientWithServerRouting };
@@ -56,29 +57,6 @@ type PageContextBuiltInCommon<Data> = PageContextConfig & {
      * https://vike.dev/pageContext#data
      */
     data: Data;
-    /** The URL you provided to Vike when calling `renderPage({ urlOriginal })` in your server middleware.
-     *
-     * https://vike.dev/renderPage
-     */
-    urlOriginal: string;
-    /**
-     * The HTTP request headers.
-     *
-     * As a string object normalized by Vike.
-     *
-     * https://vike.dev/headers
-     * https://vike.dev/pageContext#headers
-     */
-    headers: Record<string, string> | null;
-    /**
-     * The HTTP request headers.
-     *
-     * The original object provided by the server.
-     *
-     * https://vike.dev/headers
-     * https://vike.dev/pageContext#headersOriginal
-     */
-    headersOriginal?: unknown;
     /**
      * The HTTP response headers.
      *
@@ -128,8 +106,6 @@ type PageContextBuiltInCommon<Data> = PageContextConfig & {
     /** @experimental https://github.com/vikejs/vike/issues/1268 */
     sources: Sources;
     /** @deprecated */
-    url: string;
-    /** @deprecated */
     pageExports: Record<string, unknown>;
     /**
      * Whether the Base URL is missing in the URL of the HTTP request made to the SSR server.
@@ -139,7 +115,34 @@ type PageContextBuiltInCommon<Data> = PageContextConfig & {
      */
     isBaseMissing?: true;
 };
-type PageContextBuiltInServer<Data> = PageContextBuiltInCommon<Data> & PageContextUrlServer & {
+type PageContextInit = {
+    /** The URL provided when `renderPage({ urlOriginal })` is called.
+     *
+     * https://vike.dev/renderPage
+     */
+    urlOriginal: string;
+    /**
+     * The HTTP request headers.
+     *
+     * The original object provided by the server.
+     *
+     * https://vike.dev/headers
+     * https://vike.dev/pageContext#headersOriginal
+     */
+    headersOriginal?: unknown;
+    /** @deprecated Set `pageContextInit.urlOriginal` instead  */ url?: string;
+    /** @deprecated Set pageContextInit.headersOriginal instead */ headers?: Record<string, string>;
+};
+type PageContextBuiltInServer<Data> = PageContextBuiltInCommon<Data> & PageContextInit & PageContextUrlServer & {
+    /**
+     * The HTTP request headers.
+     *
+     * As a string object normalized by Vike.
+     *
+     * https://vike.dev/headers
+     * https://vike.dev/pageContext#headers
+     */
+    headers: Record<string, string> | null;
     /**
      * Whether the environment is the client-side:
      * - In the browser, the value is `true`.
@@ -182,6 +185,10 @@ type PageContextBuiltInServer<Data> = PageContextBuiltInCommon<Data> & PageConte
     previousPageContext?: undefined;
 };
 type PageContextBuiltInClientWithClientRouting<Data> = Partial<PageContextBuiltInCommon<Data>> & Pick<PageContextBuiltInCommon<Data>, 'Page' | 'routeParams' | 'pageExports' | 'config' | 'configEntries' | 'exports' | 'exportsAll' | 'abortReason' | 'data' | 'pageId' | 'source' | 'sources' | 'from'> & PageContextClientCommon & {
+    /**
+     * The current URL unprocessed (e.g. with the Base URL).
+     */
+    urlOriginal: string;
     /**
      * Whether the page is the first page rendered.
      *

package/dist/utils/PROJECT_VERSION.d.ts

@@ -1 +1 @@
-export declare const PROJECT_VERSION: "0.4.250-commit-193dea3";
+export declare const PROJECT_VERSION: "0.4.250-commit-2686732";

package/dist/utils/PROJECT_VERSION.js

@@ -1,2 +1,2 @@
 // Automatically updated by @brillout/release-me
-export const PROJECT_VERSION = '0.4.250-commit-193dea3';
+export const PROJECT_VERSION = '0.4.250-commit-2686732';

package/dist/utils/installUncaughtErrorHandlers.d.ts

@@ -0,0 +1,2 @@
+export { installUncaughtErrorHandlers };
+declare function installUncaughtErrorHandlers(): void;

package/dist/utils/installUncaughtErrorHandlers.js

@@ -0,0 +1,20 @@
+export { installUncaughtErrorHandlers };
+import { getGlobalObject } from './getGlobalObject.js';
+const globalObject = getGlobalObject('./installUncaughtErrorHandlers.ts', {
+    installed: false,
+});
+// Avoid server shutdown upon uncaught errors, e.g. `setTimeout(() => throw new Error('Uncaught error'), 10)`
+// If in the future we want to call +onError then let's use different handlers
+function installUncaughtErrorHandlers() {
+    if (globalObject.installed)
+        return;
+    globalObject.installed = true;
+    if (typeof process === 'undefined')
+        return;
+    process?.addListener?.('uncaughtException', (err) => {
+        console.error(err);
+    });
+    process?.addListener?.('unhandledRejection', (err) => {
+        console.error(err);
+    });
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vike",
-  "version": "0.4.250-commit-193dea3",
+  "version": "0.4.250-commit-2686732",
   "repository": "https://github.com/vikejs/vike",
   "exports": {
     "./server": {
@@ -124,7 +124,7 @@
     "@brillout/json-serializer": "^0.5.21",
     "@brillout/picocolors": "^1.0.30",
     "@brillout/require-shim": "^0.1.2",
-    "@brillout/vite-plugin-server-entry": "^0.7.15",
+    "@brillout/vite-plugin-server-entry": "^0.7.17",
     "cac": "^6.0.0",
     "es-module-lexer": "^1.0.0",
     "esbuild": ">=0.19.0",