vike 0.0.0-alpha.0 → 0.4.142-commit-8bf568b

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

@@ -0,0 +1,240 @@
+export { getPageContext };
+export { getPageContextErrorPage };
+export { checkIf404 };
+export { isAlreadyServerSideRouted };
+import { navigationState } from './navigationState.js';
+import { assert, assertUsage, hasProp, objectAssign, getProjectError, serverSideRouteTo, executeHook, isObject, getGlobalObject } from './utils.js';
+import { parse } from '@brillout/json-serializer/parse';
+import { getPageContextSerializedInHtml } from '../shared/getPageContextSerializedInHtml.js';
+import { analyzePageServerSide } from '../../shared/getPageFiles/analyzePageServerSide.js';
+import { route } from '../../shared/route/index.js';
+import { getErrorPageId } from '../../shared/error-page.js';
+import { getHook } from '../../shared/hooks/getHook.js';
+import { preparePageContextForUserConsumptionClientSide } from '../shared/preparePageContextForUserConsumptionClientSide.js';
+import { loadPageFilesClientSide } from '../shared/loadPageFilesClientSide.js';
+import { removeBuiltInOverrides } from './getPageContext/removeBuiltInOverrides.js';
+import { getPageContextRequestUrl } from '../../shared/getPageContextRequestUrl.js';
+import { getConfigValue, getPageConfig } from '../../shared/page-configs/utils.js';
+import { assertOnBeforeRenderHookReturn } from '../../shared/assertOnBeforeRenderHookReturn.js';
+import { executeGuardHook } from '../../shared/route/executeGuardHook.js';
+import { AbortRender, isAbortPageContext } from '../../shared/route/abort.js';
+const globalObject = getGlobalObject('router/getPageContext.ts', {});
+async function getPageContext(pageContext) {
+    if (pageContext._isFirstRenderAttempt && navigationState.isFirstUrl(pageContext.urlOriginal)) {
+        assert(hasProp(pageContext, '_isFirstRenderAttempt', 'true'));
+        const pageContextAddendum = await getPageContextFirstRender(pageContext);
+        setPageContextInitHasClientData(pageContextAddendum);
+        return pageContextAddendum;
+    }
+    else {
+        assert(hasProp(pageContext, '_isFirstRenderAttempt', 'false'));
+        const pageContextAddendum = await getPageContextUponNavigation(pageContext);
+        setPageContextInitHasClientData(pageContextAddendum);
+        return pageContextAddendum;
+    }
+}
+async function getPageContextFirstRender(pageContext) {
+    const pageContextAddendum = getPageContextSerializedInHtml();
+    removeBuiltInOverrides(pageContextAddendum);
+    objectAssign(pageContextAddendum, {
+        isHydration: true,
+        _hasPageContextFromClient: false
+    });
+    objectAssign(pageContextAddendum, await loadPageFilesClientSide(pageContext._pageFilesAll, pageContext._pageConfigs, pageContextAddendum._pageId));
+    {
+        const pageContextForHook = { ...pageContext, ...pageContextAddendum };
+        if (await onBeforeRenderClientOnlyExists(pageContextForHook)) {
+            const pageContextFromHook = await executeOnBeforeRenderHookClientSide(pageContextForHook);
+            objectAssign(pageContextAddendum, pageContextFromHook);
+        }
+    }
+    return pageContextAddendum;
+}
+async function getPageContextErrorPage(pageContext) {
+    const errorPageId = getErrorPageId(pageContext._pageFilesAll, pageContext._pageConfigs);
+    if (!errorPageId)
+        throw new Error('No error page defined.');
+    const pageContextAddendum = {
+        isHydration: false,
+        _pageId: errorPageId
+    };
+    objectAssign(pageContextAddendum, await getPageContextAlreadyRouted({ ...pageContext, ...pageContextAddendum }, true));
+    return pageContextAddendum;
+}
+async function getPageContextUponNavigation(pageContext) {
+    const pageContextAddendum = {
+        isHydration: false
+    };
+    objectAssign(pageContextAddendum, await getPageContextFromRoute(pageContext));
+    objectAssign(pageContextAddendum, await getPageContextAlreadyRouted({ ...pageContext, ...pageContextAddendum }, false));
+    return pageContextAddendum;
+}
+async function getPageContextAlreadyRouted(pageContext, isErrorPage) {
+    let pageContextAddendum = {};
+    objectAssign(pageContextAddendum, await loadPageFilesClientSide(pageContext._pageFilesAll, pageContext._pageConfigs, pageContext._pageId));
+    // Needs to be called before any client-side hook, because it may contain pageContextInit.user which is needed for guard() and onBeforeRender()
+    if (
+    // For the error page, we cannot fetch pageContext from the server because the pageContext JSON request is based on the URL
+    !isErrorPage &&
+        (await hasPageContextServer({ ...pageContext, ...pageContextAddendum }))) {
+        const pageContextFromServer = await fetchPageContextFromServer(pageContext);
+        if (!pageContextFromServer['_isError']) {
+            objectAssign(pageContextAddendum, pageContextFromServer);
+        }
+        else {
+            const errorPageId = getErrorPageId(pageContext._pageFilesAll, pageContext._pageConfigs);
+            assert(errorPageId);
+            pageContextAddendum = {};
+            objectAssign(pageContextAddendum, {
+                isHydration: false,
+                _pageId: errorPageId
+            });
+            objectAssign(pageContextAddendum, await loadPageFilesClientSide(pageContext._pageFilesAll, pageContext._pageConfigs, pageContextAddendum._pageId));
+            assert(hasProp(pageContextFromServer, 'is404', 'boolean'));
+            assert(hasProp(pageContextFromServer, 'pageProps', 'object'));
+            assert(hasProp(pageContextFromServer.pageProps, 'is404', 'boolean'));
+            // When the user hasn't define a `_error.page.js` file: the mechanism with `serverSideError: true` is used instead
+            assert(!('serverSideError' in pageContextFromServer));
+            objectAssign(pageContextAddendum, pageContextFromServer);
+        }
+    }
+    else {
+        objectAssign(pageContextAddendum, { _hasPageContextFromServer: false });
+        // We don't need to call guard() on the client-side if we fetch pageContext from the server side. (Because the `${url}.pageContext.json` HTTP request will already trigger the routing and guard() hook on the serve-side.)
+        // We cannot call guard() before retrieving pageContext from server, since the server-side may define pageContextInit.user which is paramount for guard() hooks
+        if (!isErrorPage) {
+            // Should we really call the guard() hook on the client-side? Shouldn't we make the guard() hook a server-side only hook? Or maybe make its env configurable like onBeforeRender()?
+            await executeGuardHook({
+                _hasPageContextFromClient: false,
+                ...pageContext,
+                ...pageContextAddendum
+            }, (pageContext) => preparePageContextForUserConsumptionClientSide(pageContext, true));
+        }
+    }
+    {
+        // For the error page, we also execute the client-side onBeforeRender() hook, but maybe we shouldn't? The server-side does it as well (but maybe it shouldn't).
+        const pageContextFromHook = await executeOnBeforeRenderHookClientSide({ ...pageContext, ...pageContextAddendum });
+        objectAssign(pageContextAddendum, pageContextFromHook);
+    }
+    return pageContextAddendum;
+}
+async function executeOnBeforeRenderHookClientSide(pageContext) {
+    const hook = getHook(pageContext, 'onBeforeRender');
+    if (!hook) {
+        const pageContextAddendum = {
+            _hasPageContextFromClient: false
+        };
+        return pageContextAddendum;
+    }
+    const onBeforeRender = hook.hookFn;
+    const pageContextAddendum = {
+        _hasPageContextFromClient: true
+    };
+    const pageContextForUserConsumption = preparePageContextForUserConsumptionClientSide({
+        ...pageContext,
+        ...pageContextAddendum
+    }, true);
+    const hookResult = await executeHook(() => onBeforeRender(pageContextForUserConsumption), 'onBeforeRender', hook.hookFilePath);
+    assertOnBeforeRenderHookReturn(hookResult, hook.hookFilePath);
+    const pageContextFromHook = hookResult?.pageContext;
+    objectAssign(pageContextAddendum, pageContextFromHook);
+    return pageContextAddendum;
+}
+async function hasPageContextServer(pageContext) {
+    return !!globalObject.pageContextInitHasClientData || (await onBeforeRenderServerOnlyExists(pageContext));
+}
+// Workaround for the fact that the client-side cannot known whether a pageContext JSON request is needed in order to fetch pageContextInit data passed to the client.
+//  - The workaround is reliable as long as the user sets additional pageContextInit to undefined instead of not defining the property:
+//    ```diff
+//    - // Breaks the workaround:
+//    - const pageContextInit = { urlOriginal: req.url }
+//    - if (user) pageContextInit.user = user
+//    + // Makes the workaround reliable:
+//    + const pageContextInit = { urlOriginal: req.url, user }
+//    ```
+// - We can show a warning to users when the pageContextInit keys aren't always the same. (We didn't implement the waning yet because it would require a new doc page https://vike.dev/pageContextInit#avoid-conditional-properties
+// - Workaround cannot be made completely reliable because the workaround assumes that passToClient is always the same, but the user may set a different passToClient value for another page
+// - Alternatively, we could define a new config `alwaysFetchPageContextFromServer: boolean`
+function setPageContextInitHasClientData(pageContext) {
+    if (pageContext._pageContextInitHasClientData) {
+        globalObject.pageContextInitHasClientData = true;
+    }
+}
+async function onBeforeRenderServerOnlyExists(pageContext) {
+    if (pageContext._pageConfigs.length > 0) {
+        // V1
+        const pageConfig = getPageConfig(pageContext._pageId, pageContext._pageConfigs);
+        return getConfigValue(pageConfig, 'onBeforeRenderEnv')?.value === 'server-only';
+    }
+    else {
+        // TODO/v1-release: remove
+        // V0.4
+        const { hasOnBeforeRenderServerSideOnlyHook } = await analyzePageServerSide(pageContext._pageFilesAll, pageContext._pageId);
+        return hasOnBeforeRenderServerSideOnlyHook;
+    }
+}
+async function onBeforeRenderClientOnlyExists(pageContext) {
+    if (pageContext._pageConfigs.length > 0) {
+        // V1
+        const pageConfig = getPageConfig(pageContext._pageId, pageContext._pageConfigs);
+        return getConfigValue(pageConfig, 'onBeforeRenderEnv')?.value === 'client-only';
+    }
+    else {
+        // TODO/v1-release: remove
+        return false;
+    }
+}
+async function getPageContextFromRoute(pageContext) {
+    const routeResult = await route(pageContext);
+    const pageContextFromRoute = routeResult.pageContextAddendum;
+    if (!pageContextFromRoute._pageId) {
+        const err = new Error('No routing match');
+        markIs404(err);
+        throw err;
+    }
+    assert(hasProp(pageContextFromRoute, '_pageId', 'string'));
+    return pageContextFromRoute;
+}
+function markIs404(err) {
+    objectAssign(err, { _is404: true });
+}
+function checkIf404(err) {
+    return isObject(err) && err._is404 === true;
+}
+async function fetchPageContextFromServer(pageContext) {
+    const urlLogical = pageContext._urlRewrite ?? pageContext._urlOriginalPristine ?? pageContext.urlOriginal;
+    const pageContextUrl = getPageContextRequestUrl(urlLogical);
+    const response = await fetch(pageContextUrl);
+    {
+        const contentType = response.headers.get('content-type');
+        const contentTypeCorrect = 'application/json';
+        const isCorrect = contentType && contentType.includes(contentTypeCorrect);
+        // Static hosts + page doesn't exist
+        if (!isCorrect && response.status === 404) {
+            serverSideRouteTo(pageContext.urlOriginal);
+            throw AlreadyServerSideRouted();
+        }
+        assertUsage(isCorrect, `Wrong Content-Type for ${pageContextUrl}: it should be ${contentTypeCorrect} but it's ${contentType} instead. Make sure to properly use pageContext.httpResponse.headers, see https://vike.dev/renderPage`);
+    }
+    const responseText = await response.text();
+    const pageContextFromServer = parse(responseText);
+    assert(isObject(pageContextFromServer));
+    if ('serverSideError' in pageContextFromServer) {
+        throw getProjectError(`The pageContext object couldn't be fetched from the server as an error occurred on the server-side. Check your server logs.`);
+    }
+    if (isAbortPageContext(pageContextFromServer)) {
+        throw AbortRender(pageContextFromServer);
+    }
+    assert(hasProp(pageContextFromServer, '_pageId', 'string'));
+    removeBuiltInOverrides(pageContextFromServer);
+    objectAssign(pageContextFromServer, { _hasPageContextFromServer: true });
+    return pageContextFromServer;
+}
+function isAlreadyServerSideRouted(err) {
+    return isObject(err) && !!err._alreadyServerSideRouted;
+}
+function AlreadyServerSideRouted() {
+    const err = new Error("Page doesn't exist");
+    Object.assign(err, { _alreadyServerSideRouted: true });
+    return err;
+}

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

