vike 0.4.247-commit-903de25 → 0.4.247-commit-14351e3

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

@@ -0,0 +1,122 @@
+export { createGlobalContextShared };
+export { getGlobalContextSyncErrMsg };
+export type { GlobalContextBase };
+export type { GlobalContextBasePublic };
+export type GlobalContextInternal = GlobalContextServerInternal | GlobalContextClientInternal;
+import type { PageFile } from './getPageFiles.js';
+import type { PageConfigRuntime } from '../types/PageConfig.js';
+import { type GlobalContextPrepareMinimum } from './prepareGlobalContextForPublicUsage.js';
+import type { GlobalContextServerInternal } from '../server/runtime/globalContext.js';
+import type { GlobalContextClientInternal } from '../client/runtime-client-routing/getGlobalContextClientInternal.js';
+import { type Hook } from './hooks/getHook.js';
+declare const getGlobalContextSyncErrMsg = "The global context isn't set yet, call getGlobalContextSync() later or use getGlobalContext() instead.";
+declare function createGlobalContextShared<GlobalContextAdded extends {}, GlobalContextAddedAsync extends {}>(virtualFileExportsGlobalEntry: unknown, globalObject: {
+    globalContext?: {};
+    onCreateGlobalContextHooks?: Hook<GlobalContextPrepareMinimum>[];
+    previousCreateGlobalContextPromise?: Promise<void>;
+}, addGlobalContext?: (globalContext: GlobalContextBase) => GlobalContextAdded, addGlobalContextTmp?: (globalContext: GlobalContextBase) => Promise<GlobalContextAdded>, addGlobalContextAsync?: (globalContext: GlobalContextBase) => Promise<GlobalContextAddedAsync>): Promise<{
+    _globalConfigPublic: {
+        pages: {
+            [k: string]: {
+                config: import("../types/index.js").ConfigResolved;
+                _source: import("./page-configs/resolveVikeConfigPublic.js").Source;
+                _sources: import("./page-configs/resolveVikeConfigPublic.js").Sources;
+                _from: import("./page-configs/resolveVikeConfigPublic.js").From;
+            } & ({
+                route: import("../types/Config.js").Route;
+                isErrorPage?: undefined;
+            } | {
+                route?: undefined;
+                isErrorPage: true;
+            });
+        };
+        config: import("../types/index.js").ConfigResolved;
+        _source: import("./page-configs/resolveVikeConfigPublic.js").Source;
+        _sources: import("./page-configs/resolveVikeConfigPublic.js").Sources;
+        _from: import("./page-configs/resolveVikeConfigPublic.js").From;
+    };
+    pages: {
+        [k: string]: {
+            config: import("../types/index.js").ConfigResolved;
+            _source: import("./page-configs/resolveVikeConfigPublic.js").Source;
+            _sources: import("./page-configs/resolveVikeConfigPublic.js").Sources;
+            _from: import("./page-configs/resolveVikeConfigPublic.js").From;
+        } & ({
+            route: import("../types/Config.js").Route;
+            isErrorPage?: undefined;
+        } | {
+            route?: undefined;
+            isErrorPage: true;
+        });
+    };
+    config: import("../types/index.js").ConfigResolved;
+    _source: import("./page-configs/resolveVikeConfigPublic.js").Source;
+    _sources: import("./page-configs/resolveVikeConfigPublic.js").Sources;
+    _from: import("./page-configs/resolveVikeConfigPublic.js").From;
+    /**
+     * Useful for distinguishing `globalContext` from other objects and narrowing down TypeScript unions.
+     *
+     * https://vike.dev/globalContext#typescript
+     */
+    isGlobalContext: true;
+    _isOriginalObject: true;
+    _virtualFileExportsGlobalEntry: unknown;
+    _pageFilesAll: PageFile[];
+    _pageConfigs: PageConfigRuntime[];
+    _pageConfigGlobal: import("../types/PageConfig.js").PageConfigGlobalRuntime;
+    _allPageIds: string[];
+} & GlobalContextAdded & Awaited<GlobalContextAddedAsync>>;
+type GlobalContextBasePublic = Pick<GlobalContextBase, 'config' | 'pages' | 'isGlobalContext'>;
+type GlobalContextBase = ReturnType<typeof createGlobalContextBase>;
+declare function createGlobalContextBase(virtualFileExportsGlobalEntry: unknown): {
+    _globalConfigPublic: {
+        pages: {
+            [k: string]: {
+                config: import("../types/index.js").ConfigResolved;
+                _source: import("./page-configs/resolveVikeConfigPublic.js").Source;
+                _sources: import("./page-configs/resolveVikeConfigPublic.js").Sources;
+                _from: import("./page-configs/resolveVikeConfigPublic.js").From;
+            } & ({
+                route: import("../types/Config.js").Route;
+                isErrorPage?: undefined;
+            } | {
+                route?: undefined;
+                isErrorPage: true;
+            });
+        };
+        config: import("../types/index.js").ConfigResolved;
+        _source: import("./page-configs/resolveVikeConfigPublic.js").Source;
+        _sources: import("./page-configs/resolveVikeConfigPublic.js").Sources;
+        _from: import("./page-configs/resolveVikeConfigPublic.js").From;
+    };
+    pages: {
+        [k: string]: {
+            config: import("../types/index.js").ConfigResolved;
+            _source: import("./page-configs/resolveVikeConfigPublic.js").Source;
+            _sources: import("./page-configs/resolveVikeConfigPublic.js").Sources;
+            _from: import("./page-configs/resolveVikeConfigPublic.js").From;
+        } & ({
+            route: import("../types/Config.js").Route;
+            isErrorPage?: undefined;
+        } | {
+            route?: undefined;
+            isErrorPage: true;
+        });
+    };
+    config: import("../types/index.js").ConfigResolved;
+    _source: import("./page-configs/resolveVikeConfigPublic.js").Source;
+    _sources: import("./page-configs/resolveVikeConfigPublic.js").Sources;
+    _from: import("./page-configs/resolveVikeConfigPublic.js").From;
+    /**
+     * Useful for distinguishing `globalContext` from other objects and narrowing down TypeScript unions.
+     *
+     * https://vike.dev/globalContext#typescript
+     */
+    isGlobalContext: true;
+    _isOriginalObject: true;
+    _virtualFileExportsGlobalEntry: unknown;
+    _pageFilesAll: PageFile[];
+    _pageConfigs: PageConfigRuntime[];
+    _pageConfigGlobal: import("../types/PageConfig.js").PageConfigGlobalRuntime;
+    _allPageIds: string[];
+};

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

