vike 0.4.229-commit-58f7ed0 → 0.4.229-commit-5da80bf

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,20 @@
 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 { getProxyForMutationTracking } from './getProxyForPublicUsage.js';
+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);
+    const pageContextWithProxy = getProxyForMutationTracking(pageContext);
+    return pageContextWithProxy;
+}

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,12 @@
+export { getProxyForPublicUsage };
+export { getProxyForPublicUsageFlat };
+export { getProxyForMutationTracking };
+type Target = Record<string, unknown> & {
+    _onChange?: () => void;
+    _proxyTarget?: any;
+    _userMods?: any;
+    _proxyTargetPublic?: any;
+};
+declare function getProxyForPublicUsage<Obj extends Target>(obj: Obj, objName: string, skipOnInternalProp?: true): Obj;
+declare function getProxyForPublicUsageFlat<Obj extends Target>(obj: Obj, objName: string, skipOnInternalProp?: true): Obj;
+declare function getProxyForMutationTracking<Obj extends Target>(obj: Obj): Obj;

package/dist/esm/shared/getProxyForPublicUsage.js

@@ -0,0 +1,104 @@
+export { getProxyForPublicUsage };
+export { getProxyForPublicUsageFlat };
+export { getProxyForMutationTracking };
+// 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, objectAssign, objectReplace } from './utils.js';
+function getProxyForPublicUsage(obj, objName, skipOnInternalProp) {
+    return new Proxy(obj, {
+        get: getTrapGet(obj, objName, skipOnInternalProp)
+    });
+}
+function getProxyForPublicUsageFlat(obj, objName, skipOnInternalProp) {
+    assert(obj._isOriginalObject);
+    assert(obj._proxyTarget);
+    obj._proxyTargetPublic ?? (obj._proxyTargetPublic = {});
+    const target = obj._proxyTargetPublic;
+    obj._userMods ?? (obj._userMods = {});
+    const objUserMods = obj._userMods;
+    const update = () => {
+        assert(obj._proxyTarget);
+        objectReplace(target, obj._proxyTarget);
+        objectAssign(target, objUserMods);
+    };
+    obj._onChange = () => {
+        update();
+    };
+    update();
+    return new Proxy(target, {
+        // get: getTrapGet(target, objName, skipOnInternalProp),
+        set(_, prop, val) {
+            const ret = Reflect.set(objUserMods, prop, val);
+            update();
+            return ret;
+        },
+        defineProperty(_, ...args) {
+            const ret = Reflect.defineProperty(objUserMods, ...args);
+            update();
+            return ret;
+        },
+        deleteProperty(_, ...args) {
+            const ret = Reflect.deleteProperty(objUserMods, ...args);
+            update();
+            return ret;
+        }
+    });
+}
+function getTrapGet(obj, objName, skipOnInternalProp) {
+    return function (_, prop) {
+        const propStr = String(prop);
+        if (!skipOnInternalProp)
+            onInternalProp(propStr, objName);
+        const val = obj[prop];
+        onNotSerializable(propStr, val, objName);
+        return val;
+    };
+}
+function getProxyForMutationTracking(obj) {
+    objectAssign(obj, { _proxyTarget: obj });
+    return new Proxy(obj, {
+        set(...args) {
+            const ret = Reflect.set(...args);
+            obj._onChange?.();
+            return ret;
+        },
+        defineProperty(...args) {
+            const ret = Reflect.defineProperty(...args);
+            obj._onChange?.();
+            return ret;
+        },
+        deleteProperty(...args) {
+            const ret = Reflect.deleteProperty(...args);
+            obj._onChange?.();
+            return ret;
+        }
+    });
+}
+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 | PageContextPrepareMinimum): void;

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

@@ -0,0 +1,162 @@
+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 {
+            providePageContext(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);
+    providePageContext(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 pageContext;
+    const pageContextForPublicUsage = preparePageContextForPublicUsage(pageContext);
+    return pageContextForPublicUsage;
+}
+/**
+ * Provide `pageContext` for universal hooks.
+ *
+ * https://vike.dev/getPageContext
+ */
+function providePageContext(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(')'));

package/dist/esm/shared/page-configs/Config.d.ts

@@ -5,6 +5,7 @@ export type { ConfigNameBuiltIn };
 export type { ConfigNameGlobal };
 export type { ConfigMeta };
 export type { HookName };
+export type { HookNameOld };
 export type { HookNamePage };
 export type { HookNameGlobal };
 export type { ImportString };
@@ -43,10 +44,11 @@ import type { Vike, VikePackages } from '../VikeNamespace.js';
 import type { HooksTimeoutProvidedByUser } from '../hooks/getHook.js';
 import type { GlobalContext, PageContextClient, PageContextServer } from '../types.js';
 import type { InlineConfig } from 'vite';
-type HookName = HookNamePage | HookNameGlobal | HookNameOldDesign;
-type HookNamePage = 'onHydrationEnd' | 'onBeforePrerenderStart' | 'onBeforeRender' | 'onPageTransitionStart' | 'onPageTransitionEnd' | 'onRenderHtml' | 'onRenderClient' | 'guard' | 'data';
-type HookNameGlobal = 'onBeforePrerender' | 'onBeforeRoute' | 'onPrerenderStart' | 'onCreatePageContext' | 'onCreateGlobalContext';
-type HookNameOldDesign = 'render' | 'prerender';
+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';
+type HookNameOldDesign = 'render' | 'prerender' | 'onBeforePrerender';
 type ConfigNameBuiltIn = Exclude<keyof Config, keyof VikeVitePluginOptions | 'onBeforeRoute' | 'onPrerenderStart' | 'vite' | 'redirects'> | 'prerender' | 'isClientRuntimeLoaded' | 'onBeforeRenderEnv' | 'dataEnv' | 'hooksTimeout' | 'clientHooks' | 'middleware';
 type ConfigNameGlobal = 'onPrerenderStart' | 'onBeforeRoute' | 'prerender' | 'disableAutoFullBuild' | 'includeAssetsImportedByServer' | 'baseAssets' | 'baseServer' | 'redirects' | 'trailingSlash' | 'disableUrlNormalization' | 'vite';
 type Config = ConfigBuiltIn & Vike.Config & (VikePackages.ConfigVikeReact | VikePackages.ConfigVikeVue | VikePackages.ConfigVikeSolid | VikePackages.ConfigVikeSvelte | VikePackages.ConfigVikeAngular);
@@ -345,6 +347,11 @@ type ConfigBuiltIn = {
      *  https://vike.dev/data
      */
     data?: DataAsync<unknown> | DataSync<unknown> | ImportString | null;
+    /** Hook called as soon as `pageContext.data` is available.
+     *
+     *  https://vike.dev/onData
+     */
+    onData?: Function;
     /** Determines what pageContext properties are sent to the client-side.
      *
      * https://vike.dev/passToClient