vike 0.4.144 → 0.4.145-commit-2520555

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

@@ -1,15 +1,30 @@
 export { prefetch };
 export { addLinkPrefetchHandlers };
-import { assert, assertClientRouting, assertUsage, checkIfClientRouting } from './utils.js';
+import { assert, assertClientRouting, assertUsage, assertWarning, checkIfClientRouting, getGlobalObject, isExternalLink } from './utils.js';
 import { isErrorFetchingStaticAssets, loadPageFilesClientSide } from '../shared/loadPageFilesClientSide.js';
-import { isClientSideRoutable, skipLink } from './skipLink.js';
-import { getPageId } from './getPageId.js';
+import { skipLink } from './skipLink.js';
 import { getPrefetchSettings } from './prefetch/getPrefetchSettings.js';
 import { isAlreadyPrefetched, markAsAlreadyPrefetched } from './prefetch/alreadyPrefetched.js';
-import { disableClientRouting } from './useClientRouter.js';
-import { isExternalLink } from './isExternalLink.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';
 assertClientRouting();
-const linkPrefetchHandlerAdded = new Map();
+const globalObject = getGlobalObject('prefetch.ts', { linkPrefetchHandlerAdded: new Map() });
+async function prefetchAssets(pageId, pageContext) {
+    try {
+        await loadPageFilesClientSide(pageId, pageContext);
+    }
+    catch (err) {
+        if (isErrorFetchingStaticAssets(err)) {
+            disableClientRouting(err, true);
+        }
+        else {
+            throw err;
+        }
+    }
+}
 /**
  * Programmatically prefetch client assets.
  *
@@ -21,33 +36,38 @@ async function prefetch(url) {
     assertUsage(checkIfClientRouting(), 'prefetch() only works with Client Routing, see https://vike.dev/prefetch', {
         showStackTrace: true
     });
-    assertUsage(!isExternalLink(url), `You are trying to prefetch the URL ${url} of another domain which cannot be prefetched`, { showStackTrace: true });
+    const errPrefix = `Cannot prefetch URL ${url} because it`;
+    assertUsage(!isExternalLink(url), `${errPrefix} lives on another domain`, { showStackTrace: true });
     if (isAlreadyPrefetched(url))
         return;
     markAsAlreadyPrefetched(url);
-    const { pageId, pageFilesAll, pageConfigs } = await getPageId(url);
-    if (pageId) {
-        try {
-            await loadPageFilesClientSide(pageFilesAll, pageConfigs, pageId);
-        }
-        catch (err) {
-            if (isErrorFetchingStaticAssets(err)) {
-                disableClientRouting(err, true);
-            }
-            else {
-                throw err;
-            }
-        }
+    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} ${noRouteMatch}`, {
+            showStackTrace: true,
+            onlyOnce: false
+        });
+        return;
+    }
+    await prefetchAssets(pageId, pageContext);
 }
 function addLinkPrefetchHandlers(pageContext) {
     // Current URL is already prefetched
     markAsAlreadyPrefetched(pageContext.urlPathname);
     const linkTags = [...document.getElementsByTagName('A')];
     linkTags.forEach((linkTag) => {
-        if (linkPrefetchHandlerAdded.has(linkTag))
+        if (globalObject.linkPrefetchHandlerAdded.has(linkTag))
             return;
-        linkPrefetchHandlerAdded.set(linkTag, true);
+        globalObject.linkPrefetchHandlerAdded.set(linkTag, true);
         const url = linkTag.getAttribute('href');
         if (skipLink(linkTag))
             return;
@@ -59,17 +79,17 @@ function addLinkPrefetchHandlers(pageContext) {
             return;
         if (prefetchStaticAssets === 'hover') {
             linkTag.addEventListener('mouseover', () => {
-                prefetchIfClientSideRoutable(url);
+                prefetchIfPossible(url);
             });
             linkTag.addEventListener('touchstart', () => {
-                prefetchIfClientSideRoutable(url);
+                prefetchIfPossible(url);
             }, { passive: true });
         }
         if (prefetchStaticAssets === 'viewport') {
             const observer = new IntersectionObserver((entries) => {
                 entries.forEach((entry) => {
                     if (entry.isIntersecting) {
-                        prefetchIfClientSideRoutable(url);
+                        prefetchIfPossible(url);
                         observer.disconnect();
                     }
                 });
@@ -78,14 +98,19 @@ function addLinkPrefetchHandlers(pageContext) {
         }
     });
 }
-async function prefetchIfClientSideRoutable(url) {
+async function prefetchIfPossible(url) {
+    const pageContext = await createPageContext(url);
+    let pageContextFromRoute;
     try {
-        if (!(await isClientSideRoutable(url)))
-            return;
+        pageContextFromRoute = await route(pageContext);
     }
     catch {
         // If a route() hook has a bug or `throw render()` / `throw redirect()`
         return;
     }
-    await prefetch(url);
+    if (!pageContextFromRoute?._pageId)
+        return;
+    if (!(await isClientSideRoutable(pageContextFromRoute._pageId, pageContext)))
+        return;
+    await prefetchAssets(pageContextFromRoute._pageId, pageContext);
 }

package/dist/esm/client/client-routing-runtime/renderPageClientSide.d.ts

@@ -0,0 +1,19 @@
+export { renderPageClientSide };
+export { getRenderCount };
+export { disableClientRouting };
+import { PageContextFromRewrite } from '../../shared/route/abort.js';
+import { type ScrollTarget } from './setScrollPosition.js';
+type RenderArgs = {
+    scrollTarget: ScrollTarget;
+    isBackwardNavigation: boolean | null;
+    urlOriginal?: string;
+    overwriteLastHistoryEntry?: boolean;
+    pageContextsFromRewrite?: PageContextFromRewrite[];
+    redirectCount?: number;
+    /** Whether the navigation was triggered by the user land calling `history.pushState()` */
+    isUserLandPushStateNavigation?: boolean;
+    isClientSideNavigation?: boolean;
+};
+declare function renderPageClientSide(renderArgs: RenderArgs): Promise<void>;
+declare function disableClientRouting(err: unknown, log: boolean): void;
+declare function getRenderCount(): number;

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