@@ -0,0 +1,2 @@
+export { forkPageContext };
+declare function forkPageContext<PageContext extends Record<string, unknown>>(pageContext: PageContext): {} & PageContext;

package/dist/shared-server-client/forkPageContext.js

@@ -0,0 +1,8 @@
+export { forkPageContext };
+import { objectAssign } from './utils.js';
+// Create pageContext forks to avoid leaks: upon an error (bug or abort) a brand new pageContext object is created, in order to avoid previous pageContext modifications that are now obsolete to leak to the new pageContext object.
+function forkPageContext(pageContext) {
+    const pageContextNew = {};
+    objectAssign(pageContextNew, pageContext, true);
+    return pageContextNew;
+}

package/dist/shared-server-client/getPageContextRequestUrl.js

@@ -0,0 +1,13 @@
+export { getPageContextRequestUrl };
+export { pageContextJsonFileExtension };
+export { doNotCreateExtraDirectory };
+// This module isn't loaded by the client-side of Server Routing => we don't include `urlToFile` to `./utils.ts`
+import { urlToFile } from '../utils/urlToFile.js';
+const pageContextJsonFileExtension = '.pageContext.json';
+// `/some-base-url/index.pageContext.json` instead of `/some-base-url.pageContext.json` in order to comply to common reverse proxy setups, see https://github.com/vikejs/vike/issues/443
+const doNotCreateExtraDirectory = false;
+// See also node/renderPageServer/handlePageContextRequestUrl.ts
+function getPageContextRequestUrl(url) {
+    const pageContextRequestUrl = urlToFile(url, pageContextJsonFileExtension, doNotCreateExtraDirectory);
+    return pageContextRequestUrl;
+}

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