@@ -0,0 +1,10 @@
+export { getPageId };
+declare function getPageId(url: string): Promise<{
+    pageId: null;
+    pageFilesAll: import("../../shared/getPageFiles/getPageFileObject.js").PageFile[];
+    pageConfigs: import("../../shared/page-configs/PageConfig.js").PageConfig[];
+} | {
+    pageId: string;
+    pageFilesAll: import("../../shared/getPageFiles/getPageFileObject.js").PageFile[];
+    pageConfigs: import("../../shared/page-configs/PageConfig.js").PageConfig[];
+}>;

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

@@ -0,0 +1,17 @@
+export { getPageId };
+import { route } from '../../shared/route/index.js';
+import { createPageContext } from './createPageContext.js';
+async function getPageId(url) {
+    const pageContext = await createPageContext({ urlOriginal: url });
+    const routeContext = await route(pageContext);
+    const pageFilesAll = pageContext._pageFilesAll;
+    const pageConfigs = pageContext._pageConfigs;
+    if (!('pageContextAddendum' in routeContext)) {
+        return { pageId: null, pageFilesAll, pageConfigs };
+    }
+    const pageId = routeContext.pageContextAddendum._pageId;
+    if (!pageId) {
+        return { pageId: null, pageFilesAll, pageConfigs };
+    }
+    return { pageId, pageFilesAll, pageConfigs };
+}

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

