vike 0.4.229 → 0.4.230-commit-dd11364

package/dist/esm/shared/createGlobalContextShared.js

@@ -1,9 +1,11 @@
 export { createGlobalContextShared };
 export { getGlobalContextSyncErrMsg };
+import { changeEnumerable, objectAssign, unique } from './utils.js';
+import { parseGlobResults } from './getPageFiles/parseGlobResults.js';
+import { getUserFriendlyConfigsGlobal, getUserFriendlyConfigsPageEager } from './page-configs/getUserFriendlyConfigs.js';
+import { execHookGlobal } from './hooks/execHook.js';
+import { prepareGlobalContextForPublicUsage } from './prepareGlobalContextForPublicUsage.js';
 const getGlobalContextSyncErrMsg = "The global context isn't set yet, call getGlobalContextSync() later or use getGlobalContext() instead.";
-import { getPageConfigsRuntime } from './getPageConfigsRuntime.js';
-import { executeHookGenericGlobalCumulative } from './hooks/executeHookGeneric.js';
-import { objectAssign } from './utils.js';
 async function createGlobalContextShared(virtualFileExports, globalObject, addGlobalContext) {
     const globalContext = createGlobalContextBase(virtualFileExports);
     const globalContextAddendum = await addGlobalContext?.(globalContext);
@@ -21,17 +23,17 @@ async function createGlobalContextShared(virtualFileExports, globalObject, addGl
         //      - globalContext._viteDevServer.hot.send()
         //        - Send 'full-server-reload' signal whenever a onCreateGlobalContext() function is modified => we need a globalObject to track all hooks and see if one of them is new/modified.
         //        - Seems less idiomatic
-        await executeHookGenericGlobalCumulative('onCreateGlobalContext', globalContext._pageConfigGlobal, null, globalContext);
+        await execHookGlobal('onCreateGlobalContext', globalContext._pageConfigGlobal, null, globalContext, prepareGlobalContextForPublicUsage);
     }
     else {
         // Singleton: ensure all `globalContext` user-land references are preserved & updated.
         // We don't use objectReplace() in order to keep user-land properties.
-        objectAssign(globalObject.globalContext, globalContext);
+        objectAssign(globalObject.globalContext, globalContext, true);
     }
     return globalObject.globalContext;
 }
 function createGlobalContextBase(virtualFileExports) {
-    const { pageFilesAll, allPageIds, pageConfigs, pageConfigGlobal, globalConfig, pageConfigsUserFriendly } = getPageConfigsRuntime(virtualFileExports);
+    const { pageFilesAll, allPageIds, pageConfigs, pageConfigGlobal, userFriendlyConfigsGlobal, userFriendlyConfigsPageEager } = getConfigsAll(virtualFileExports);
     const globalContext = {
         /**
          * Useful for distinguishing `globalContext` from other objects and narrowing down TypeScript unions.
@@ -39,13 +41,40 @@ function createGlobalContextBase(virtualFileExports) {
          * https://vike.dev/globalContext#typescript
          */
         isGlobalContext: true,
+        _isOriginalObject: true,
         _virtualFileExports: virtualFileExports,
         _pageFilesAll: pageFilesAll,
         _pageConfigs: pageConfigs,
         _pageConfigGlobal: pageConfigGlobal,
         _allPageIds: allPageIds,
-        config: globalConfig.config,
-        pages: pageConfigsUserFriendly
+        _userFriendlyConfigsGlobal: userFriendlyConfigsGlobal,
+        config: userFriendlyConfigsGlobal.config,
+        pages: userFriendlyConfigsPageEager
     };
+    changeEnumerable(globalContext, '_isOriginalObject', false);
     return globalContext;
 }