@@ -0,0 +1,42 @@
+export { getPageContextUrlComputed };
+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 */
+    urlParsed: UrlPublic;
+    /** The URL pathname, e.g. `/product/42` of `https://example.com/product/42?details=yes#reviews` */
+    urlPathname: string;
+    /** @deprecated */
+    url: string;
+};
+type PageContextUrl = {
+    /** The URL of the HTTP request */
+    urlOriginal: string;
+} & PageContextUrlComputed;
+type PageContextUrlInternal = PageContextPrepareMinimum & PageContextUrl & {
+    _urlRewrite?: string;
+};
+type PageContextUrlClient = PageContextUrl;
+type PageContextUrlServer = PageContextUrl & {
+    urlParsed: Omit<PageContextUrl['urlParsed'], HashProps> & {
+        /** Only available on the client-side */
+        hash: '';
+        /** Only available on the client-side */
+        hashString: null;
+        /** @deprecated */
+        hashOriginal: null;
+    };
+};
+type HashProps = 'hash' | 'hashString' | 'hashOriginal';
+declare function getPageContextUrlComputed(pageContext: PageContextUrlSource): PageContextUrlComputed;
+type PageContextUrlSource = {
+    urlOriginal: string;
+    urlLogical?: string;
+    _urlRewrite?: string;
+    _baseServer: string;
+    _urlHandler: null | ((url: string) => string);
+};

package/dist/shared-server-client/getPageFiles/analyzePageClientSide/determineClientEntry.d.ts

@@ -0,0 +1,14 @@
+export { determineClientEntry };
+export { getVikeClientEntry };
+import type { ClientDependency } from './ClientDependency.js';
+import type { PageFile } from '../../getPageFiles.js';
+declare function determineClientEntry({ pageFilesClientSide, pageFilesServerSide, isHtmlOnly, isClientRouting, }: {
+    pageFilesClientSide: PageFile[];
+    pageFilesServerSide: PageFile[];
+    isHtmlOnly: boolean;
+    isClientRouting: boolean;
+}): {
+    clientEntries: string[];
+    clientDependencies: ClientDependency[];
+};
+declare function getVikeClientEntry(isClientRouting: boolean): "@@vike/dist/client/runtime-client-routing/entry.js" | "@@vike/dist/client/runtime-server-routing/entry.js";

package/dist/shared-server-client/getPageFiles/analyzePageClientSide/determineClientEntry.js

@@ -0,0 +1,28 @@
+// TO-DO/next-major-release: remove
+export { determineClientEntry };
+export { getVikeClientEntry };
+function determineClientEntry({ pageFilesClientSide, pageFilesServerSide, isHtmlOnly, isClientRouting, }) {
+    let clientEntries = [];
+    const pageFilesServerSideOnly = pageFilesServerSide.filter((p) => !pageFilesClientSide.includes(p));
+    const clientDependencies = [];
+    clientDependencies.push(...pageFilesClientSide.map((p) => ({ id: p.filePath, onlyAssets: false, eagerlyImported: false })));
+    // CSS & assets
+    clientDependencies.push(...pageFilesServerSideOnly.map((p) => ({ id: p.filePath, onlyAssets: true, eagerlyImported: false })));
+    // Handle SPA & SSR pages.
+    if (isHtmlOnly) {
+        clientEntries = pageFilesClientSide.map((p) => p.filePath);
+    }
+    else {
+        // Add the vike client entry
+        const clientEntry = getVikeClientEntry(isClientRouting);
+        clientDependencies.push({ id: clientEntry, onlyAssets: false, eagerlyImported: false });
+        clientEntries = [clientEntry];
+    }
+    // console.log(pageFilesClientSide, pageFilesServerSide, clientDependencies, clientEntry)
+    return { clientEntries, clientDependencies };
+}
+function getVikeClientEntry(isClientRouting) {
+    return isClientRouting
+        ? '@@vike/dist/client/runtime-client-routing/entry.js'
+        : '@@vike/dist/client/runtime-server-routing/entry.js';
+}