@@ -0,0 +1,13 @@
+export { initHistoryState, getHistoryState, pushHistory, ScrollPosition, saveScrollPosition };
+type HistoryState = {
+    timestamp?: number;
+    scrollPosition?: null | ScrollPosition;
+};
+type ScrollPosition = {
+    x: number;
+    y: number;
+};
+declare function initHistoryState(): void;
+declare function getHistoryState(): HistoryState;
+declare function saveScrollPosition(): void;
+declare function pushHistory(url: string, overwriteLastHistoryEntry: boolean): void;

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

@@ -0,0 +1,71 @@
+export { initHistoryState, getHistoryState, pushHistory, saveScrollPosition };
+import { assert, hasProp, isObject } from './utils.js';
+// Fill missing state information.
+//  - The very first render => `history.state` is uninitialized (`null`).
+//  - The vike app runs `location.hash = '#section'` => `history.state` is uninitialized (`null`).
+//  - The user clicks on an anchor link `<a href="#section">Section</a>` => `history.state` is uninitialized (`null`).
+//  - `history.state` set by an old vike version => state information may be incomplete. (E.g. `state.timestamp` was introduced for `pageContext.isBackwardNavigation` in `0.4.19`.)
+function initHistoryState() {
+    let state = window.history.state;
+    if (!state) {
+        state = {};
+    }
+    let hasModifications = false;
+    if (!('timestamp' in state)) {
+        hasModifications = true;
+        state.timestamp = getTimestamp();
+    }
+    if (!('scrollPosition' in state)) {
+        hasModifications = true;
+        state.scrollPosition = getScrollPosition();
+    }
+    assertState(state);
+    if (hasModifications) {
+        replaceHistoryState(state);
+    }
+}
+function getHistoryState() {
+    const state = window.history.state || {};
+    assertState(state);
+    return state;
+}
+function getScrollPosition() {
+    const scrollPosition = { x: window.scrollX, y: window.scrollY };
+    return scrollPosition;
+}
+function getTimestamp() {
+    return new Date().getTime();
+}
+function saveScrollPosition() {
+    const scrollPosition = getScrollPosition();
+    const state = getHistoryState();
+    replaceHistoryState({ ...state, scrollPosition });
+}
+function pushHistory(url, overwriteLastHistoryEntry) {
+    if (!overwriteLastHistoryEntry) {
+        const timestamp = getTimestamp();
+        pushHistoryState({ timestamp, scrollPosition: null }, url);
+    }
+    else {
+        replaceHistoryState(getHistoryState(), url);
+    }
+}
+function assertState(state) {
+    assert(isObject(state));
+    if ('timestamp' in state) {
+        const { timestamp } = state;
+        assert(typeof timestamp === 'number');
+    }
+    if ('scrollPosition' in state) {
+        const { scrollPosition } = state;
+        if (scrollPosition !== null) {
+            assert(hasProp(scrollPosition, 'x', 'number') && hasProp(scrollPosition, 'y', 'number'));
+        }
+    }
+}
+function replaceHistoryState(state, url) {
+    window.history.replaceState(state, '', url ?? /* Passing `undefined` chokes older Edge versions */ null);
+}
+function pushHistoryState(state, url) {
+    window.history.pushState(state, '', url);
+}

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