@@ -0,0 +1,347 @@
+export { renderPageClientSide };
+export { getRenderCount };
+export { disableClientRouting };
+import { assert, getCurrentUrl, isEquivalentError, objectAssign, serverSideRouteTo, getGlobalObject, executeHook, hasProp } from './utils.js';
+import { getPageContextFromHooks_errorPage, getPageContextFromHooks_firstRender, getPageContextFromHooks_uponNavigation, isAlreadyServerSideRouted } from './getPageContextFromHooks.js';
+import { createPageContext } from './createPageContext.js';
+import { addLinkPrefetchHandlers } from './prefetch.js';
+import { assertInfo, assertWarning, isReact } from './utils.js';
+import { executeOnRenderClientHook } from '../shared/executeOnRenderClientHook.js';
+import { assertHook } from '../../shared/hooks/getHook.js';
+import { isErrorFetchingStaticAssets } from '../shared/loadPageFilesClientSide.js';
+import { pushHistory } from './history.js';
+import { assertNoInfiniteAbortLoop, getPageContextFromAllRewrites, isAbortError, logAbortErrorHandled } from '../../shared/route/abort.js';
+import { route } from '../../shared/route/index.js';
+import { isClientSideRoutable } from './isClientSideRoutable.js';
+import { setScrollPosition } from './setScrollPosition.js';
+import { updateState } from './onBrowserHistoryNavigation.js';
+import { browserNativeScrollRestoration_disable, setInitialRenderIsDone } from './scrollRestoration.js';
+const globalObject = getGlobalObject('renderPageClientSide.ts', { renderCounter: 0 });
+async function renderPageClientSide(renderArgs) {
+    const { scrollTarget, urlOriginal = getCurrentUrl(), overwriteLastHistoryEntry = false, isBackwardNavigation, pageContextsFromRewrite = [], redirectCount = 0, isUserLandPushStateNavigation, isClientSideNavigation = true } = renderArgs;
+    const { abortRender, setHydrationCanBeAborted, isFirstRender } = getAbortRender();
+    assert(isClientSideNavigation === !isFirstRender);
+    assertNoInfiniteAbortLoop(pageContextsFromRewrite.length, redirectCount);
+    if (globalObject.clientRoutingIsDisabled) {
+        serverSideRouteTo(urlOriginal);
+        return;
+    }
+    const pageContext = await createPageContext(urlOriginal);
+    if (abortRender())
+        return;
+    objectAssign(pageContext, {
+        isBackwardNavigation,
+        isClientSideNavigation
+    });
+    {
+        const pageContextFromAllRewrites = getPageContextFromAllRewrites(pageContextsFromRewrite);
+        objectAssign(pageContext, pageContextFromAllRewrites);
+    }
+    let renderState = {};
+    const onError = (err) => {
+        assert(err);
+        assert(!('err' in renderState));
+        assert(!('errorWhileRendering' in pageContext));
+        renderState.err = err;
+        pageContext.errorWhileRendering = err;
+    };
+    if (!isFirstRender) {
+        // Route
+        try {
+            renderState = { pageContextFromRoute: await route(pageContext) };
+        }
+        catch (err) {
+            onError(err);
+        }
+        if (abortRender())
+            return;
+        // Check whether rendering should be skipped
+        if (renderState.pageContextFromRoute) {
+            const { pageContextFromRoute } = renderState;
+            objectAssign(pageContext, pageContextFromRoute);
+            let isClientRoutable;
+            if (!pageContextFromRoute._pageId) {
+                isClientRoutable = false;
+            }
+            else {
+                isClientRoutable = await isClientSideRoutable(pageContextFromRoute._pageId, pageContext);
+                if (abortRender())
+                    return;
+            }
+            if (!isClientRoutable) {
+                serverSideRouteTo(urlOriginal);
+                return;
+            }
+            const isSamePage = pageContextFromRoute._pageId &&
+                globalObject.previousPageContext?._pageId &&
+                pageContextFromRoute._pageId === globalObject.previousPageContext._pageId;
+            if (isUserLandPushStateNavigation && isSamePage) {
+                // Skip's Vike's rendering; let the user handle the navigation
+                return;
+            }
+        }
+    }
+    // onPageTransitionStart()
+    const callTransitionHooks = !isFirstRender;
+    if (callTransitionHooks) {
+        if (!globalObject.isTransitioning) {
+            await globalObject.onPageTransitionStart?.(pageContext);
+            globalObject.isTransitioning = true;
+            if (abortRender())
+                return;
+        }
+    }
+    if (isFirstRender) {
+        assert(!renderState.pageContextFromRoute);
+        assert(!renderState.err);
+        try {
+            renderState.pageContextFromHooks = await getPageContextFromHooks_firstRender(pageContext);
+        }
+        catch (err) {
+            onError(err);
+        }
+        if (abortRender())
+            return;
+    }
+    else {
+        if (!renderState.err) {
+            const { pageContextFromRoute } = renderState;
+            assert(pageContextFromRoute);
+            assert(pageContextFromRoute._pageId);
+            assert(hasProp(pageContextFromRoute, '_pageId', 'string')); // Help TS
+            objectAssign(pageContext, pageContextFromRoute);
+            try {
+                renderState.pageContextFromHooks = await getPageContextFromHooks_uponNavigation(pageContext);
+            }
+            catch (err) {
+                onError(err);
+            }
+            if (abortRender())
+                return;
+        }
+    }
+    if ('err' in renderState) {
+        const { err } = renderState;
+        if (!isAbortError(err)) {
+            // We don't swallow 404 errors:
+            //  - On the server-side, Vike swallows / doesn't show any 404 error log because it's expected that a user may go to some random non-existent URL. (We don't want to flood the app's error tracking with 404 logs.)
+            //  - On the client-side, if the user navigates to a 404 then it means that the UI has a broken link. (It isn't expected that users can go to some random URL using the client-side router, as it would require, for example, the user to manually change the URL of a link by manually manipulating the DOM which highly unlikely.)
+            console.error(err);
+        }
+        else {
+            // We swallow throw redirect()/render() called by client-side hooks onBeforeRender() and guard()
+            // We handle the abort error down below.
+        }
+        if (shouldSwallowAndInterrupt(err, pageContext, isFirstRender))
+            return;
+        if (isAbortError(err)) {
+            const errAbort = err;
+            logAbortErrorHandled(err, pageContext._isProduction, pageContext);
+            const pageContextAbort = errAbort._pageContextAbort;
+            // throw render('/some-url')
+            if (pageContextAbort._urlRewrite) {
+                await renderPageClientSide({
+                    ...renderArgs,
+                    scrollTarget: 'scroll-to-top-or-hash',
+                    pageContextsFromRewrite: [...pageContextsFromRewrite, pageContextAbort]
+                });
+                return;
+            }
+            // throw redirect('/some-url')
+            if (pageContextAbort._urlRedirect) {
+                const urlRedirect = pageContextAbort._urlRedirect.url;
+                if (urlRedirect.startsWith('http')) {
+                    // External redirection
+                    window.location.href = urlRedirect;
+                    return;
+                }
+                else {
+                    await renderPageClientSide({
+                        ...renderArgs,
+                        scrollTarget: 'scroll-to-top-or-hash',
+                        urlOriginal: urlRedirect,
+                        overwriteLastHistoryEntry: false,
+                        isBackwardNavigation: false,
+                        redirectCount: redirectCount + 1
+                    });
+                }
+                return;
+            }
+            // throw render(statusCode)
+            assert(pageContextAbort.abortStatusCode);
+            objectAssign(pageContext, pageContextAbort);
+            if (pageContextAbort.abortStatusCode === 404) {
+                objectAssign(pageContext, { is404: true });
+            }
+        }
+        else {
+            objectAssign(pageContext, { is404: false });
+        }
+        try {
+            renderState.pageContextFromHooks = await getPageContextFromHooks_errorPage(pageContext);
+        }
+        catch (err2) {
+            // - When user hasn't defined a `_error.page.js` file
+            // - Some unpexected vike internal error
+            if (shouldSwallowAndInterrupt(err2, pageContext, isFirstRender))
+                return;
+            if (!isFirstRender) {
+                setTimeout(() => {
+                    // We let the server show the 404 page
+                    window.location.pathname = urlOriginal;
+                }, 0);
+            }
+            if (!isEquivalentError(err, err2)) {
+                throw err2;
+            }
+            else {
+                // Abort
+                return;
+            }
+        }
+        if (abortRender())
+            return;
+    }
+    const { pageContextFromHooks } = renderState;
+    assert(pageContextFromHooks);
+    objectAssign(pageContext, pageContextFromHooks);
+    // Set global onPageTransitionStart()
+    assertHook(pageContext, 'onPageTransitionStart');
+    globalObject.onPageTransitionStart = pageContext.exports.onPageTransitionStart;
+    // Set global hydrationCanBeAborted
+    if (pageContext.exports.hydrationCanBeAborted) {
+        setHydrationCanBeAborted();
+    }
+    else {
+        assertWarning(!isReact(), 'You seem to be using React; we recommend setting hydrationCanBeAborted to true, see https://vike.dev/clientRouting', { onlyOnce: true });
+    }
+    // There wasn't any `await` but result may change because we just called setHydrationCanBeAborted()
+    if (abortRender())
+        return;
+    // We use globalObject.renderPromise in order to ensure that there is never two concurrent onRenderClient() calls
+    if (globalObject.renderPromise) {
+        // Make sure that the previous render has finished
+        await globalObject.renderPromise;
+        assert(globalObject.renderPromise === undefined);
+        if (abortRender())
+            return;
+    }
+    changeUrl(urlOriginal, overwriteLastHistoryEntry);
+    globalObject.previousPageContext = pageContext;
+    assert(globalObject.renderPromise === undefined);
+    globalObject.renderPromise = (async () => {
+        await executeOnRenderClientHook(pageContext, true);
+        addLinkPrefetchHandlers(pageContext);
+        globalObject.renderPromise = undefined;
+    })();
+    await globalObject.renderPromise;
+    assert(globalObject.renderPromise === undefined);
+    /* We don't abort in order to ensure that onHydrationEnd() is called: we abort only after onHydrationEnd() is called.
+    if (abortRender(true)) return
+    */
+    // onHydrationEnd()
+    if (isFirstRender) {
+        assertHook(pageContext, 'onHydrationEnd');
+        const { onHydrationEnd } = pageContext.exports;
+        if (onHydrationEnd) {
+            const hookFilePath = pageContext.exportsAll.onHydrationEnd[0].exportSource;
+            assert(hookFilePath);
+            await executeHook(() => onHydrationEnd(pageContext), 'onHydrationEnd', hookFilePath);
+            if (abortRender(true))
+                return;
+        }
+    }
+    // We abort only after onHydrationEnd() is called
+    if (abortRender(true))
+        return;
+    // onPageTransitionEnd()
+    if (callTransitionHooks) {
+        if (pageContext.exports.onPageTransitionEnd) {
+            assertHook(pageContext, 'onPageTransitionEnd');
+            await pageContext.exports.onPageTransitionEnd(pageContext);
+            if (abortRender(true))
+                return;
+        }
+        globalObject.isTransitioning = undefined;
+    }
+    // Page scrolling
+    setScrollPosition(scrollTarget);
+    browserNativeScrollRestoration_disable();
+    setInitialRenderIsDone();
+}
+function changeUrl(url, overwriteLastHistoryEntry) {
+    if (getCurrentUrl() === url)
+        return;
+    browserNativeScrollRestoration_disable();
+    pushHistory(url, overwriteLastHistoryEntry);
+    updateState();
+}
+function shouldSwallowAndInterrupt(err, pageContext, isFirstRender) {
+    if (isAlreadyServerSideRouted(err))
+        return true;
+    if (handleErrorFetchingStaticAssets(err, pageContext, isFirstRender))
+        return true;
+    return false;
+}
+function handleErrorFetchingStaticAssets(err, pageContext, isFirstRender) {
+    if (!isErrorFetchingStaticAssets(err)) {
+        return false;
+    }
+    if (isFirstRender) {
+        disableClientRouting(err, false);
+        // This may happen if the frontend was newly deployed during hydration.
+        // Ideally: re-try a couple of times by reloading the page (not entirely trivial to implement since `localStorage` is needed.)
+        throw err;
+    }
+    else {
+        disableClientRouting(err, true);
+    }
+    serverSideRouteTo(pageContext.urlOriginal);
+    return true;
+}
+function disableClientRouting(err, log) {
+    assert(isErrorFetchingStaticAssets(err));
+    globalObject.clientRoutingIsDisabled = true;
+    if (log) {
+        // We don't use console.error() to avoid flooding error trackers such as Sentry
+        console.log(err);
+    }
+    // @ts-ignore Since dist/cjs/client/ is never used, we can ignore this error.
+    const isProd = import.meta.env.PROD;
+    assertInfo(false, [
+        'Failed to fetch static asset.',
+        isProd ? 'This usually happens when a new frontend is deployed.' : null,
+        'Falling back to Server Routing.',
+        '(The next page navigation will use Server Routing instead of Client Routing.)'
+    ]
+        .filter(Boolean)
+        .join(' '), { onlyOnce: true });
+}
+function getAbortRender() {
+    const renderNumber = ++globalObject.renderCounter;
+    assert(renderNumber >= 1);
+    let hydrationCanBeAborted = false;
+    const setHydrationCanBeAborted = () => {
+        hydrationCanBeAborted = true;
+    };
+    /** Whether the rendering should be aborted because a new rendering has started. We should call this after each `await`. */
+    const abortRender = (isRenderCleanup) => {
+        // Never abort hydration if `hydrationCanBeAborted` isn't `true`
+        if (!isRenderCleanup) {
+            const isHydration = renderNumber === 1;
+            if (isHydration && !hydrationCanBeAborted) {
+                return false;
+            }
+        }
+        // If there is a newer rendering, we should abort all previous renderings
+        return renderNumber !== globalObject.renderCounter;
+    };
+    return {
+        abortRender,
+        setHydrationCanBeAborted,
+        isFirstRender: renderNumber === 1
+    };
+}
+function getRenderCount() {
+    return globalObject.renderCounter;
+}

