vike 0.4.197 → 0.4.198

package/dist/esm/client/client-routing-runtime/prefetch.js

@@ -1,21 +1,51 @@
 export { prefetch };
+export { getPageContextPrefetched };
+export { initLinkPrefetchHandlers };
+export { populatePageContextPrefetchCache };
 export { addLinkPrefetchHandlers };
-import { assert, assertClientRouting, assertUsage, assertUsageUrlPathname, assertWarning, checkIfClientRouting, getGlobalObject } from './utils.js';
+export { addLinkPrefetchHandlers_watch };
+export { addLinkPrefetchHandlers_unwatch };
+import { assert, assertClientRouting, assertUsage, assertWarning, checkIfClientRouting, getGlobalObject, hasProp, objectAssign } from './utils.js';
 import { isErrorFetchingStaticAssets, loadUserFilesClientSide } from '../shared/loadUserFilesClientSide.js';
 import { skipLink } from './skipLink.js';
-import { getPrefetchSettings } from './prefetch/getPrefetchSettings.js';
-import { isAlreadyPrefetched, markAsAlreadyPrefetched } from './prefetch/alreadyPrefetched.js';
 import { disableClientRouting } from './renderPageClientSide.js';
 import { isClientSideRoutable } from './isClientSideRoutable.js';
 import { createPageContext } from './createPageContext.js';
 import { route } from '../../shared/route/index.js';
 import { noRouteMatch } from '../../shared/route/noRouteMatch.js';
+import { getPageContextFromServerHooks } from './getPageContextFromHooks.js';
+import { getPageContextCurrent } from './getPageContextCurrent.js';
+import { PAGE_CONTEXT_MAX_AGE_DEFAULT, getPrefetchSettings } from './prefetch/getPrefetchSettings.js';
 import pc from '@brillout/picocolors';
+import { normalizeUrlArgument } from './normalizeUrlArgument.js';
 assertClientRouting();