+function getConfigsAll(virtualFileExports) {
+    const { pageFilesAll, pageConfigs, pageConfigGlobal } = parseGlobResults(virtualFileExports);
+    const allPageIds = getAllPageIds(pageFilesAll, pageConfigs);
+    const userFriendlyConfigsGlobal = getUserFriendlyConfigsGlobal({
+        pageConfigGlobalValues: pageConfigGlobal.configValues
+    });
+    const userFriendlyConfigsPageEager = Object.fromEntries(pageConfigs.map((pageConfig) => {
+        return getUserFriendlyConfigsPageEager(pageConfigGlobal.configValues, pageConfig, pageConfig.configValues);
+    }));
+    return {
+        pageFilesAll,
+        allPageIds,
+        pageConfigs,
+        pageConfigGlobal,
+        userFriendlyConfigsGlobal,
+        userFriendlyConfigsPageEager
+    };
+}
+function getAllPageIds(pageFilesAll, pageConfigs) {
+    const fileIds = pageFilesAll.filter(({ isDefaultPageFile }) => !isDefaultPageFile).map(({ pageId }) => pageId);
+    const allPageIds = unique(fileIds);
+    const allPageIds2 = pageConfigs.map((p) => p.pageId);
+    return [...allPageIds, ...allPageIds2];
+}

package/dist/esm/shared/createPageContextShared.d.ts

@@ -1,9 +1,10 @@
 export { createPageContextShared };
+export { createPageContextObject };
+import type { PageConfigUserFriendly } from './page-configs/getUserFriendlyConfigs.js';
 import type { PageConfigGlobalRuntime } from './page-configs/PageConfig.js';
-declare function createPageContextShared<T extends object>(pageContextCreated: T, pageConfigGlobal: PageConfigGlobalRuntime): Promise<T & {
-    config: import("./page-configs/Config/PageContextConfig.js").ConfigResolved;
-    _source: import("./page-configs/getPageConfigUserFriendly.js").Source;
-    _sources: import("./page-configs/getPageConfigUserFriendly.js").Sources;
-    _from: import("./page-configs/getPageConfigUserFriendly.js").From;
+import { type PageContextPrepareMinimum } from './preparePageContextForPublicUsage.js';
+declare function createPageContextShared<T extends PageContextPrepareMinimum>(pageContextCreated: T, pageConfigGlobal: PageConfigGlobalRuntime, userFriendlyConfigsGlobal: PageConfigUserFriendly): Promise<T & PageConfigUserFriendly>;
+declare function createPageContextObject(): {
+    _isOriginalObject: true;
     isPageContext: true;
-}>;
+};

package/dist/esm/shared/createPageContextShared.js

@@ -1,15 +1,18 @@
 export { createPageContextShared };