@@ -0,0 +1,18 @@
+export { navigate, reload } from './navigate.js';
+export { prefetch } from './prefetch.js';
+import type { PageContextBuiltInClientWithClientRouting } from '../../shared/types.js';
+/** @deprecated
+ * Replace:
+ *   ```
+ *   import type { PageContextBuiltInClient } from 'vite-plugin/client/router'
+ *   ```
+ * With:
+ *   ```
+ *   import type {
+ *     PageContextBuiltInClientWithClientRouting as
+ *     PageContextBuiltInClient
+ *   } from 'vike/types'
+ *   ```
+ */
+type PageContextBuiltInClient<Page = any> = PageContextBuiltInClientWithClientRouting<Page>;
+export type { PageContextBuiltInClient };

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

@@ -0,0 +1,7 @@
+// TODO/v1-release - move:
+//   import { navigate, prefetch } from 'vike/client/router'
+// to:
+//   import { navigate, prefetch } from 'vike'
+// Use package.json#exports to make the imports isomorphic.
+export { navigate, reload } from './navigate.js';
+export { prefetch } from './prefetch.js';

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

@@ -0,0 +1,2 @@
+export { isExternalLink };
+declare function isExternalLink(url: string): boolean;

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

@@ -0,0 +1,4 @@
+export { isExternalLink };
+function isExternalLink(url) {
+    return !url.startsWith('/') && !url.startsWith('.') && !url.startsWith('?') && url !== '';
+}

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

