vike 0.4.249 → 0.4.250-commit-6161324

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

@@ -1,8 +1,18 @@
 export { createPageContextShared };
 export { createPageContextObject };
+export type { PageContextCreated };
+export type { PageContextCreatedBase };
 import type { GlobalConfigPublic } from './page-configs/resolveVikeConfigPublic.js';
-import { type PageContextPrepareMinimum } from './preparePageContextForPublicUsage.js';
-declare function createPageContextShared<T extends PageContextPrepareMinimum>(pageContextCreated: T, globalConfigPublic: GlobalConfigPublic): T & GlobalConfigPublic;
+import type { PageContextCreatedClient } from '../client/runtime-client-routing/createPageContextClientSide.js';
+import type { PageContextCreatedServer } from '../server/runtime/renderPageServer/createPageContextServerSide.js';
+import type { PageContextCreatedClient_ServerRouting } from '../client/runtime-server-routing/createPageContextClientSide.js';
+type PageContextCreated = PageContextCreatedServer | PageContextCreatedClient | PageContextCreatedClient_ServerRouting;
+type PageContextCreatedBase = {
+    _isOriginalObject: true;
+    isPageContext: true;
+    isClientSide: boolean;
+};
+declare function createPageContextShared<T extends Record<string, unknown>>(pageContextCreated: T, globalConfigPublic: GlobalConfigPublic): T & GlobalConfigPublic;
 declare function createPageContextObject(): {
     _isOriginalObject: true;
     isPageContext: true;

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

@@ -1,6 +1,7 @@
 export { createPageContextShared };
 export { createPageContextObject };
 import { changeEnumerable, objectAssign } from './utils.js';
+//*/
 function createPageContextShared(pageContextCreated, globalConfigPublic) {
     objectAssign(pageContextCreated, globalConfigPublic);
     return pageContextCreated;

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

@@ -3,8 +3,9 @@ export type { PageContextUrlInternal };
 export type { PageContextUrlClient };
 export type { PageContextUrlServer };
 export type { PageContextUrlSource };
-import { type PageContextPrepareMinimum } from './preparePageContextForPublicUsage.js';
 import { type UrlPublic } from './utils.js';
+import type { GlobalContextPrepareMinimum } from './prepareGlobalContextForPublicUsage.js';
+import type { PageContextCreatedBase } from './createPageContextShared.js';
 type PageContextUrlComputed = {
     /** Parsed information about the current URL */
     urlParsed: UrlPublic;
@@ -17,8 +18,10 @@ type PageContextUrl = {
     /** The URL of the HTTP request */
     urlOriginal: string;
 } & PageContextUrlComputed;
-type PageContextUrlInternal = PageContextPrepareMinimum & PageContextUrl & {
+type PageContextUrlInternal = PageContextUrl & {
     _urlRewrite?: string;
+} & PageContextCreatedBase & {
+    _globalContext: GlobalContextPrepareMinimum;
 };
 type PageContextUrlClient = PageContextUrl;
 type PageContextUrlServer = PageContextUrl & {

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

@@ -5,6 +5,7 @@ export { execHookDirectSingle };
 export { execHookDirectSingleWithReturn };
 export { execHookDirectWithoutPageContext };
 export { execHookDirectSync };
+export { execHookBase };
 export { getPageContext_sync };
 export { providePageContext };
 export { isUserHookError };
@@ -13,28 +14,29 @@ import type { PageContextClient, PageContextServer } from '../../types/PageConte
 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 { PageContextCreated } from '../createPageContextShared.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 PageContextExecHook = PageContextCreated & 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 execHookGlobal<HookArg extends GlobalContextPrepareMinimum>(hookName: HookNameGlobal, globalContext: GlobalContextPrepareMinimum, 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 execHookDirectWithoutPageContext<HookReturn>(hookFnCaller: () => HookReturn, hook: Omit<Hook, 'hookFn'>, globalContext: GlobalContextPrepareMinimum): Promise<HookReturn>;
 declare function execHookDirectSync<PageContext extends PageContextPrepareMinimum>(hook: Omit<Hook, 'hookTimeout'>, pageContext: PageContext, preparePageContextForPublicUsage: (pageContext: PageContext) => PageContext): {
     hookReturn: unknown;
 };
+declare function execHookBase<HookReturn>(hookFnCaller: () => HookReturn, hook: Omit<Hook, 'hookTimeout' | 'hookFn'>, globalContext: GlobalContextPrepareMinimum, pageContext: PageContextPrepareMinimum | null): HookReturn | Promise<HookReturn>;
 declare function getPageContext_sync<PageContext = PageContextClient | PageContextServer>(): null | PageContext;
 /**
  * Provide `pageContext` for universal hooks.

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

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

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

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

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

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

package/dist/types/Config/ConfigResolved.d.ts

@@ -1,8 +1,9 @@
 export type { ConfigResolved };
-import type { ConfigBuiltIn, ConfigBuiltInResolved, ImportString } from '../Config.js';
+import type { ConfigBuiltIn, ConfigBuiltInResolved } from '../Config.js';
+import type { ImportStringList } from '../../node/vite/shared/importString.js';
 type ConfigUnresolved = WithoutImportString<ConfigBuiltIn & Vike.Config>;
 type ConfigResolvedOnly = ConfigBuiltInResolved & Vike.ConfigResolved;
 type ConfigResolved = ConfigResolvedOnly & Omit<ConfigUnresolved, keyof ConfigResolvedOnly>;
 type WithoutImportString<T> = {
-    [K in keyof T]: Exclude<T[K], ImportString>;
+    [K in keyof T]: Exclude<T[K], ImportStringList>;
 };

package/dist/types/Config.d.ts

@@ -8,7 +8,6 @@ export type { HookName };
 export type { HookNameOld };
 export type { HookNamePage };
 export type { HookNameGlobal };
-export type { ImportString };
 export type { Route };
 export type { KeepScrollPosition };
 export type { DataAsync };
@@ -47,10 +46,12 @@ import type { GlobalContext } from './GlobalContext.js';
 import type { InlineConfig } from 'vite';
 import type { PassToClientPublic } from '../server/runtime/renderPageServer/html/serializeContext.js';
 import type { CliPreviewConfig } from '../node/api/preview.js';
+import type { StaticReplace } from '../node/vite/plugins/pluginStaticReplace/applyStaticReplace.js';
+import type { ImportStringList } from '../node/vite/shared/importString.js';
 type HookNameOld = HookName | HookNameOldDesign;
 type HookName = HookNamePage | HookNameGlobal;
 type HookNamePage = 'onHydrationEnd' | 'onBeforePrerenderStart' | 'onBeforeRender' | 'onPageTransitionStart' | 'onPageTransitionEnd' | 'onRenderHtml' | 'onRenderClient' | 'guard' | 'data' | 'onData' | 'route';
-type HookNameGlobal = 'onBeforeRoute' | 'onPrerenderStart' | 'onCreatePageContext' | 'onCreateGlobalContext' | 'onError';
+type HookNameGlobal = 'onBeforeRoute' | 'onPrerenderStart' | 'onCreatePageContext' | 'onCreateGlobalContext' | 'onError' | 'onHookCall';
 type HookNameOldDesign = 'render' | 'prerender' | 'onBeforePrerender';
 type ConfigNameBuiltIn = Exclude<keyof ConfigBuiltIn, keyof VikeVitePluginOptions | 'onBeforeRoute' | 'onPrerenderStart' | 'vite' | 'redirects'> | 'prerender' | 'hasServerOnlyHook' | 'isClientRuntimeLoaded' | 'onBeforeRenderEnv' | 'dataEnv' | 'guardEnv' | 'hooksTimeout' | 'clientHooks' | 'middleware';
 type ConfigNameGlobal = 'onPrerenderStart' | 'onBeforeRoute' | 'prerender' | 'disableAutoFullBuild' | 'includeAssetsImportedByServer' | 'baseAssets' | 'baseServer' | 'redirects' | 'trailingSlash' | 'disableUrlNormalization' | 'vite';
@@ -250,12 +251,12 @@ type ConfigBuiltIn = {
      *
      *  https://vike.dev/route
      */
-    route?: Route | ImportString;
+    route?: Route | ImportStringList;
     /** Protect page(s), e.g. forbid unauthorized access.
      *
      *  https://vike.dev/guard
      */
-    guard?: GuardAsync | GuardSync | ImportString;
+    guard?: GuardAsync | GuardSync | ImportStringList;
     /**
      * Pre-render page(s).
      *
@@ -264,7 +265,7 @@ type ConfigBuiltIn = {
      *
      * @default false
      */
-    prerender?: boolean | ImportString | {
+    prerender?: boolean | ImportStringList | {
         /**
          * Allow only some of your pages to be pre-rendered.
          *
@@ -339,32 +340,41 @@ type ConfigBuiltIn = {
      *
      * https://vike.dev/extends
      */
-    extends?: Config | ImportString | (Config | ImportString)[];
+    extends?: Config | Config[] | ImportStringList;
     /** Hook called before the page is rendered.
      *
      *  https://vike.dev/onBeforeRender
      */
-    onBeforeRender?: OnBeforeRenderAsync | OnBeforeRenderSync | ImportString | null;
+    onBeforeRender?: OnBeforeRenderAsync | OnBeforeRenderSync | ImportStringList | null;
     /** Hook called when a `pageContext` object is created.
      *
      *  https://vike.dev/onCreatePageContext
      */
-    onCreatePageContext?: ((pageContext: PageContextServer) => void) | ImportString | null;
+    onCreatePageContext?: ((pageContext: PageContextServer) => void) | ImportStringList | null;
     /** Hook called when an error occurs during server-side rendering.
      *
      *  https://vike.dev/onError
      */
-    onError?: ((error: unknown, pageContext: null | PageContextServer) => void) | ImportString | null;
+    onError?: ((error: unknown, pageContext: null | PageContextServer) => void) | ImportStringList | null;
     /** Hook called when the `globalContext` object is created.
      *
      *  https://vike.dev/onCreateGlobalContext
      */
-    onCreateGlobalContext?: ((globalContext: GlobalContext) => void) | ImportString | null;
+    onCreateGlobalContext?: ((globalContext: GlobalContext) => void) | ImportStringList | null;
+    /** Called whenever a hook is called.
+     *
+     *  https://vike.dev/onHookCall
+     */
+    onHookCall?: ((hook: {
+        name: HookName;
+        filePath: string;
+        call: () => void | Promise<void>;
+    }, pageContext: PageContextClient | PageContextServer | null) => void | Promise<void>) | ImportStringList;
     /** Hook for fetching data.
      *
      *  https://vike.dev/data
      */
-    data?: DataAsync<unknown> | DataSync<unknown> | ImportString | null;
+    data?: DataAsync<unknown> | DataSync<unknown> | ImportStringList | null;
     /** Hook called as soon as `pageContext.data` is available.
      *
      *  https://vike.dev/onData
@@ -374,83 +384,83 @@ type ConfigBuiltIn = {
      *
      * https://vike.dev/passToClient
      */
-    passToClient?: PassToClientPublic | ImportString;
+    passToClient?: PassToClientPublic | ImportStringList;
     /** Hook called when page is rendered on the client-side.
      *
      * https://vike.dev/onRenderClient
      */
-    onRenderClient?: OnRenderClientAsync | OnRenderClientSync | ImportString;
+    onRenderClient?: OnRenderClientAsync | OnRenderClientSync | ImportStringList;
     /** Hook called when page is rendered to HTML on the server-side.
      *
      * https://vike.dev/onRenderHtml
      */
-    onRenderHtml?: OnRenderHtmlAsync | OnRenderHtmlSync | ImportString;
+    onRenderHtml?: OnRenderHtmlAsync | OnRenderHtmlSync | ImportStringList;
     /** Enable async Route Functions.
      *
      * https://vike.dev/route-function#async
      */
-    iKnowThePerformanceRisksOfAsyncRouteFunctions?: boolean | ImportString;
+    iKnowThePerformanceRisksOfAsyncRouteFunctions?: boolean | ImportStringList;
     /** Change the URL root of Filesystem Routing.
      *
      * https://vike.dev/filesystemRoutingRoot
      */
-    filesystemRoutingRoot?: string | ImportString;
+    filesystemRoutingRoot?: string | ImportStringList;
     /** Page Hook called when pre-rendering starts.
      *
      * https://vike.dev/onPrerenderStart
      */
-    onPrerenderStart?: OnPrerenderStartAsync | OnPrerenderStartSync | ImportString;
+    onPrerenderStart?: OnPrerenderStartAsync | OnPrerenderStartSync | ImportStringList;
     /** Global Hook called before the whole pre-rendering process starts.
      *
      * https://vike.dev/onBeforePrerenderStart
      */
-    onBeforePrerenderStart?: OnBeforePrerenderStartAsync | OnBeforePrerenderStartSync | ImportString;
+    onBeforePrerenderStart?: OnBeforePrerenderStartAsync | OnBeforePrerenderStartSync | ImportStringList;
     /** Hook called before the URL is routed to a page.
      *
      * https://vike.dev/onBeforeRoute
      */
-    onBeforeRoute?: OnBeforeRouteAsync | OnBeforeRouteSync | ImportString;
+    onBeforeRoute?: OnBeforeRouteAsync | OnBeforeRouteSync | ImportStringList;
     /** Hook called after the page is hydrated.
      *
      * https://vike.dev/onHydrationEnd
      */
-    onHydrationEnd?: OnHydrationEndAsync | OnHydrationEndSync | ImportString;
+    onHydrationEnd?: OnHydrationEndAsync | OnHydrationEndSync | ImportStringList;
     /** Hook called before the user navigates to a new page.
      *
      * https://vike.dev/onPageTransitionStart
      */
-    onPageTransitionStart?: OnPageTransitionStartAsync | OnPageTransitionStartSync | ImportString;
+    onPageTransitionStart?: OnPageTransitionStartAsync | OnPageTransitionStartSync | ImportStringList;
     /** Hook called after the user navigates to a new page.
      *
      * https://vike.dev/onPageTransitionEnd
      */
-    onPageTransitionEnd?: OnPageTransitionEndAsync | OnPageTransitionEndSync | ImportString;
+    onPageTransitionEnd?: OnPageTransitionEndAsync | OnPageTransitionEndSync | ImportStringList;
     /** Whether the UI framework (React/Vue/Solid/...) allows the page's hydration to be aborted.
      *
      * https://vike.dev/hydrationCanBeAborted
      */
-    hydrationCanBeAborted?: boolean | ImportString;
+    hydrationCanBeAborted?: boolean | ImportStringList;
     /** Add client code.
      *
      * https://vike.dev/client
      */
-    client?: string | ImportString;
+    client?: string | ImportStringList;
     /** Enable Client Routing.
      *
      * https://vike.dev/clientRouting
      */
-    clientRouting?: boolean | ImportString;
+    clientRouting?: boolean | ImportStringList;
     /**
      * Whether hooks are loaded on the client-side.
      *
      * https://vike.dev/clientHooks
      */
-    clientHooks?: boolean | null | ImportString;
+    clientHooks?: boolean | null | ImportStringList;
     /** Create new or modify existing configurations.
      *
      * https://vike.dev/meta
      */
-    meta?: ConfigMeta | ImportString;
+    meta?: ConfigMeta | ImportStringList;
     /** Vite configuration.
      *
      * https://vite.dev/config/
@@ -498,13 +508,13 @@ type ConfigBuiltIn = {
      *
      * https://vike.dev/prefetch
      */
-    prefetch?: PrefetchSetting | ImportString;
+    prefetch?: PrefetchSetting | ImportStringList;
     /** @deprecated Use `prefetch` setting (https://vike.dev/prefetch) instead.  */
     /** Prefetch links.
      *
      * https://vike.dev/prefetchStaticAssets
      */
-    prefetchStaticAssets?: PrefetchStaticAssets | ImportString;
+    prefetchStaticAssets?: PrefetchStaticAssets | ImportStringList;
     /** Modify the timeouts of hooks. */
     hooksTimeout?: HooksTimeoutProvidedByUser;
     /** `Cache-Control` HTTP header value.
@@ -587,13 +597,19 @@ type ConfigBuiltIn = {
     cli?: {
         preview?: CliPreviewConfig;
     };
+    /**
+     * Static code transformations for optimizations like removing component children server-side.
+     *
+     * @experimental
+     */
+    staticReplace?: StaticReplace[];
 };
 type ConfigBuiltInResolved = {
     passToClient?: string[][];
     redirects?: Record<string, string>[];
-    prerender?: Exclude<Config['prerender'], ImportString | undefined>[];
+    prerender?: Exclude<Config['prerender'], ImportStringList | undefined>[];
     middleware?: Function[];
-    headersResponse?: Exclude<Config['headersResponse'], ImportString | undefined>[];
+    headersResponse?: Exclude<Config['headersResponse'], ImportStringList | undefined>[];
+    staticReplace?: StaticReplace[][];
 };
 type ConfigMeta = Record<string, ConfigDefinition>;
-type ImportString = `import:${string}`;

package/dist/types/Config.js

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

package/dist/types/PageConfig.d.ts

@@ -25,7 +25,7 @@ import type { ConfigValueSerialized } from '../shared-server-client/page-configs
 import type { LocationId } from '../node/vite/shared/resolveVikeConfigInternal/filesystemRouting.js';
 import type { FilePath } from './FilePath.js';
 import type { ConfigDefinitionsInternal } from '../node/vite/shared/resolveVikeConfigInternal/configDefinitionsBuiltIn.js';
-import type { PlusFile } from '../node/vite/shared/resolveVikeConfigInternal/getPlusFilesAll.js';
+import type { PlusFile } from '../node/vite/shared/resolveVikeConfigInternal/getPlusFilesByLocationId.js';
 import type { ApiOperation } from '../node/api/types.js';
 type PageConfigCommon = {
     pageId: string;

package/dist/types/PageContext.d.ts

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

package/dist/types/index.d.ts

@@ -4,7 +4,8 @@ export type { PrerenderContextPublic as PrerenderContext } from '../node/prerend
 export type { PageContextBuiltInServer } from './PageContext.js';
 export type { PageContextBuiltInClientWithClientRouting } from './PageContext.js';
 export type { PageContextBuiltInClientWithServerRouting } from './PageContext.js';
-export type { Config, ConfigMeta as Meta, ImportString, KeepScrollPosition, } from './Config.js';
+export type { Config, ConfigMeta as Meta, KeepScrollPosition, } from './Config.js';
+export type { ImportString } from '../node/vite/shared/importString.js';
 export type { DataAsync, DataSync, GuardAsync, GuardSync, OnBeforePrerenderStartAsync, OnBeforePrerenderStartSync, OnBeforeRenderAsync, OnBeforeRenderSync, OnBeforeRouteAsync, OnBeforeRouteSync, OnHydrationEndAsync, OnHydrationEndSync, OnPageTransitionEndAsync, OnPageTransitionEndSync, OnPageTransitionStartAsync, OnPageTransitionStartSync, OnPrerenderStartAsync, OnPrerenderStartSync, OnRenderClientAsync, OnRenderClientSync, OnRenderHtmlAsync, OnRenderHtmlSync, RouteAsync, RouteSync, } from './Config.js';
 export type { ConfigResolved } from './Config/ConfigResolved.js';
 export type { ConfigEnv } from './PageConfig.js';

package/dist/utils/PROJECT_VERSION.d.ts

@@ -1 +1 @@
-export declare const PROJECT_VERSION: "0.4.249";
+export declare const PROJECT_VERSION: "0.4.250-commit-6161324";

package/dist/utils/PROJECT_VERSION.js

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