package/dist/shared-server-client/getPageFiles/getAllPageIdFiles.js

@@ -0,0 +1,100 @@
+// TO-DO/next-major-release: remove this file
+export { getPageFilesClientSide };
+export { getPageFilesServerSide };
+import { assert, assertUsage, isNotNullish } from '../utils.js';
+function getPageFilesClientSide(pageFilesAll, pageId) {
+    return determine(pageFilesAll, pageId, true);
+}
+function getPageFilesServerSide(pageFilesAll, pageId) {
+    return determine(pageFilesAll, pageId, false);
+}
+function determine(pageFilesAll, pageId, envIsClient) {
+    const env = envIsClient ? 'CLIENT_ONLY' : 'SERVER_ONLY';
+    const pageFilesRelevant = pageFilesAll
+        .filter((p) => p.isRelevant(pageId) && p.fileType !== '.page.route')
+        .sort(getPageFilesSorter(envIsClient, pageId));
+    // Load the `.page.js` files specific to `pageId`
+    const getPageIdFile = (iso) => {
+        const files = pageFilesRelevant.filter((p) => p.pageId === pageId && p.isEnv(iso ? 'CLIENT_AND_SERVER' : env));
+        assertUsage(files.length <= 1, `Merge the following files into a single file: ${files.map((p) => p.filePath).join(' ')}`);
+        const pageIdFile = files[0];
+        assert(pageIdFile === undefined || !pageIdFile.isDefaultPageFile);
+        return pageIdFile;
+    };
+    const pageIdFileEnv = getPageIdFile(false);
+    const pageIdFileIso = getPageIdFile(true);
+    // A page can have only one renderer. In other words: Multiple `renderer/` overwrite each other.
+    // Load only load renderer (`/renderer/_default.*`)
+    const getRendererFile = (iso) => pageFilesRelevant.filter((p) => p.isRendererPageFile && p.isEnv(iso ? 'CLIENT_AND_SERVER' : env))[0];
+    const rendererFileEnv = getRendererFile(false);
+    const rendererFileIso = getRendererFile(true);
+    // A page can load multiple `_default.page.*` files of the same `fileType`. In other words: non-renderer `_default.page.*` files are cumulative.
+    // The exception being HTML-only pages because we pick a single page file as client entry. We handle that use case at `renderPageServer()`.
+    const defaultFilesNonRenderer = pageFilesRelevant.filter((p) => p.isDefaultPageFile && !p.isRendererPageFile && (p.isEnv(env) || p.isEnv('CLIENT_AND_SERVER')));
+    // Ordered by `pageContext.exports` precedence
+    const pageFiles = [pageIdFileEnv, pageIdFileIso, ...defaultFilesNonRenderer, rendererFileEnv, rendererFileIso].filter(isNotNullish);
+    return pageFiles;
+}
+function getPageFilesSorter(envIsClient, pageId) {
+    const env = envIsClient ? 'CLIENT_ONLY' : 'SERVER_ONLY';
+    const e1First = -1;
+    const e2First = +1;
+    const noOrder = 0;
+    return (e1, e2) => {
+        // `.page.js` files specific to `pageId` first
+        if (!e1.isDefaultPageFile && e2.isDefaultPageFile) {
+            return e1First;
+        }
+        if (!e2.isDefaultPageFile && e1.isDefaultPageFile) {
+            return e2First;
+        }
+        // Non-renderer `_default.page.*` before `renderer/**/_default.page.*`
+        {
+            const e1_isRenderer = e1.isRendererPageFile;
+            const e2_isRenderer = e2.isRendererPageFile;
+            if (!e1_isRenderer && e2_isRenderer) {
+                return e1First;
+            }
+            if (!e2_isRenderer && e1_isRenderer) {
+                return e2First;
+            }
+            assert(e1_isRenderer === e2_isRenderer);
+        }
+        // Filesystem nearest first
+        {
+            const e1_distance = getPathDistance(pageId, e1.filePath);
+            const e2_distance = getPathDistance(pageId, e2.filePath);
+            if (e1_distance < e2_distance) {
+                return e1First;
+            }
+            if (e2_distance < e1_distance) {
+                return e2First;
+            }
+            assert(e1_distance === e2_distance);
+        }
+        // `.page.server.js`/`.page.client.js` before `.page.js`
+        {
+            if (e1.isEnv(env) && e2.isEnv('CLIENT_AND_SERVER')) {
+                return e1First;
+            }
+            if (e2.isEnv(env) && e1.isEnv('CLIENT_AND_SERVER')) {
+                return e2First;
+            }
+        }
+        return noOrder;
+    };
+}
+function getPathDistance(pathA, pathB) {
+    // Index of first different character
+    let idx = 0;
+    for (; idx < pathA.length && idx < pathB.length; idx++) {
+        if (pathA[idx] !== pathB[idx])
+            break;
+    }
+    const pathAWithoutCommon = pathA.slice(idx);
+    const pathBWithoutCommon = pathB.slice(idx);
+    const distanceA = pathAWithoutCommon.split('/').length;
+    const distanceB = pathBWithoutCommon.split('/').length;
+    const distance = distanceA + distanceB;
+    return distance;
+}

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