-import { executeHookGenericGlobalCumulative } from './hooks/executeHookGeneric.js';
-import { getPageConfigGlobalUserFriendly } from './page-configs/getPageConfigUserFriendly.js';
-import { objectAssign } from './utils.js';
-async function createPageContextShared(pageContextCreated, pageConfigGlobal) {
-    const pageConfigGlobalUserFriendly = getPageConfigGlobalUserFriendly({
-        pageConfigGlobalValues: pageConfigGlobal.configValues
-    });
-    objectAssign(pageContextCreated, {
-        isPageContext: true,
-        ...pageConfigGlobalUserFriendly
-    }, true);
-    await executeHookGenericGlobalCumulative('onCreatePageContext', pageConfigGlobal, pageContextCreated, pageContextCreated);
+export { createPageContextObject };
+import { execHookGlobal } from './hooks/execHook.js';
+import { preparePageContextForPublicUsage } from './preparePageContextForPublicUsage.js';
+import { changeEnumerable, objectAssign } from './utils.js';
+async function createPageContextShared(pageContextCreated, pageConfigGlobal, userFriendlyConfigsGlobal) {
+    objectAssign(pageContextCreated, userFriendlyConfigsGlobal);
+    await execHookGlobal('onCreatePageContext', pageConfigGlobal, pageContextCreated, pageContextCreated, preparePageContextForPublicUsage);
     return pageContextCreated;
 }
+function createPageContextObject() {
+    const pageContext = {
+        _isOriginalObject: true,
+        isPageContext: true
+    };
+    changeEnumerable(pageContext, '_isOriginalObject', false);
+    return pageContext;
+}

package/dist/esm/shared/getPageContext.d.ts

@@ -1 +1 @@
-export { getPageContext, providePageContext } from './hooks/executeHook.js';
+export { getPageContext, providePageContext } from './hooks/execHook.js';

package/dist/esm/shared/getPageContext.js

@@ -1 +1 @@
-export { getPageContext, providePageContext } from './hooks/executeHook.js';
+export { getPageContext, providePageContext } from './hooks/execHook.js';

package/dist/esm/shared/getPageContextUrlComputed.d.ts

@@ -1,9 +1,9 @@
 export { getPageContextUrlComputed };
-export { assertPageContextUrl };
 export type { PageContextUrlInternal };
 export type { PageContextUrlClient };
 export type { PageContextUrlServer };
 export type { PageContextUrlSource };
+import { type PageContextPrepareMinimum } from './preparePageContextForPublicUsage.js';
 import { type UrlPublic } from './utils.js';
 type PageContextUrlComputed = {
     /** Parsed information about the current URL */
@@ -17,7 +17,7 @@ type PageContextUrl = {
     /** The URL of the HTTP request */
     urlOriginal: string;
 } & PageContextUrlComputed;
-type PageContextUrlInternal = PageContextUrl & {
+type PageContextUrlInternal = PageContextPrepareMinimum & PageContextUrl & {
     _urlRewrite: string | null;
 };
 type PageContextUrlClient = PageContextUrl;
@@ -40,6 +40,3 @@ type PageContextUrlSource = {
     _baseServer: string;
     _urlHandler: null | ((url: string) => string);
 };
-declare function assertPageContextUrl(pageContext: {
-    urlOriginal: string;
-} & PageContextUrlClient): void;

package/dist/esm/shared/getPageContextUrlComputed.js

@@ -1,14 +1,14 @@
 export { getPageContextUrlComputed };
-export { assertPageContextUrl };
 // =====================
 // File determining the URL logic.
 // URLs need to be computed, because the user can modify the URL e.g. with onBeforeRoute() for i18n.
 // =====================
 import { objectDefineProperty } from '../utils/objectDefineProperty.js';
-import { assert, parseUrl, assertWarning, isPlainObject, isPropertyGetter, isBrowser, changeEnumerable } from './utils.js';
+import { assertPropertyGetters } from './preparePageContextForPublicUsage.js';
+import { assert, parseUrl, assertWarning, isBrowser, changeEnumerable } from './utils.js';
 function getPageContextUrlComputed(pageContext) {
     assert(typeof pageContext.urlOriginal === 'string');
-    assertPageContextUrlComputed(pageContext);
+    assertPropertyGetters(pageContext);
     const pageContextUrlComputed = {};
     objectDefineProperty(pageContextUrlComputed, 'urlPathname', {
         get: urlPathnameGetter,
@@ -128,37 +128,3 @@ function urlParsedGetter() {
     }
     return urlParsedEnhanced;
 }
-function assertPageContextUrl(pageContext) {
-    assert(typeof pageContext.urlOriginal === 'string');
-    assert(typeof pageContext.urlPathname === 'string');
-    assert(isPlainObject(pageContext.urlParsed));
-    assert(pageContext.urlPathname === pageContext.urlParsed.pathname);
-    assertPageContextUrlComputed(pageContext);
-}
-function assertPageContextUrlComputed(pageContext) {
-    /*
-    If the isPropertyGetter() assertions fail then it's most likely because Object.assign() was used instead of `objectAssign()`:
-    ```js
-    const PageContextUrlComputed = getPageContextUrlComputed(pageContext)
-  
-    // ❌ Breaks the property descriptors/getters of pageContext defined by getPageContextUrlComputed() such as pageContext.urlPathname
-    Object.assign(pageContext, pageContextUrlComputed)
-  
-    // ❌ Also breaks property descriptors/getters
-    const pageContext = { ...pageContextUrlComputed }
-  
-    // ✅ Preserves property descriptors/getters (see objectAssign() implementation)
-    objectAssign(pageContext, pageContextUrlComputed)
-    ```
-    */
-    if ('urlPathname' in pageContext) {
-        assert(typeof pageContext.urlPathname === 'string');
-        assert(isPropertyGetter(pageContext, 'urlPathname'));
-        assert(isPropertyGetter(pageContext, 'urlParsed'));
-        assert(isPropertyGetter(pageContext, 'url'));
-    }
-    else {
-        assert(!('urlParsed' in pageContext));
-        assert(!('url' in pageContext));
-    }
-}

package/dist/esm/shared/getPageFiles.d.ts

@@ -1,4 +1,4 @@
 export type { PageFile } from './getPageFiles/getPageFileObject.js';
-export type { ExportsAll, PageConfigUserFriendlyOld } from './page-configs/getPageConfigUserFriendly.js';
+export type { ExportsAll, PageConfigUserFriendlyOld } from './page-configs/getUserFriendlyConfigs.js';
 export { getPageFilesClientSide } from './getPageFiles/getAllPageIdFiles.js';
 export { getPageFilesServerSide } from './getPageFiles/getAllPageIdFiles.js';

package/dist/esm/shared/getProxyForPublicUsage.d.ts

@@ -0,0 +1,4 @@
+export { getProxyForPublicUsage };
+type Target = Record<string, unknown>;
+type Fallback = (prop: string | symbol) => unknown;
+declare function getProxyForPublicUsage<Obj extends Target>(obj: Obj, objName: string, skipOnInternalProp?: true, fallback?: Fallback): Obj;

package/dist/esm/shared/getProxyForPublicUsage.js

@@ -0,0 +1,54 @@
+export { getProxyForPublicUsage };
+// We use a proxy instead of property getters.
+// - The issue with property getters is that they can't be `writable: true` but we do want the user to be able to modify the value of internal properties.
+//   ```console
+//   TypeError: Invalid property descriptor. Cannot both specify accessors and a value or writable attribute, #<Object>
+//   ```
+// - Previous implementation using property getters: https://github.com/vikejs/vike/blob/main/vike/utils/makePublicCopy.ts
+// Show warning when user is accessing internal `_` properties.
+import { NOT_SERIALIZABLE } from './NOT_SERIALIZABLE.js';
+import { assert, assertUsage, assertWarning, getPropAccessNotation, isBrowser } from './utils.js';
+function getProxyForPublicUsage(obj, objName, skipOnInternalProp, fallback) {
+    return new Proxy(obj, {
+        get: getTrapGet(obj, objName, skipOnInternalProp, fallback)
+    });
+}
+function getTrapGet(obj, objName, skipOnInternalProp, fallback) {
+    return function (_, prop) {
+        const propStr = String(prop);
+        if (prop === '_isProxyObject')
+            return true;
+        if (!skipOnInternalProp)
+            onInternalProp(propStr, objName);
+        if (fallback && !(prop in obj)) {
+            // Rudimentary flat pageContext implementation https://github.com/vikejs/vike/issues/1268
+            // Failed full-fledged implementation: https://github.com/vikejs/vike/pull/2458
+            return fallback(prop);
+        }
+        const val = obj[prop];
+        onNotSerializable(propStr, val, objName);
+        return val;
+    };
+}
+function onNotSerializable(propStr, val, objName) {
+    if (val !== NOT_SERIALIZABLE)
+        return;
+    const propName = getPropAccessNotation(propStr);
+    assert(isBrowser());
+    assertUsage(false, `Can't access ${objName}${propName} on the client side. Because it can't be serialized, see server logs.`);
+}
+function onInternalProp(propStr, objName) {
+    // - We must skip it in the client-side because of the reactivity mechanism of UI frameworks like Solid.
+    // - TO-DO/eventually: use import.meta.CLIENT instead of isBrowser()
+    //   - Where import.meta.CLIENT is defined by Vike
+    //   - Using import.meta.env.CLIENT (note `.env.`) doesn't seem possible: https://github.com/brillout/playground_node_import.meta.env
+    //     - If Rolldown Vite + Rolldowns always transpiles node_modules/ then we can simply use import.meta.env.SSR
+    if (isBrowser())
+        return;
+    // TODO/now remove this and only warn on built-in access instead
+    if (propStr === '_configFromHook')
+        return;
+    if (propStr.startsWith('_')) {
+        assertWarning(false, `Using internal ${objName}.${propStr} which may break in any minor version update. Reach out on GitHub to request official support for your use case.`, { onlyOnce: true, showStackTrace: true });
+    }
+}

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

@@ -0,0 +1,63 @@
+export { execHook };
+export { execHookSingle };
+export { execHookSingleWithReturn };
+export { execHookErrorHandling };
+export { execHooksErrorHandling };
+export { execHookWithoutPageContext };
+export { execHookGlobal };
+export { execHookSync };
+export { getPageContext };
+export { providePageContext };
+export { isUserHookError };
+export type { PageContextExecuteHook };
+import type { PageContextClient, PageContextServer } from '../types.js';
+import type { Hook, HookLoc } from './getHook.js';
+import type { PageConfigUserFriendlyOld } from '../getPageFiles.js';
+import type { HookName, HookNameGlobal } from '../page-configs/Config.js';
+import type { PageConfigGlobalRuntime } from '../page-configs/PageConfig.js';
+import type { PageContextForPublicUsageServer } from '../../node/runtime/renderPage/preparePageContextForPublicUsageServer.js';
+import type { PageContextForPublicUsageClientShared } from '../../client/shared/preparePageContextForPublicUsageClientShared.js';
+import { type PageContextPrepareMinimum } from '../preparePageContextForPublicUsage.js';
+import type { GlobalContextPrepareMinimum } from '../prepareGlobalContextForPublicUsage.js';
+type PageContextExecuteHook = PageConfigUserFriendlyOld & PageContextForPublicUsage;
+type PageContextForPublicUsage = PageContextForPublicUsageServer | PageContextForPublicUsageClientShared;
+type HookWithResult = Hook & {
+    hookReturn: unknown;
+};
+declare function execHookSingle<PageContext extends PageContextExecuteHook>(hook: Hook, pageContext: PageContext, preparePageContextForPublicUsage: (pageContext: PageContext) => PageContext): Promise<void>;
+declare function execHookSingleWithReturn<PageContext extends PageContextExecuteHook>(hook: Hook, pageContext: PageContext, preparePageContextForPublicUsage: (pageContext: PageContext) => PageContext): Promise<{
+    hookReturn: unknown;
+}>;
+declare function execHook<PageContext extends PageContextExecuteHook>(hookName: HookName, pageContext: PageContext, preparePageContextForPublicUsage: (pageContext: PageContext) => PageContext): Promise<HookWithResult[]>;
+declare function execHookErrorHandling<PageContext extends PageContextExecuteHook>(hookName: HookName, pageContext: PageContext, preparePageContextForPublicUsage: (pageContext: PageContext) => PageContext): Promise<{
+    hooks: HookWithResult[];
+    err?: undefined;
+} | {
+    hooks: Hook[];
+    err: unknown;
+}>;
+declare function execHooksErrorHandling<PageContext extends PageContextPrepareMinimum>(hooks: Hook[], pageContext: PageContext, preparePageContextForPublicUsage: (pageContext: PageContext) => PageContext): Promise<{
+    hooks: HookWithResult[];
+    err?: undefined;
+} | {
+    hooks: Hook[];
+    err: unknown;
+}>;
+declare function execHookGlobal<HookArg extends PageContextPrepareMinimum | GlobalContextPrepareMinimum>(hookName: HookNameGlobal, pageConfigGlobal: PageConfigGlobalRuntime, pageContext: PageContextPrepareMinimum | null, hookArg: HookArg, prepareForPublicUsage: (hookArg: HookArg) => HookArg): Promise<void>;
+declare function isUserHookError(err: unknown): false | HookLoc;
+declare function execHookWithoutPageContext<HookReturn>(hookFnCaller: () => HookReturn, hook: Omit<Hook, 'hookFn'>): Promise<HookReturn>;
+declare function execHookSync<PageContext extends PageContextPrepareMinimum>(hook: Omit<Hook, 'hookTimeout'>, pageContext: PageContext, preparePageContextForPublicUsage: (pageContext: PageContext) => PageContext): {
+    hookReturn: unknown;
+};
+/**
+ * Access `pageContext` object inside Vike hooks, in order to create universal hooks.
+ *
+ * https://vike.dev/getPageContext
+ */
+declare function getPageContext<PageContext = PageContextClient | PageContextServer>(): null | PageContext;
+/**
+ * Provide `pageContext` for universal hooks.
+ *
+ * https://vike.dev/getPageContext
+ */
+declare function providePageContext(pageContext: null | PageContextClient | PageContextServer): void;

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

@@ -0,0 +1,168 @@
+export { execHook };
+export { execHookSingle };
+export { execHookSingleWithReturn };
+export { execHookErrorHandling };
+export { execHooksErrorHandling };
+export { execHookWithoutPageContext };
+export { execHookGlobal };
+export { execHookSync };
+export { getPageContext };
+export { providePageContext };
+export { isUserHookError };
+import { 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';
+import { getHookFromPageConfigGlobalCumulative, getHookFromPageContextNew } from './getHook.js';
+import { preparePageContextForPublicUsage } from '../preparePageContextForPublicUsage.js';
+const globalObject = getGlobalObject('utils/execHook.ts', {
+    userHookErrors: new WeakMap(),
+    pageContext: null
+});
+async function execHookSingle(hook, pageContext, preparePageContextForPublicUsage) {
+    const res = await execHooksErrorHandling([hook], pageContext, preparePageContextForPublicUsage);
+    if ('err' in res)
+        throw res.err;
+    const { hookReturn } = res.hooks[0];
+    assertUsage(hookReturn === undefined, `The ${hook.hookName}() hook defined by ${hook.hookFilePath} isn't allowed to return a value`);
+}
+async function execHookSingleWithReturn(hook, pageContext, preparePageContextForPublicUsage) {
+    const res = await execHooksErrorHandling([hook], pageContext, preparePageContextForPublicUsage);
+    if ('err' in res)
+        throw res.err;
+    const { hookReturn } = res.hooks[0];
+    return { hookReturn };
+}
+async function execHook(hookName, pageContext, preparePageContextForPublicUsage) {
+    const res = await execHookErrorHandling(hookName, pageContext, preparePageContextForPublicUsage);
+    if ('err' in res)
+        throw res.err;
+    return res.hooks;
+}
+async function execHookErrorHandling(hookName, pageContext, preparePageContextForPublicUsage) {
+    const hooks = getHookFromPageContextNew(hookName, pageContext);
+    return execHooksErrorHandling(hooks, pageContext, preparePageContextForPublicUsage);
+}
+async function execHooksErrorHandling(hooks, pageContext, preparePageContextForPublicUsage) {
+    if (!hooks.length)
+        return { hooks: [] };
+    const pageContextForPublicUsage = preparePageContextForPublicUsage(pageContext);
+    let hooksWithResult;
+    let err;
+    try {
+        hooksWithResult = await Promise.all(hooks.map(async (hook) => {
+            const hookReturn = await execHookAsync(() => hook.hookFn(pageContextForPublicUsage), hook, pageContextForPublicUsage);
+            return { ...hook, hookReturn };
+        }));
+    }
+    catch (err_) {
+        err = err_;
+    }
+    if (hooksWithResult) {
+        return { hooks: hooksWithResult };
+    }
+    else {
+        return { hooks, err };
+    }
+}
+async function execHookGlobal(hookName, pageConfigGlobal, pageContext, hookArg, prepareForPublicUsage) {
+    const hooks = getHookFromPageConfigGlobalCumulative(pageConfigGlobal, hookName);
+    const hookArgForPublicUsage = prepareForPublicUsage(hookArg);
+    await Promise.all(hooks.map(async (hook) => {
+        await execHookAsync(() => hook.hookFn(hookArgForPublicUsage), hook, pageContext);
+    }));
+}
+function isUserHookError(err) {
+    if (!isObject(err))
+        return false;
+    return globalObject.userHookErrors.get(err) ?? false;
+}
+async function execHookWithoutPageContext(hookFnCaller, hook) {
+    const { hookName, hookFilePath, hookTimeout } = hook;
+    const hookReturn = await execHookAsync(hookFnCaller, { hookName, hookFilePath, hookTimeout }, null);
+    return hookReturn;
+}
+function execHookAsync(hookFnCaller, hook, pageContextForPublicUsage) {
+    const { hookName, hookFilePath, hookTimeout: { error: timeoutErr, warning: timeoutWarn } } = hook;
+    let resolve;
+    let reject;
+    const promise = new Promise((resolve_, reject_) => {
+        resolve = (ret) => {
+            clearTimeouts();
+            resolve_(ret);
+        };
+        reject = (err) => {
+            clearTimeouts();
+            reject_(err);
+        };
+    });
+    const clearTimeouts = () => {
+        if (currentTimeoutWarn)
+            clearTimeout(currentTimeoutWarn);
+        if (currentTimeoutErr)
+            clearTimeout(currentTimeoutErr);
+    };
+    const currentTimeoutWarn = isNotDisabled(timeoutWarn) &&
+        setTimeout(() => {
+            assertWarning(false, `The ${hookName}() hook defined by ${hookFilePath} is slow: it's taking more than ${humanizeTime(timeoutWarn)} (https://vike.dev/hooksTimeout)`, { onlyOnce: false });
+        }, timeoutWarn);
+    const currentTimeoutErr = isNotDisabled(timeoutErr) &&
+        setTimeout(() => {
+            const err = getProjectError(`The ${hookName}() hook defined by ${hookFilePath} timed out: it didn't finish after ${humanizeTime(timeoutErr)} (https://vike.dev/hooksTimeout)`);
+            reject(err);
+        }, timeoutErr);
+    (async () => {
+        try {
+            providePageContextInternal(pageContextForPublicUsage);
+            const ret = await hookFnCaller();
+            resolve(ret);
+        }
+        catch (err) {
+            if (isObject(err)) {
+                globalObject.userHookErrors.set(err, { hookName, hookFilePath });
+            }
+            reject(err);
+        }
+    })();
+    return promise;
+}
+function execHookSync(hook, pageContext, preparePageContextForPublicUsage) {
+    const pageContextForPublicUsage = preparePageContextForPublicUsage(pageContext);
+    providePageContextInternal(pageContextForPublicUsage);
+    const hookReturn = hook.hookFn(pageContextForPublicUsage);
+    return { hookReturn };
+}
+function isNotDisabled(timeout) {
+    return !!timeout && timeout !== Infinity;
+}
+/**
+ * Access `pageContext` object inside Vike hooks, in order to create universal hooks.
+ *
+ * https://vike.dev/getPageContext
+ */
+function getPageContext() {
+    const { pageContext } = globalObject;
+    if (!pageContext)
+        return null;
+    const pageContextForPublicUsage = pageContext._isProxyObject
+        ? // providePageContext() is called on the user-land (e.g. it's called by `vike-{react,vue,solid}`) thus it's already a proxy
+            pageContext
+        : preparePageContextForPublicUsage(pageContext);
+    return pageContextForPublicUsage;
+}
+/**
+ * Provide `pageContext` for universal hooks.
+ *
+ * https://vike.dev/getPageContext
+ */
+function providePageContext(pageContext) {
+    providePageContextInternal(pageContext);
+}
+function providePageContextInternal(pageContext) {
+    globalObject.pageContext = pageContext;
+    // Promise.resolve() is quicker than process.nextTick() and setImmediate()
+    // https://stackoverflow.com/questions/67949576/process-nexttick-before-promise-resolve-then
+    Promise.resolve().then(() => {
+        globalObject.pageContext = null;
+    });
+}

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

@@ -1,38 +1,37 @@
 export { getHookFromPageContext };
+export { getHookFromPageContextNew };
 export { getHookFromPageConfig };
 export { getHookFromPageConfigGlobal };
 export { getHookFromPageConfigGlobalCumulative };
-export { assertHook };
 export { getHook_setIsPrerenderering };
 export type { Hook };
-export type { HookName };
 export type { HookLoc };
 export type { HookTimeout };
 export type { HooksTimeoutProvidedByUser };
 export { getHookTimeoutDefault };
 import type { PageConfigUserFriendlyOld } from '../getPageFiles.js';
-import type { HookName, HookNamePage, HookNameGlobal } from '../page-configs/Config.js';
+import type { HookNameOld, HookNamePage, HookNameGlobal, HookName } from '../page-configs/Config.js';
 import type { PageConfigGlobalRuntime, PageConfigRuntime } from '../page-configs/PageConfig.js';
+import type { GlobalContextPrepareMinimum } from '../prepareGlobalContextForPublicUsage.js';
+import type { PageContextPrepareMinimum } from '../preparePageContextForPublicUsage.js';
 type Hook = HookLoc & {
     hookFn: HookFn;
     hookTimeout: HookTimeout;
 };
 type HookLoc = {
-    hookName: HookName;
+    hookName: HookNameOld;
     hookFilePath: string;
 };
-type HookFn = (arg: object) => unknown;
+type HookFn = (arg: PageContextPrepareMinimum | GlobalContextPrepareMinimum) => unknown;
 type HookTimeout = {
     error: number | false;
     warning: number | false;
 };
-type HooksTimeoutProvidedByUser = false | Partial<Record<HookName, false | Partial<HookTimeout>>>;
-declare function getHookFromPageContext(pageContext: PageConfigUserFriendlyOld, hookName: HookName): null | Hook;
+type HooksTimeoutProvidedByUser = false | Partial<Record<HookNameOld, false | Partial<HookTimeout>>>;
+declare function getHookFromPageContext(pageContext: PageConfigUserFriendlyOld, hookName: HookNameOld): null | Hook;
+declare function getHookFromPageContextNew(hookName: HookName, pageContext: PageConfigUserFriendlyOld): Hook[];
 declare function getHookFromPageConfig(pageConfig: PageConfigRuntime, hookName: HookNamePage): null | Hook;
 declare function getHookFromPageConfigGlobal(pageConfigGlobal: PageConfigGlobalRuntime, hookName: HookNameGlobal): null | Hook;
 declare function getHookFromPageConfigGlobalCumulative(pageConfigGlobal: PageConfigGlobalRuntime, hookName: HookNameGlobal): Hook[];
-declare function assertHook<TPageContext extends PageConfigUserFriendlyOld, THookName extends PropertyKey & HookName>(pageContext: TPageContext, hookName: THookName): asserts pageContext is TPageContext & {
-    exports: Record<THookName, Function | undefined>;
-};
-declare function getHookTimeoutDefault(hookName: HookName): HookTimeout;
+declare function getHookTimeoutDefault(hookName: HookNameOld): HookTimeout;
 declare function getHook_setIsPrerenderering(): void;

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

@@ -1,8 +1,8 @@
 export { getHookFromPageContext };
+export { getHookFromPageContextNew };
 export { getHookFromPageConfig };
 export { getHookFromPageConfigGlobal };
 export { getHookFromPageConfigGlobalCumulative };
-export { assertHook };
 export { getHook_setIsPrerenderering };
 // TODO/v1-release: remove
 // We export for old V0.4 design which doesn't support config.hooksTimeout
@@ -22,12 +22,34 @@ function getHookFromPageContext(pageContext, hookName) {
     const hookFn = pageContext.exports[hookName];
     if (hookFn === null)
         return null;
+    // TO-DO/eventually: use pageContext.configEntries in favor of pageContext.exportsAll once V0.4 is removed
     const file = pageContext.exportsAll[hookName][0];
     assert(file.exportValue === hookFn);
     const hookFilePath = file.filePath;
     assert(hookFilePath);
     return getHook(hookFn, hookName, hookFilePath, hookTimeout);
 }
+// TO-DO/eventually: remove getHookFromPageContext() in favor of getHookFromPageContextNew()
+function getHookFromPageContextNew(hookName, pageContext) {
+    const { hooksTimeout } = pageContext.config;
+    const hookTimeout = getHookTimeout(hooksTimeout, hookName);
+    const hooks = [];
+    /* TO-DO/eventually: use pageContext.configEntries in favor of pageContext.exportsAll once V0.4 is removed
+    pageContext.configEntries[hookName]?.forEach((val) => {
+      const hookFn = val.configValue
+      if (hookFn === null) return
+      const hookFilePath = val.configDefinedByFile
+    */
+    pageContext.exportsAll[hookName]?.forEach((val) => {
+        const hookFn = val.exportValue;
+        if (hookFn === null)
+            return;
+        const hookFilePath = val.filePath;
+        assert(hookFilePath);
+        hooks.push(getHook(hookFn, hookName, hookFilePath, hookTimeout));
+    });
+    return hooks;
+}
 function getHookFromPageConfig(pageConfig, hookName) {
     const configValue = getConfigValueRuntime(pageConfig, hookName);
     if (!configValue?.value)
@@ -76,9 +98,6 @@ function getHookFromConfigValue(configValue) {
     const hookFilePath = getHookFilePathToShowToUser(configValue.definedAtData);
     return { hookFn, hookFilePath };
 }
-function assertHook(pageContext, hookName) {
-    getHookFromPageContext(pageContext, hookName);
-}
 function assertHookFn(hookFn, { hookName, hookFilePath }) {
     assert(hookName && hookFilePath);
     assert(!hookName.endsWith(')'));