@@ -0,0 +1,17 @@
+export { navigate };
+export { reload };
+export { defineNavigate };
+/** Programmatically navigate to a new page.
+ *
+ * https://vike.dev/navigate
+ *
+ * @param url - The URL of the new page.
+ * @param keepScrollPosition - Don't scroll to the top of the page, instead keep the current scroll position.
+ * @param overwriteLastHistoryEntry - Don't create a new entry in the browser's history, instead let the new URL replace the current URL. (This effectively removes the current URL from the browser history).
+ */
+declare function navigate(url: string, { keepScrollPosition, overwriteLastHistoryEntry }?: {
+    keepScrollPosition?: boolean | undefined;
+    overwriteLastHistoryEntry?: boolean | undefined;
+}): Promise<void>;
+declare function defineNavigate(navigate_: typeof navigate): void;
+declare function reload(): Promise<void>;

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

@@ -0,0 +1,34 @@
+export { navigate };
+export { reload };
+export { defineNavigate };
+import { assertUsage, isBrowser, getGlobalObject, assertClientRouting, checkIfClientRouting, getCurrentUrl } from './utils.js';
+assertClientRouting();
+const globalObject = getGlobalObject('navigate.ts', {});
+/** Programmatically navigate to a new page.
+ *
+ * https://vike.dev/navigate
+ *
+ * @param url - The URL of the new page.
+ * @param keepScrollPosition - Don't scroll to the top of the page, instead keep the current scroll position.
+ * @param overwriteLastHistoryEntry - Don't create a new entry in the browser's history, instead let the new URL replace the current URL. (This effectively removes the current URL from the browser history).
+ */
+async function navigate(url, { keepScrollPosition = false, overwriteLastHistoryEntry = false } = {}) {
+    assertUsage(isBrowser(), 'The navigate() function can be called only on the client-side', { showStackTrace: true });
+    const errMsg = 'navigate() works only with Client Routing, see https://vike.dev/navigate';
+    assertUsage(globalObject.navigate, errMsg, { showStackTrace: true });
+    assertUsage(checkIfClientRouting(), errMsg, { showStackTrace: true });
+    assertUsage(url, '[navigate(url)] Missing argument url', { showStackTrace: true });
+    assertUsage(typeof url === 'string', '[navigate(url)] Argument url should be a string', { showStackTrace: true });
+    assertUsage(typeof keepScrollPosition === 'boolean', '[navigate(url, { keepScrollPosition })] Argument keepScrollPosition should be a boolean', { showStackTrace: true });
+    assertUsage(typeof overwriteLastHistoryEntry === 'boolean', '[navigate(url, { overwriteLastHistoryEntry })] Argument overwriteLastHistoryEntry should be a boolean', { showStackTrace: true });
+    assertUsage(url.startsWith('/'), '[navigate(url)] Argument url should start with a leading /', {
+        showStackTrace: true
+    });
+    await globalObject.navigate(url, { keepScrollPosition, overwriteLastHistoryEntry });
+}
+function defineNavigate(navigate_) {
+    globalObject.navigate = navigate_;
+}
+async function reload() {
+    await navigate(getCurrentUrl());
+}

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