@@ -0,0 +1,10 @@
+export { getProxyForPublicUsage };
+export type { DangerouslyUseInternals };
+declare function getProxyForPublicUsage<Obj extends Record<string | symbol, unknown>>(obj: Obj, objName: 'pageContext' | 'globalContext' | 'prerenderContext' | 'vikeConfig', skipOnInternalProp?: boolean, fallback?: (prop: string | symbol) => unknown): Obj & {
+    _isProxyObject: true;
+    _originalObject: Obj;
+    /** https://vike.dev/warning/internals */
+    dangerouslyUseInternals: DangerouslyUseInternals<Obj>;
+};
+/** https://vike.dev/warning/internals */
+type DangerouslyUseInternals<Obj> = Obj;

package/dist/shared-server-client/getProxyForPublicUsage.js

@@ -0,0 +1,59 @@
+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/4dbb354b0bcec04e862041fc9183fc4691bb8711/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: (_, prop) => getProp(prop, obj, objName, skipOnInternalProp, fallback),
+    });
+}
+function getProp(prop, ...args) {
+    const [obj, objName, skipOnInternalProp, fallback] = args;
+    const propStr = String(prop);
+    if (prop === '_isProxyObject')
+        return true;
+    if (prop === 'dangerouslyUseInternals') {
+        args[2] = true;
+        return getProxyForPublicUsage(...args);
+    }
+    if (!skipOnInternalProp) {
+        if (!globalThis.__VIKE__IS_CLIENT)
+            onInternalProp(propStr, objName);
+    }
+    if (prop === '_originalObject')
+        return obj;
+    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 on the client-side because of the reactivity mechanism of UI frameworks like Solid.
+    assert(!isBrowser());
+    // TO-DO/soon/proxy: remove this and only warn on built-in access instead
+    if (propStr === '_configFromHook')
+        return;
+    if (propStr.startsWith('_')) {
+        assertWarning(false, `Using internal ${objName}.${propStr} — https://vike.dev/warning/internals`, {
+            onlyOnce: true,
+            showStackTrace: true,
+        });
+    }
+}

package/dist/shared-server-client/hooks/execHook.d.ts