package/dist/esm/client/client-routing-runtime/scrollRestoration.d.ts

@@ -0,0 +1,6 @@
+export { browserNativeScrollRestoration_disable };
+export { setupNativeScrollRestoration };
+export { setInitialRenderIsDone };
+declare function setupNativeScrollRestoration(): void;
+declare function setInitialRenderIsDone(): void;
+declare function browserNativeScrollRestoration_disable(): void;

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

@@ -0,0 +1,25 @@
+// Handle the browser's native scroll restoration mechanism
+export { browserNativeScrollRestoration_disable };
+export { setupNativeScrollRestoration };
+export { setInitialRenderIsDone };
+import { getGlobalObject, onPageHide, onPageShow } from './utils.js';
+const globalObject = getGlobalObject('scrollRestoration.ts', {});
+// We use the browser's native scroll restoration mechanism only for the first render
+function setupNativeScrollRestoration() {
+    browserNativeScrollRestoration_enable();
+    onPageHide(browserNativeScrollRestoration_enable);
+    onPageShow(() => globalObject.initialRenderIsDone && browserNativeScrollRestoration_disable());
+}
+function setInitialRenderIsDone() {
+    globalObject.initialRenderIsDone = true;
+}
+function browserNativeScrollRestoration_disable() {
+    if ('scrollRestoration' in window.history) {
+        window.history.scrollRestoration = 'manual';
+    }
+}
+function browserNativeScrollRestoration_enable() {
+    if ('scrollRestoration' in window.history) {
+        window.history.scrollRestoration = 'auto';
+    }
+}