@@ -0,0 +1,5 @@
+export declare const navigationState: {
+    markNavigationChange(): void;
+    readonly noNavigationChangeYet: boolean;
+    isFirstUrl(url: string): boolean;
+};

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

@@ -0,0 +1,14 @@
+import { getCurrentUrl, getGlobalObject } from '../server-routing-runtime/utils.js';
+const globalObject = getGlobalObject('navigationState.ts', {});
+const urlFirst = getCurrentUrl();
+export const navigationState = {
+    markNavigationChange() {
+        globalObject.navigationChanged = true;
+    },
+    get noNavigationChangeYet() {
+        return !globalObject.navigationChanged && this.isFirstUrl(getCurrentUrl());
+    },
+    isFirstUrl(url) {
+        return url === urlFirst;
+    }
+};

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

@@ -0,0 +1,2 @@
+export { onLoad };
+declare function onLoad(): void;

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

@@ -0,0 +1,8 @@
+export { onLoad };
+import { assertIsBrowser } from '../../utils/assertIsBrowser.js';
+import { assertClientRouting } from '../../utils/assertRoutingType.js';
+function onLoad() {
+    assertIsBrowser();
+    // Ensure we don't bloat the Server Routing runtime with Client Routing utils
+    assertClientRouting();
+}

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

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,4 @@
+import { setPageFiles } from '../../shared/getPageFiles.js';
+// @ts-ignore
+import * as pageFilesExports from 'virtual:vike:importUserCode:client:client-routing';
+setPageFiles(pageFilesExports);

package/dist/esm/client/client-routing-runtime/prefetch/alreadyPrefetched.d.ts

@@ -0,0 +1,4 @@
+export { isAlreadyPrefetched };
+export { markAsAlreadyPrefetched };
+declare function isAlreadyPrefetched(url: string): boolean;
+declare function markAsAlreadyPrefetched(url: string): void;

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

@@ -0,0 +1,16 @@
+export { isAlreadyPrefetched };
+export { markAsAlreadyPrefetched };
+import { parseUrl } from '../utils.js';
+const linkAlreadyPrefetched = new Map();
+function isAlreadyPrefetched(url) {
+    const urlPathname = getUrlPathname(url);
+    return linkAlreadyPrefetched.has(urlPathname);
+}
+function markAsAlreadyPrefetched(url) {
+    const urlPathname = getUrlPathname(url);
+    linkAlreadyPrefetched.set(urlPathname, true);
+}
+function getUrlPathname(url) {
+    const urlPathname = parseUrl(url, '/').pathname;
+    return urlPathname;
+}

package/dist/esm/client/client-routing-runtime/prefetch/getPrefetchSettings.d.ts

@@ -0,0 +1,11 @@
+export { getPrefetchSettings };
+export type { PrefetchStaticAssets };
+type PageContextPrefetch = {
+    exports: Record<string, unknown>;
+    _isProduction: boolean;
+};
+type PrefetchStaticAssets = false | 'hover' | 'viewport';
+type PrefetchSettings = {
+    prefetchStaticAssets: PrefetchStaticAssets;
+};
+declare function getPrefetchSettings(pageContext: PageContextPrefetch, linkTag: HTMLElement): PrefetchSettings;

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