@@ -0,0 +1,44 @@
+export { execHook };
+export { execHookGlobal };
+export { execHookDirect };
+export { execHookDirectSingle };
+export { execHookDirectSingleWithReturn };
+export { execHookDirectWithoutPageContext };
+export { execHookDirectSync };
+export { getPageContext_sync };
+export { providePageContext };
+export { isUserHookError };
+export type { PageContextExecHook };
+import type { PageContextClient, PageContextServer } from '../../types/PageContext.js';
+import type { Hook, HookLoc } from './getHook.js';
+import type { PageContextConfig } from '../getPageFiles.js';
+import type { HookName, HookNameGlobal } from '../../types/Config.js';
+import type { PageConfigGlobalRuntime } from '../../types/PageConfig.js';
+import type { PageContextForPublicUsageServer } from '../../server/runtime/renderPageServer/preparePageContextForPublicUsageServer.js';
+import type { PageContextForPublicUsageClientShared } from '../../client/shared/preparePageContextForPublicUsageClientShared.js';
+import { type PageContextPrepareMinimum } from '../preparePageContextForPublicUsage.js';
+import type { GlobalContextPrepareMinimum } from '../prepareGlobalContextForPublicUsage.js';
+type PageContextExecHook = PageContextConfig & PageContextForPublicUsage;
+type PageContextForPublicUsage = PageContextForPublicUsageServer | PageContextForPublicUsageClientShared;
+type HookWithResult = Hook & {
+    hookReturn: unknown;
+};
+declare function execHook<PageContext extends PageContextExecHook>(hookName: HookName, pageContext: PageContext, preparePageContextForPublicUsage: (pageContext: PageContext) => PageContext): Promise<HookWithResult[]>;
+declare function execHookGlobal<HookArg extends GlobalContextPrepareMinimum>(hookName: HookNameGlobal, pageConfigGlobal: PageConfigGlobalRuntime, pageContext: PageContextPrepareMinimum | null, hookArg: HookArg, prepareForPublicUsage: (hookArg: HookArg) => HookArg): Promise<void>;
+declare function execHookDirect<PageContext extends PageContextPrepareMinimum>(hooks: Hook[], pageContext: PageContext, preparePageContextForPublicUsage: (pageContext: PageContext) => PageContext): Promise<HookWithResult[]>;
+declare function execHookDirectSingle<PageContext extends PageContextExecHook>(hook: Hook, pageContext: PageContext, preparePageContextForPublicUsage: (pageContext: PageContext) => PageContext): Promise<void>;
+declare function execHookDirectSingleWithReturn<PageContext extends PageContextExecHook>(hook: Hook, pageContext: PageContext, preparePageContextForPublicUsage: (pageContext: PageContext) => PageContext): Promise<{
+    hookReturn: unknown;
+}>;
+declare function isUserHookError(err: unknown): false | HookLoc;
+declare function execHookDirectWithoutPageContext<HookReturn>(hookFnCaller: () => HookReturn, hook: Omit<Hook, 'hookFn'>): Promise<HookReturn>;
+declare function execHookDirectSync<PageContext extends PageContextPrepareMinimum>(hook: Omit<Hook, 'hookTimeout'>, pageContext: PageContext, preparePageContextForPublicUsage: (pageContext: PageContext) => PageContext): {
+    hookReturn: unknown;
+};
+declare function getPageContext_sync<PageContext = PageContextClient | PageContextServer>(): null | PageContext;
+/**
+ * Provide `pageContext` for universal hooks.
+ *
+ * https://vike.dev/getPageContext
+ */
+declare function providePageContext(pageContext: null | PageContextClient | PageContextServer): void;

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