-const globalObject = getGlobalObject('prefetch.ts', { linkPrefetchHandlerAdded: new WeakMap() });
-async function prefetchAssets(pageId, pageContext) {
+const globalObject = getGlobalObject('prefetch.ts', {
+    linkPrefetchHandlerAdded: new WeakSet(),
+    addLinkPrefetchHandlers_debounce: null,
+    mutationObserver: new MutationObserver(addLinkPrefetchHandlers),
+    // `linkTags` [is automatically updated](https://developer.mozilla.org/en-US/docs/Web/API/HTMLCollection#:~:text=An%20HTMLCollection%20in%20the%20HTML%20DOM%20is%20live%3B%20it%20is%20automatically%20updated%20when%20the%20underlying%20document%20is%20changed.)
+    linkTags: document.getElementsByTagName('A'),
+    prefetchedPageContexts: {}
+});
+function getPageContextPrefetched(pageContext) {
+    const prefetchSettings = getPrefetchSettings(pageContext, null);
+    // TODO/pageContext-prefetch: I guess we need linkTag to make this condition work
+    if (!prefetchSettings.pageContext)
+        return null;
+    const key = getCacheKey(pageContext.urlPathname);
+    const found = globalObject.prefetchedPageContexts[key];
+    if (!found || found.result.is404ServerSideRouted || isExpired(found))
+        return null;
+    const pageContextPrefetched = found.result.pageContextFromServerHooks;
+    /* TODO/pageContext-prefetch: make it work for when resultMaxAge is Infinity.
+    // We discard the prefetched pageContext whenever we use it, so that the user always sees fresh data upon naivgating.
+    delete globalObject.prefetchedPageContexts[key]
+    */
+    return pageContextPrefetched;
+}
+async function prefetchAssets(pageContextLink) {
     try {
-        await loadUserFilesClientSide(pageId, pageContext._pageFilesAll, pageContext._pageConfigs);
+        await loadUserFilesClientSide(pageContextLink.pageId, pageContextLink._pageFilesAll, pageContextLink._pageConfigs);
     }
     catch (err) {
         if (isErrorFetchingStaticAssets(err)) {
@@ -26,6 +56,36 @@ async function prefetchAssets(pageId, pageContext) {
         }
     }
 }
+async function prefetchPageContextFromServerHooks(pageContextLink, resultMaxAge) {
+    const result = await getPageContextFromServerHooks(pageContextLink, false);
+    setPageContextPrefetchCache(pageContextLink, result, resultMaxAge);
+}
+function populatePageContextPrefetchCache(pageContext /*& PageContextExports*/, result) {
+    // TODO/pageContext-prefetch: replace with using pageContext.config.prerender instead. (For being able to do that: eager configs need to be accessible without have to use PageContextExports as it isn't available here.)
+    if (!isBrilloutDocpress())
+        return;
+    setPageContextPrefetchCache(pageContext, result, null);
+}
+function setPageContextPrefetchCache(pageContext, result, resultMaxAge) {
+    if (resultMaxAge === null)
+        resultMaxAge = getResultMaxAge();
+    const key = getCacheKey(pageContext.urlPathname);
+    assert(isBrilloutDocpress()); // Ensure this API isn't used by anyone else
+    globalObject.prefetchedPageContexts[key] = {
+        resultFetchedAt: Date.now(),
+        resultMaxAge,
+        result
+    };
+}
+function getResultMaxAge() {
+    const pageContextCurrent = getPageContextCurrent();
+    // TODO/pageContext-prefetch: remove this dirty hack used by @brillout/docpress and, instead, use Vike's default if pageContextCurrent isn't defined yet.
+    if (!pageContextCurrent)
+        return Infinity;
+    const prefetchSettings = getPrefetchSettings(pageContextCurrent, null);
+    const resultMaxAge = typeof prefetchSettings.pageContext === 'number' ? prefetchSettings.pageContext : PAGE_CONTEXT_MAX_AGE_DEFAULT;
+    return resultMaxAge;
+}
 /**
  * Programmatically prefetch client assets.
  *
@@ -33,85 +93,153 @@ async function prefetchAssets(pageId, pageContext) {
  *
  * @param url - The URL of the page you want to prefetch.
  */
-async function prefetch(url) {
+async function prefetch(url, options) {
     assertUsage(checkIfClientRouting(), 'prefetch() only works with Client Routing, see https://vike.dev/prefetch', {
         showStackTrace: true
     });
-    const errPrefix = '[prefetch(url)] url';
-    assertUsageUrlPathname(url, errPrefix);
-    if (isAlreadyPrefetched(url))
-        return;
-    markAsAlreadyPrefetched(url);
-    const pageContext = await createPageContext(url);
-    let pageContextFromRoute;
-    try {
-        pageContextFromRoute = await route(pageContext);
-    }
-    catch {
-        // If a route() hook has a bug or `throw render()` / `throw redirect()`
-        return;
-    }
-    const pageId = pageContextFromRoute.pageId;
-    if (!pageId) {
-        assertWarning(false, `${errPrefix} ${pc.string(url)} ${noRouteMatch}`, {
+    url = normalizeUrlArgument(url, 'prefetch');
+    const pageContextLink = await getPageContextLink(url);
+    if (!pageContextLink?.pageId) {
+        assertWarning(false, `[prefetch(url)] ${pc.string(url)} ${noRouteMatch}`, {
             showStackTrace: true,
             onlyOnce: false
         });
         return;
     }
-    await prefetchAssets(pageId, pageContext);
+    assert(hasProp(pageContextLink, 'pageId', 'string')); // help TypeScript
+    await Promise.all([
+        (async () => {
+            if (options?.staticAssets !== false) {
+                await prefetchAssets(pageContextLink);
+            }
+        })(),
+        (async () => {
+            if (options?.pageContext !== false) {
+                const resultMaxAge = typeof options?.pageContext === 'number' ? options.pageContext : null;
+                await prefetchPageContextFromServerHooks(pageContextLink, resultMaxAge);
+            }
+        })()
+    ]);
 }
-function addLinkPrefetchHandlers(pageContext) {
-    // Current URL is already prefetched
-    markAsAlreadyPrefetched(pageContext.urlPathname);
-    const linkTags = [...document.getElementsByTagName('A')];
-    linkTags.forEach((linkTag) => {
-        if (globalObject.linkPrefetchHandlerAdded.has(linkTag))
-            return;
-        globalObject.linkPrefetchHandlerAdded.set(linkTag, true);
-        const url = linkTag.getAttribute('href');
-        if (skipLink(linkTag))
-            return;
-        assert(url);
-        if (isAlreadyPrefetched(url))
-            return;
-        const { prefetchStaticAssets } = getPrefetchSettings(pageContext, linkTag);
-        if (!prefetchStaticAssets)
-            return;
-        if (prefetchStaticAssets === 'hover') {
-            linkTag.addEventListener('mouseover', () => {
-                prefetchIfPossible(url);
-            });
-            linkTag.addEventListener('touchstart', () => {
-                prefetchIfPossible(url);
-            }, { passive: true });
+// Lazy execution logic copied from: https://github.com/withastro/astro/blob/2594eb088d53a98181ac820243bcb1a765856ecf/packages/astro/src/runtime/client/dev-toolbar/apps/audit/index.ts#L53-L72
+function addLinkPrefetchHandlers() {
+    if (globalObject.addLinkPrefetchHandlers_debounce)
+        clearTimeout(globalObject.addLinkPrefetchHandlers_debounce);
+    globalObject.addLinkPrefetchHandlers_debounce = setTimeout(() => {
+        // Wait for the next idle period, as it is less likely to interfere with any other work the browser is doing post-mutation.
+        if ('requestIdleCallback' in window) {
+            requestIdleCallback(addLinkPrefetchHandlers_apply, { timeout: 300 });
         }
-        if (prefetchStaticAssets === 'viewport') {
-            const observer = new IntersectionObserver((entries) => {
-                entries.forEach((entry) => {
-                    if (entry.isIntersecting) {
-                        prefetchIfPossible(url);
-                        observer.disconnect();
-                    }
-                });
-            });
-            observer.observe(linkTag);
+        else {
+            // Fallback for old versions of Safari, we'll assume that things are less likely to be busy after 150ms.
+            setTimeout(addLinkPrefetchHandlers_apply, 150);
         }
+    }, 250);
+}
+function initLinkPrefetchHandlers() {
+    addLinkPrefetchHandlers();
+}
+function addLinkPrefetchHandlers_watch() {
+    // Notes about performance:
+    // - https://stackoverflow.com/questions/31659567/performance-of-mutationobserver-to-detect-nodes-in-entire-dom/39332340#39332340
+    // - https://news.ycombinator.com/item?id=15274211
+    //   - https://github.com/kubetail-org/sentineljs
+    // - https://stackoverflow.com/questions/55046093/listening-for-changes-in-htmlcollection-or-achieving-a-similar-effect
+    globalObject.mutationObserver.observe(document.body, {
+        childList: true,
+        subtree: true
     });
 }
-async function prefetchIfPossible(url) {
-    const pageContext = await createPageContext(url);
+function addLinkPrefetchHandlers_unwatch() {
+    globalObject.mutationObserver.disconnect();
+}
+function addLinkPrefetchHandlers_apply() {
+    for (let linkTag of globalObject.linkTags) {
+        if (globalObject.linkPrefetchHandlerAdded.has(linkTag))
+            continue;
+        globalObject.linkPrefetchHandlerAdded.add(linkTag);
+        if (skipLink(linkTag))
+            continue;
+        linkTag.addEventListener('mouseover', () => {
+            prefetchOnEvent(linkTag, 'hover');
+        }, { passive: true });
+        linkTag.addEventListener('touchstart', () => {
+            prefetchOnEvent(linkTag, 'hover');
+        }, { passive: true });
+        const observer = new IntersectionObserver((entries) => {
+            entries.forEach((entry) => {
+                if (entry.isIntersecting) {
+                    prefetchOnEvent(linkTag, 'viewport');
+                }
+            });
+        });
+        observer.observe(linkTag);
+    }
+}
+async function prefetchOnEvent(linkTag, event) {
+    let prefetchSettings;
+    const pageContextCurrent = getPageContextCurrent();
+    if (pageContextCurrent) {
+        prefetchSettings = getPrefetchSettings(pageContextCurrent, linkTag);
+    }
+    else {
+        // TODO/pageContext-prefetch: remove this dirty hack used by @brillout/docpress and, instead, use Vike's default if pageContextCurrent isn't defined yet.
+        prefetchSettings = { staticAssets: 'hover', pageContext: Infinity };
+    }
+    // Check again in case DOM was manipulated since last check
+    if (skipLink(linkTag))
+        return;
+    const urlOfLink = linkTag.getAttribute('href');
+    const pageContextLink = await getPageContextLink(urlOfLink);
+    if (!pageContextLink?.pageId)
+        return;
+    assert(hasProp(pageContextLink, 'pageId', 'string')); // help TypeScript
+    if (!(await isClientSideRoutable(pageContextLink.pageId, pageContextLink)))
+        return;
+    await Promise.all([
+        (async () => {
+            if (prefetchSettings.staticAssets === event) {
+                await prefetchAssets(pageContextLink);
+            }
+        })(),
+        (async () => {
+            if (event !== 'viewport' && prefetchSettings.pageContext) {
+                const key = getCacheKey(urlOfLink);
+                const found = globalObject.prefetchedPageContexts[key];
+                if (!found || isExpired(found)) {
+                    // TODO/pageContext-prefetch: move this logic in getPrefetchSettings()
+                    const resultMaxAge = prefetchSettings.pageContext;
+                    await prefetchPageContextFromServerHooks(pageContextLink, resultMaxAge);
+                }
+            }
+        })()
+    ]);
+}
+function isExpired(found) {
+    return Date.now() - found.resultFetchedAt > found.resultMaxAge;
+}
+// TODO/next-major-release: make it sync
+async function getPageContextLink(urlOfLink) {
+    const pageContextLink = await createPageContext(urlOfLink);
     let pageContextFromRoute;
     try {
-        pageContextFromRoute = await route(pageContext);
+        pageContextFromRoute = await route(pageContextLink);
     }
     catch {
         // If a route() hook has a bug or `throw render()` / `throw redirect()`
-        return;
+        return null;
     }
-    if (!pageContextFromRoute?.pageId)
-        return;
-    if (!(await isClientSideRoutable(pageContextFromRoute.pageId, pageContext)))
-        return;
-    await prefetchAssets(pageContextFromRoute.pageId, pageContext);
+    objectAssign(pageContextLink, pageContextFromRoute);
+    return pageContextLink;
+}
+function getCacheKey(url) {
+    if (url.startsWith('#'))
+        url = '/';
+    assert(url.startsWith('/'), { urlPathname: url });
+    const key = url.split('#')[0];
+    return key;
+}
+// TODO/pageContext-prefetch: remove
+function isBrilloutDocpress() {
+    return '_isBrilloutDocpress' in window;
 }

package/dist/esm/client/client-routing-runtime/renderPageClientSide.js

@@ -3,9 +3,9 @@ export { getRenderCount };
 export { disableClientRouting };
 export { firstRenderStartPromise };
 import { assert, getCurrentUrl, isSameErrorMessage, objectAssign, redirectHard, getGlobalObject, executeHook, hasProp, augmentType, genPromise, isCallable } from './utils.js';
-import { getPageContextFromHooks_isHydration, getPageContextFromHooks_isNotHydration, getPageContextFromHooks_serialized } from './getPageContextFromHooks.js';
+import { getPageContextFromClientHooks, getPageContextFromServerHooks, getPageContextFromHooks_isHydration, getPageContextFromHooks_serialized, setPageContextInitIsPassedToClient } from './getPageContextFromHooks.js';
 import { createPageContext } from './createPageContext.js';
-import { addLinkPrefetchHandlers } from './prefetch.js';
+import { addLinkPrefetchHandlers, addLinkPrefetchHandlers_unwatch, addLinkPrefetchHandlers_watch, getPageContextPrefetched, populatePageContextPrefetchCache } from './prefetch.js';
 import { assertInfo, assertWarning, isReact } from './utils.js';
 import { executeOnRenderClientHook } from '../shared/executeOnRenderClientHook.js';
 import { assertHook, getHook } from '../../shared/hooks/getHook.js';
@@ -18,6 +18,7 @@ import { setScrollPosition } from './setScrollPosition.js';
 import { updateState } from './onBrowserHistoryNavigation.js';
 import { browserNativeScrollRestoration_disable, setInitialRenderIsDone } from './scrollRestoration.js';
 import { getErrorPageId } from '../../shared/error-page.js';
+import { setPageContextCurrent } from './getPageContextCurrent.js';
 import { getRouteStringParameterList } from '../../shared/route/resolveRouteString.js';
 const globalObject = getGlobalObject('renderPageClientSide.ts', (() => {
     const { promise: firstRenderStartPromise, resolve: firstRenderStartPromiseResolve } = genPromise();
@@ -32,6 +33,7 @@ async function renderPageClientSide(renderArgs) {
     const { urlOriginal = getCurrentUrl(), overwriteLastHistoryEntry = false, isBackwardNavigation, pageContextsFromRewrite = [], redirectCount = 0, isUserLandPushStateNavigation, isClientSideNavigation = true } = renderArgs;
     let { scrollTarget } = renderArgs;
     const { previousPageContext } = globalObject;
+    addLinkPrefetchHandlers_unwatch();
     const { isRenderOutdated, setHydrationCanBeAborted, isFirstRender } = getIsRenderOutdated();
     // Note that pageContext.isHydration isn't equivalent to isFirstRender
     // - Thus pageContext.isHydration isn't equivalent to !pageContext.isClientSideNavigation
@@ -51,7 +53,7 @@ async function renderPageClientSide(renderArgs) {
         const onError = async (err) => {
             await renderErrorPage({ err });
         };
-        const pageContext = await getPageContextBegin();
+        const pageContext = await getPageContextBegin(false);
         if (isRenderOutdated())
             return;
         // onPageTransitionStart()
@@ -79,10 +81,13 @@ async function renderPageClientSide(renderArgs) {
             }
         }
         // Route
-        let pageContextRouted;
         if (isFirstRender) {
             const pageContextSerialized = getPageContextFromHooks_serialized();
-            pageContextRouted = pageContextSerialized;
+            // TODO/eventually: create helper assertPageContextFromHook()
+            assert(!('urlOriginal' in pageContextSerialized));
+            objectAssign(pageContext, pageContextSerialized);
+            // TODO/pageContext-prefetch: remove or change, because this only makes sense for a pre-rendered page
+            populatePageContextPrefetchCache(pageContext, { pageContextFromServerHooks: pageContextSerialized });
         }
         else {
             let pageContextFromRoute;
@@ -123,10 +128,10 @@ async function renderPageClientSide(renderArgs) {
                 // Skip's Vike's rendering; let the user handle the navigation
                 return;
             }
-            pageContextRouted = pageContextFromRoute;
+            // TODO/eventually: create helper assertPageContextFromHook()
+            assert(!('urlOriginal' in pageContextFromRoute));
+            objectAssign(pageContext, pageContextFromRoute);
         }
-        assert(!('urlOriginal' in pageContextRouted));
-        objectAssign(pageContext, pageContextRouted);
         try {
             objectAssign(pageContext, await loadUserFilesClientSide(pageContext.pageId, pageContext._pageFilesAll, pageContext._pageConfigs));
         }
@@ -142,6 +147,7 @@ async function renderPageClientSide(renderArgs) {
         }
         if (isRenderOutdated())
             return;
+        setPageContextCurrent(pageContext);
         // Set global hydrationCanBeAborted
         if (pageContext.exports.hydrationCanBeAborted) {
             setHydrationCanBeAborted();
@@ -149,7 +155,7 @@ async function renderPageClientSide(renderArgs) {
         else {
             assertWarning(!isReact(), 'You seem to be using React; we recommend setting hydrationCanBeAborted to true, see https://vike.dev/hydrationCanBeAborted', { onlyOnce: true });
         }
-        // There wasn't any `await` but result may change because we just called setHydrationCanBeAborted()
+        // There wasn't any `await` but the isRenderOutdated() return value may have changed because we called setHydrationCanBeAborted()
         if (isRenderOutdated())
             return;
         // Get pageContext from hooks (fetched from server, and/or directly called on the client-side)
@@ -170,9 +176,35 @@ async function renderPageClientSide(renderArgs) {
             await renderPageView(pageContext);
         }
         else {
-            let res;
+            // Fetch pageContext from server-side hooks
+            let pageContextFromServerHooks;
+            const pageContextPrefetched = getPageContextPrefetched(pageContext);
+            if (pageContextPrefetched) {
+                pageContextFromServerHooks = pageContextPrefetched;
+            }
+            else {
+                try {
+                    const result = await getPageContextFromServerHooks(pageContext, false);
+                    if (result.is404ServerSideRouted)
+                        return;
+                    pageContextFromServerHooks = result.pageContextFromServerHooks;
+                    // TODO/pageContext-prefetch: remove or change, because this only makes sense for a pre-rendered page
+                    populatePageContextPrefetchCache(pageContext, result);
+                }
+                catch (err) {
+                    await onError(err);
+                    return;
+                }
+            }
+            if (isRenderOutdated())
+                return;
+            // TODO/eventually: create helper assertPageContextFromHook()
+            assert(!('urlOriginal' in pageContextFromServerHooks));
+            objectAssign(pageContext, pageContextFromServerHooks);
+            // Get pageContext from client-side hooks
+            let pageContextFromClientHooks;
             try {
-                res = await getPageContextFromHooks_isNotHydration(pageContext, false);
+                pageContextFromClientHooks = await getPageContextFromClientHooks(pageContext, false);
             }
             catch (err) {
                 await onError(err);
@@ -180,18 +212,16 @@ async function renderPageClientSide(renderArgs) {
             }
             if (isRenderOutdated())
                 return;
-            if ('is404ServerSideRouted' in res)
-                return;
-            augmentType(pageContext, res.pageContextAugmented);
-            // Render page view
+            augmentType(pageContext, pageContextFromClientHooks);
             await renderPageView(pageContext);
         }
     }
-    async function getPageContextBegin() {
+    async function getPageContextBegin(isForErrorPage) {
         const pageContext = await createPageContext(urlOriginal);
         objectAssign(pageContext, {
             isBackwardNavigation,
             isClientSideNavigation,
+            isHydration: isFirstRender && !isForErrorPage,
             _previousPageContext: previousPageContext
         });
         {
@@ -226,7 +256,7 @@ async function renderPageClientSide(renderArgs) {
                 // We handle the abort error down below.
             }
         }
-        const pageContext = await getPageContextBegin();
+        const pageContext = await getPageContextBegin(true);
         if (isRenderOutdated())
             return;
         if (args.is404)
@@ -310,21 +340,34 @@ async function renderPageClientSide(renderArgs) {
         }
         if (isRenderOutdated())
             return;
-        let res;
+        setPageContextCurrent(pageContext);
+        let pageContextFromServerHooks;
         try {
-            res = await getPageContextFromHooks_isNotHydration(pageContext, true);
+            const result = await getPageContextFromServerHooks(pageContext, true);
+            if (result.is404ServerSideRouted)
+                return;
+            pageContextFromServerHooks = result.pageContextFromServerHooks;
         }
         catch (err) {
-            // - When user hasn't defined a `_error.page.js` file
-            // - Some Vike unpexected internal error
             onError(err);
             return;
         }
         if (isRenderOutdated())
             return;
-        if ('is404ServerSideRouted' in res)
+        // TODO/eventually: create helper assertPageContextFromHook()
+        assert(!('urlOriginal' in pageContextFromServerHooks));
+        objectAssign(pageContext, pageContextFromServerHooks);
+        let pageContextFromClientHooks;
+        try {
+            pageContextFromClientHooks = await getPageContextFromClientHooks(pageContext, true);
+        }
+        catch (err) {
+            onError(err);
+            return;
+        }
+        if (isRenderOutdated())
             return;
-        augmentType(pageContext, res.pageContextAugmented);
+        augmentType(pageContext, pageContextFromClientHooks);
         objectAssign(pageContext, { routeParams: {} });
         await renderPageView(pageContext, args);
     }
@@ -372,7 +415,6 @@ async function renderPageClientSide(renderArgs) {
         /* We don't abort in order to ensure that onHydrationEnd() is called: we abort only after onHydrationEnd() is called.
         if (isRenderOutdated(true)) return
         */
-        addLinkPrefetchHandlers(pageContext);
         // onHydrationEnd()
         if (isFirstRender && !onRenderClientError) {
             assertHook(pageContext, 'onHydrationEnd');
@@ -427,6 +469,11 @@ async function renderPageClientSide(renderArgs) {
         setScrollPosition(scrollTarget);
         browserNativeScrollRestoration_disable();
         setInitialRenderIsDone();
+        if (pageContext._hasPageContextFromServer)
+            setPageContextInitIsPassedToClient(pageContext);
+        // Add link prefetch handlers
+        addLinkPrefetchHandlers_watch();
+        addLinkPrefetchHandlers();
     }
 }
 function changeUrl(url, overwriteLastHistoryEntry) {

package/dist/esm/node/plugin/plugins/importUserCode/v1-design/getVikeConfig/configDefinitionsBuiltIn.js

@@ -67,6 +67,11 @@ const configDefinitionsBuiltIn = {
     hydrationCanBeAborted: {
         env: { client: true }
     },
+    prefetch: {
+        env: { client: true },
+        eager: true
+    },
+    // TODO/v1-release: remove
     prefetchStaticAssets: {
         env: { client: true }
     },
@@ -100,10 +105,12 @@ const configDefinitionsBuiltIn = {
     },
     onBeforeRenderEnv: {
         env: { client: true },
+        eager: true,
         _computed: (configValueSources) => !isConfigSet(configValueSources, 'onBeforeRender') ? null : getConfigEnv(configValueSources, 'onBeforeRender')
     },
     dataEnv: {
         env: { client: true },
+        eager: true,
         _computed: (configValueSources) => !isConfigSet(configValueSources, 'data') ? null : getConfigEnv(configValueSources, 'data')
     },
     hooksTimeout: {
@@ -149,7 +156,13 @@ function getConfigEnv(configValueSources, configName) {
     const configValueSource = getConfigValueSource(configValueSources, configName);
     if (!configValueSource)
         return null;
-    return configValueSource.configEnv;
+    const { configEnv } = configValueSource;
+    const env = {};
+    if (configEnv.client)
+        env.client = true;
+    if (configEnv.server)
+        env.server = true;
+    return env;
 }
 function isConfigSet(configValueSources, configName) {
     const configValueSource = getConfigValueSource(configValueSources, configName);

package/dist/esm/node/plugin/plugins/importUserCode/v1-design/getVikeConfig/loadFileAtConfigTime.js

@@ -6,7 +6,7 @@ import { assert, assertUsage, hasProp, assertIsNotProductionRuntime } from '../.
 import { transpileAndExecuteFile } from './transpileAndExecuteFile.js';
 import { assertPlusFileExport } from '../../../../../../shared/page-configs/assertPlusFileExport.js';
 import pc from '@brillout/picocolors';
-import { parsePointerImportData } from './transformFileImports.js';
+import { parsePointerImportData } from './transformPointerImports.js';
 import { getConfigFileExport } from '../getConfigFileExport.js';
 import { resolvePointerImport } from './resolvePointerImport.js';
 assertIsNotProductionRuntime();

package/dist/esm/node/plugin/plugins/importUserCode/v1-design/getVikeConfig/resolvePointerImport.d.ts

@@ -2,7 +2,7 @@ export { resolvePointerImportOfConfig };
 export { resolvePointerImport };
 export { clearFilesEnvMap };
 import type { ConfigEnvInternal, DefinedAtFilePath } from '../../../../../../shared/page-configs/PageConfig.js';
-import { type PointerImportData } from './transformFileImports.js';
+import { type PointerImportData } from './transformPointerImports.js';
 import type { FilePath, FilePathResolved } from '../../../../../../shared/page-configs/FilePath.js';
 type PointerImportResolved = DefinedAtFilePath & {
     fileExportName: string;