@@ -0,0 +1,82 @@
+export { getPrefetchSettings };
+import { assert, assertUsage, assertInfo, assertWarning, isPlainObject } from '../utils.js';
+function getPrefetchSettings(pageContext, linkTag) {
+    let prefetchStaticAssets = getPrefetchStaticAssets(pageContext, linkTag);
+    if (prefetchStaticAssets === 'viewport' && !pageContext._isProduction) {
+        assertInfo(false, 'Viewport prefetching is disabled in development', { onlyOnce: true });
+        prefetchStaticAssets = 'hover';
+    }
+    return {
+        prefetchStaticAssets
+    };
+}
+function getPrefetchStaticAssets(pageContext, linkTag) {
+    {
+        const prefetchAttribute = getPrefetchAttribute(linkTag);
+        if (prefetchAttribute !== null)
+            return prefetchAttribute;
+    }
+    // TODO/v1-release: remove
+    if ('prefetchLinks' in pageContext.exports) {
+        assertUsage(false, '`export { prefetchLinks }` is deprecated, use `export { prefetchStaticAssets }` instead.');
+    }
+    if ('prefetchStaticAssets' in pageContext.exports) {
+        const { prefetchStaticAssets } = pageContext.exports;
+        if (prefetchStaticAssets === false) {
+            return false;
+        }
+        if (prefetchStaticAssets === 'hover') {
+            return 'hover';
+        }
+        if (prefetchStaticAssets === 'viewport') {
+            return 'viewport';
+        }
+        const wrongUsageMsg = "prefetchStaticAssets value should be false, 'hover', or 'viewport'";
+        // TODO/v1-release: remove
+        assertUsage(isPlainObject(prefetchStaticAssets), wrongUsageMsg);
+        const keys = Object.keys(prefetchStaticAssets);
+        assertUsage(keys.length === 1 && keys[0] === 'when', wrongUsageMsg);
+        const { when } = prefetchStaticAssets;
+        if (when === 'HOVER' || when === 'VIEWPORT') {
+            const correctValue = when.toLowerCase();
+            assertWarning(false, `prefetchStaticAssets value \`{ when: '${when}' }\` is outdated: set prefetchStaticAssets to '${correctValue}' instead`, { onlyOnce: true });
+            return correctValue;
+        }
+        assertUsage(false, wrongUsageMsg);
+    }
+    return 'hover';
+}
+function getPrefetchAttribute(linkTag) {
+    const attr = linkTag.getAttribute('data-prefetch-static-assets');
+    const attrOld = linkTag.getAttribute('data-prefetch');
+    if (attr === null && attrOld === null) {
+        return null;
+    }
+    // TODO/v1-release: remove
+    const deprecationNotice = 'The attribute data-prefetch is outdated, use data-prefetch-static-assets instead.';
+    if (attr) {
+        assertUsage(attrOld === null, deprecationNotice);
+        if (attr === 'hover' || attr === 'viewport') {
+            return attr;
+        }
+        if (attr === 'false') {
+            return false;
+        }
+        assertUsage(false, `data-prefetch-static-assets has value "${attr}" but it should instead be "false", "hover", or "viewport"`);
+    }
+    // TODO/v1-release: remove
+    if (attrOld) {
+        assert(!attr);
+        assertWarning(false, deprecationNotice, {
+            onlyOnce: true
+        });
+        if (attrOld === 'true') {
+            return 'viewport';
+        }
+        if (attrOld === 'false') {
+            return 'hover';
+        }
+        assertUsage(false, `data-prefetch has value "${attrOld}" but it should instead be "true" or "false"`);
+    }
+    assert(false);
+}

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

@@ -0,0 +1,15 @@
+export { prefetch };
+export { addLinkPrefetchHandlers };
+/**
+ * Programmatically prefetch client assets.
+ *
+ * https://vike.dev/prefetch
+ *
+ * @param url - The URL of the page you want to prefetch.
+ */
+declare function prefetch(url: string): Promise<void>;
+declare function addLinkPrefetchHandlers(pageContext: {
+    exports: Record<string, unknown>;
+    _isProduction: boolean;
+    urlPathname: string;
+}): void;