@@ -0,0 +1,140 @@
+export { execHook };
+export { execHookGlobal };
+export { execHookDirect };
+export { execHookDirectSingle };
+export { execHookDirectSingleWithReturn };
+export { execHookDirectWithoutPageContext };
+export { execHookDirectSync };
+export { getPageContext_sync };
+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 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);
+    const hookArgForPublicUsage = prepareForPublicUsage(hookArg);
+    await Promise.all(hooks.map(async (hook) => {
+        await execHookDirectAsync(() => hook.hookFn(hookArgForPublicUsage), hook, pageContext);
+    }));
+}
+async function execHookDirect(hooks, pageContext, preparePageContextForPublicUsage) {
+    if (!hooks.length)
+        return [];
+    const pageContextForPublicUsage = preparePageContextForPublicUsage(pageContext);
+    const hooksWithResult = await Promise.all(hooks.map(async (hook) => {
+        const hookReturn = await execHookDirectAsync(() => hook.hookFn(pageContextForPublicUsage), hook, pageContextForPublicUsage);
+        return { ...hook, hookReturn };
+    }));
+    return hooksWithResult;
+}
+async function execHookDirectSingle(hook, pageContext, preparePageContextForPublicUsage) {
+    const hooksWithResult = await execHookDirect([hook], pageContext, preparePageContextForPublicUsage);
+    const { hookReturn } = hooksWithResult[0];
+    assertUsage(hookReturn === undefined, `The ${hook.hookName}() hook defined by ${hook.hookFilePath} isn't allowed to return a value`);
+}
+async function execHookDirectSingleWithReturn(hook, pageContext, preparePageContextForPublicUsage) {
+    const hooksWithResult = await execHookDirect([hook], pageContext, preparePageContextForPublicUsage);
+    const { hookReturn } = hooksWithResult[0];
+    return { hookReturn };
+}
+function isUserHookError(err) {
+    if (!isObject(err))
+        return false;
+    return globalObject.userHookErrors.get(err) ?? false;
+}
+async function execHookDirectWithoutPageContext(hookFnCaller, hook) {
+    const { hookName, hookFilePath, hookTimeout } = hook;
+    const hookReturn = await execHookDirectAsync(hookFnCaller, { hookName, hookFilePath, hookTimeout }, null);
+    return hookReturn;
+}
+function execHookDirectAsync(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 execHookDirectSync(hook, pageContext, preparePageContextForPublicUsage) {
+    const pageContextForPublicUsage = preparePageContextForPublicUsage(pageContext);
+    providePageContextInternal(pageContextForPublicUsage);
+    const hookReturn = hook.hookFn(pageContextForPublicUsage);
+    return { hookReturn };
+}
+function isNotDisabled(timeout) {
+    return !!timeout && timeout !== Infinity;
+}
+function getPageContext_sync() {
+    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/shared-server-client/hooks/getHook.d.ts

@@ -0,0 +1,38 @@
+export { getHookFromPageContext };
+export { getHookFromPageContextNew };
+export { getHookFromPageConfig };
+export { getHookFromPageConfigGlobal };
+export { getHookFromPageConfigGlobalCumulative };
+export { getHook_setIsPrerenderering };
+export type { Hook };
+export type { HookLoc };
+export type { HookTimeout };
+export type { HooksTimeoutProvidedByUser };
+export { getHookTimeoutDefault };
+import type { PageContextConfig } from '../getPageFiles.js';
+import type { HookNameOld, HookNamePage, HookNameGlobal, HookName } from '../../types/Config.js';
+import type { PageConfigGlobalRuntime, PageConfigRuntime } from '../../types/PageConfig.js';
+import type { GlobalContextPrepareMinimum } from '../prepareGlobalContextForPublicUsage.js';
+import type { PageContextPrepareMinimum } from '../preparePageContextForPublicUsage.js';
+type HookArgDefault = PageContextPrepareMinimum;
+type Hook<HookArg = HookArgDefault> = HookLoc & {
+    hookFn: HookFn<HookArg>;
+    hookTimeout: HookTimeout;
+};
+type HookLoc = {
+    hookName: HookNameOld;
+    hookFilePath: string;
+};
+type HookFn<HookArg = HookArgDefault> = (arg: HookArg, ...rest: unknown[]) => unknown;
+type HookTimeout = {
+    error: number | false;
+    warning: number | false;
+};
+type HooksTimeoutProvidedByUser = false | Partial<Record<HookNameOld, false | Partial<HookTimeout>>>;
+declare function getHookFromPageContext(pageContext: PageContextConfig, hookName: HookNameOld): null | Hook;
+declare function getHookFromPageContextNew(hookName: HookName, pageContext: PageContextConfig): Hook[];
+declare function getHookFromPageConfig(pageConfig: PageConfigRuntime, hookName: HookNamePage): null | Hook;
+declare function getHookFromPageConfigGlobal(pageConfigGlobal: PageConfigGlobalRuntime, hookName: HookNameGlobal): null | Hook;
+declare function getHookFromPageConfigGlobalCumulative<HookArg = GlobalContextPrepareMinimum>(pageConfigGlobal: PageConfigGlobalRuntime, hookName: HookNameGlobal): Hook<HookArg>[];
+declare function getHookTimeoutDefault(hookName: HookNameOld): HookTimeout;
+declare function getHook_setIsPrerenderering(): void;