package/dist/esm/client/client-routing-runtime/setScrollPosition.d.ts

@@ -0,0 +1,7 @@
+export { setScrollPosition };
+export { autoSaveScrollPosition };
+export type { ScrollTarget };
+import { type ScrollPosition } from './history.js';
+type ScrollTarget = ScrollPosition | 'scroll-to-top-or-hash' | 'preserve-scroll';
+declare function setScrollPosition(scrollTarget: ScrollTarget): void;
+declare function autoSaveScrollPosition(): void;

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

@@ -0,0 +1,77 @@
+export { setScrollPosition };
+export { autoSaveScrollPosition };
+import { assert, onPageHide, sleep, throttle } from './utils.js';
+import { saveScrollPosition } from './history.js';
+function setScrollPosition(scrollTarget) {
+    if (scrollTarget === 'preserve-scroll') {
+        return;
+    }
+    let scrollPosition;
+    if (scrollTarget === 'scroll-to-top-or-hash') {
+        const hash = getUrlHash();
+        // We replicate the browser's native behavior
+        if (hash && hash !== 'top') {
+            const hashTarget = document.getElementById(hash) || document.getElementsByName(hash)[0];
+            if (hashTarget) {
+                hashTarget.scrollIntoView();
+                return;
+            }
+        }
+        scrollPosition = { x: 0, y: 0 };
+    }
+    else {
+        assert('x' in scrollTarget && 'y' in scrollTarget);
+        scrollPosition = scrollTarget;
+    }
+    setScroll(scrollPosition);
+}
+/** Change the browser's scoll position, in a way that works during a repaint. */
+function setScroll(scrollPosition) {
+    const scroll = () => window.scrollTo(scrollPosition.x, scrollPosition.y);
+    const done = () => window.scrollX === scrollPosition.x && window.scrollY === scrollPosition.y;
+    // In principle, this `done()` call should force the repaint to be finished. But that doesn't seem to be the case with `Firefox 97.0.1`.
+    if (done())
+        return;
+    scroll();
+    // Because `done()` doesn't seem to always force the repaint to be finished, we potentially need to retry again.
+    if (done())
+        return;
+    requestAnimationFrame(() => {
+        scroll();
+        if (done())
+            return;
+        setTimeout(async () => {
+            scroll();
+            if (done())
+                return;
+            // In principle, `requestAnimationFrame() -> setTimeout(, 0)` should be enough.
+            //  - https://stackoverflow.com/questions/61281139/waiting-for-repaint-in-javascript
+            //  - But it's not enough for `Firefox 97.0.1`.
+            //  - The following strategy is very agressive. It doesn't need to be that aggressive for Firefox. But we do it to be safe.
+            const start = new Date().getTime();
+            while (true) {
+                await sleep(10);
+                scroll();
+                if (done())
+                    return;
+                const millisecondsElapsed = new Date().getTime() - start;
+                if (millisecondsElapsed > 100)
+                    return;
+            }
+        }, 0);
+    });
+}
+function getUrlHash() {
+    let { hash } = window.location;
+    if (hash === '')
+        return null;
+    assert(hash.startsWith('#'));
+    hash = hash.slice(1);
+    return hash;
+}
+// Save scroll position (needed for back-/forward navigation)
+function autoSaveScrollPosition() {
+    // Safari cannot handle more than 100 `history.replaceState()` calls within 30 seconds (https://github.com/vikejs/vike/issues/46)
+    window.addEventListener('scroll', throttle(saveScrollPosition, Math.ceil(1000 / 3)), { passive: true });
+    onPageHide(saveScrollPosition);
+}

