vike 0.4.247-commit-a642bde → 0.4.247-commit-14351e3

package/dist/esm/node/vite/utils.d.ts

@@ -1,23 +0,0 @@
-export * from '../runtime/utils.js';
-export * from '../../utils/requireResolve.js';
-export * from '../../utils/includes.js';
-export * from '../../utils/isDev.js';
-export * from '../../utils/getMostSimilar.js';
-export * from '../../utils/getRandomId.js';
-export * from '../../utils/escapeRegex.js';
-export * from '../../utils/trimWithAnsi.js';
-export * from '../../utils/removeEmptyLines.js';
-export * from '../../utils/findPackageJson.js';
-export * from '../../utils/deepEqual.js';
-export * from '../../utils/assertKeys.js';
-export * from '../../utils/injectRollupInputs.js';
-export * from '../../utils/pLimit.js';
-export * from '../../utils/assertVersion.js';
-export * from '../../utils/isFilePathAbsoluteFilesystem.js';
-export * from '../../utils/isEqualStringList.js';
-export * from '../../utils/isDocker.js';
-export * from '../../utils/isVitest.js';
-export * from '../../utils/rollupSourceMap.js';
-export * from '../../utils/isImportPath.js';
-export * from '../../utils/virtualFileId.js';
-export * from '../../utils/isExactlyOneTruthy.js';

package/dist/esm/node/vite/utils.js

@@ -1,30 +0,0 @@
-// Utils needed by Vike's Vite plugin
-// We call onLoad() here so that it's called even when only a subset of the plugin is loaded. (Making the assert() calls inside onLoad() a lot stronger.)
-import { onLoad } from './onLoad.js';
-onLoad();
-// - Server-side bloat is negligible
-// - The Vite plugin imports the server runtime anyways
-export * from '../runtime/utils.js';
-// Utils only needed by `plugin/*`
-export * from '../../utils/requireResolve.js';
-export * from '../../utils/includes.js';
-export * from '../../utils/isDev.js';
-export * from '../../utils/getMostSimilar.js';
-export * from '../../utils/getRandomId.js';
-export * from '../../utils/escapeRegex.js';
-export * from '../../utils/trimWithAnsi.js';
-export * from '../../utils/removeEmptyLines.js';
-export * from '../../utils/findPackageJson.js';
-export * from '../../utils/deepEqual.js';
-export * from '../../utils/assertKeys.js';
-export * from '../../utils/injectRollupInputs.js';
-export * from '../../utils/pLimit.js';
-export * from '../../utils/assertVersion.js';
-export * from '../../utils/isFilePathAbsoluteFilesystem.js';
-export * from '../../utils/isEqualStringList.js';
-export * from '../../utils/isDocker.js';
-export * from '../../utils/isVitest.js';
-export * from '../../utils/rollupSourceMap.js';
-export * from '../../utils/isImportPath.js';
-export * from '../../utils/virtualFileId.js';
-export * from '../../utils/isExactlyOneTruthy.js';

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

@@ -1,122 +0,0 @@
-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 '../node/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/esm/shared/getPageContext.d.ts

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

package/dist/esm/shared/getPageContext.js

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

package/dist/esm/shared/getPageContextRequestUrl.js

@@ -1,13 +0,0 @@
-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/renderPage/handlePageContextRequestUrl.ts
-function getPageContextRequestUrl(url) {
-    const pageContextRequestUrl = urlToFile(url, pageContextJsonFileExtension, doNotCreateExtraDirectory);
-    return pageContextRequestUrl;
-}

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

@@ -1,42 +0,0 @@
-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 | null;
-};
-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 | null;
-    _baseServer: string;
-    _urlHandler: null | ((url: string) => string);
-};

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

@@ -1,14 +0,0 @@
-export { determineClientEntry };
-export { getVikeClientEntry };
-import type { ClientDependency } from './ClientDependency.js';
-import type { PageFile } from '../../../shared/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/esm/client/runtime-client-routing/entry.js" | "@@vike/dist/esm/client/runtime-server-routing/entry.js";

package/dist/esm/shared/getPageFiles/analyzePageClientSide/determineClientEntry.js

@@ -1,28 +0,0 @@
-// 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/esm/client/runtime-client-routing/entry.js'
-        : '@@vike/dist/esm/client/runtime-server-routing/entry.js';
-}

package/dist/esm/shared/getPageFiles/getAllPageIdFiles.js

@@ -1,100 +0,0 @@
-// 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 `renderPage()`.
-    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/esm/shared/getProxyForPublicUsage.d.ts

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

package/dist/esm/shared/getProxyForPublicUsage.js

@@ -1,54 +0,0 @@
-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, obj, objName, skipOnInternalProp, fallback) {
-    const propStr = String(prop);
-    if (prop === '_isProxyObject')
-        return true;
-    if (prop === 'dangerouslyUseInternals')
-        return obj;
-    if (!skipOnInternalProp) {
-        if (!globalThis.__VIKE__IS_CLIENT)
-            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 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/esm/shared/hooks/execHook.d.ts

@@ -1,49 +0,0 @@
-export { execHook };
-export { execHookGlobal };
-export { execHookDirect };
-export { execHookDirectSingle };
-export { execHookDirectSingleWithReturn };
-export { execHookDirectWithoutPageContext };
-export { execHookDirectSync };
-export { getPageContext };
-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 '../../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 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;
-};
-/**
- * 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

@@ -1,145 +0,0 @@
-export { execHook };
-export { execHookGlobal };
-export { execHookDirect };
-export { execHookDirectSingle };
-export { execHookDirectSingleWithReturn };
-export { execHookDirectWithoutPageContext };
-export { execHookDirectSync };
-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 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;
-}
-/**
- * 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;
-    });
-}