package/dist/esm/client/client-routing-runtime/skipLink.d.ts

@@ -1,3 +1,2 @@
 export { skipLink };
-export { isClientSideRoutable } from './skipLink/isClientSideRoutable.js';
 declare function skipLink(linkTag: HTMLElement): boolean;

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

@@ -1,9 +1,6 @@
 export { skipLink };
-export { isClientSideRoutable } from './skipLink/isClientSideRoutable.js';
 import { getBaseServer } from './getBaseServer.js';
-import { isExternalLink } from './isExternalLink.js';
-import { assert, parseUrl, isBaseServer, isParsable } from './utils.js';
-import { isDisableAutomaticLinkInterception } from './useClientRouter.js';
+import { assert, parseUrl, isBaseServer, isParsable, isExternalLink } from './utils.js';
 function skipLink(linkTag) {
     const url = linkTag.getAttribute('href');
     if (url === null)
@@ -27,7 +24,7 @@ function skipLink(linkTag) {
         return true;
     return false;
 }
-// TODO/v1-release: remove this in favor of synchronously checking whether URL matches the route of a page (possible since Async Route Functions are now deprecated)
+// TODO/v1-release: remove this in favor of synchronously checking whether URL matches the route of a page (possible since Async Route Functions will be deprecated)
 function isVikeLink(linkTag) {
     const disableAutomaticLinkInterception = isDisableAutomaticLinkInterception();
     if (!disableAutomaticLinkInterception) {
@@ -59,3 +56,10 @@ function hasBaseServer(url) {
     const { hasBaseServer } = parseUrl(url, baseServer);
     return hasBaseServer;
 }
+function isDisableAutomaticLinkInterception() {
+    // @ts-ignore
+    return !!window._disableAutomaticLinkInterception;
+    /* globalObject should be used if we want to make disableAutomaticLinkInterception a page-by-page setting
+    return globalObject.disableAutomaticLinkInterception ?? false
+    */
+}

package/dist/esm/client/client-routing-runtime/utils.d.ts

@@ -20,3 +20,5 @@ export * from '../../utils/sleep.js';
 export * from '../../utils/slice.js';
 export * from '../../utils/throttle.js';
 export * from '../../utils/assertRoutingType.js';
+export * from '../../utils/onPageVisibilityChange.js';
+export * from '../../utils/isExternalLink.js';

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

@@ -26,3 +26,5 @@ export * from '../../utils/sleep.js';
 export * from '../../utils/slice.js';
 export * from '../../utils/throttle.js';
 export * from '../../utils/assertRoutingType.js';
+export * from '../../utils/onPageVisibilityChange.js';
+export * from '../../utils/isExternalLink.js';