inertiax-core 2.6.2 → 5.0.0

package/types/index.d.ts

@@ -1,8 +1,6 @@
-import { Router } from './router';
 export { default as createHeadManager } from './head';
-export { default as setupProgress } from './progress';
+export { hide as hideProgress, reveal as revealProgress, default as setupProgress } from './progress';
 export { default as shouldIntercept } from './shouldIntercept';
 export * from './types';
 export { hrefToUrl, mergeDataIntoQueryString, urlWithoutHash } from './url';
-export { type Router };
-export declare const router: Router;
+export { Router } from './router';

package/types/initialVisit.d.ts

@@ -0,0 +1,10 @@
+export declare class InitialVisit {
+    static handle(): void;
+    protected static clearRememberedStateOnReload(): void;
+    protected static handleBackForward(): boolean;
+    /**
+     * @link https://inertiajs.com/redirects#external-redirects
+     */
+    protected static handleLocation(): boolean;
+    protected static handleDefault(): void;
+}

package/types/navigationType.d.ts

@@ -0,0 +1,9 @@
+declare class NavigationType {
+    protected type: NavigationTimingType;
+    constructor();
+    get(): NavigationTimingType;
+    isBackForward(): boolean;
+    isReload(): boolean;
+}
+export declare const navigationType: NavigationType;
+export {};

package/types/objectUtils.d.ts

@@ -0,0 +1 @@
+export declare const objectsAreEqual: <T>(obj1: T, obj2: T, excludeKeys: { [K in keyof T]: K; }[keyof T][]) => boolean;

package/types/page.d.ts

@@ -0,0 +1,45 @@
+import { Frame, Component, Page, PageEvent, FrameHandler, PreserveStateOption, RouterInitParams, VisitOptions } from './types';
+declare class CurrentPage {
+    protected page: Page;
+    protected swappers: {
+        [frame: string]: FrameHandler;
+    };
+    protected componentId: {};
+    protected listeners: {
+        event: PageEvent;
+        callback: VoidFunction;
+    }[];
+    protected isFirstPageLoad: boolean;
+    protected cleared: boolean;
+    init({ frame, initialState, swapComponent }: RouterInitParams): this;
+    set(page: Page, { replace, preserveScroll, preserveState, }?: Partial<Pick<VisitOptions, 'replace' | 'preserveScroll' | 'preserveState'>>): Promise<void>;
+    setQuietly(page: Page, { preserveState, }?: {
+        preserveState?: PreserveStateOption;
+    }): Promise<unknown>;
+    setFrame(name: string, frame: Frame, options?: Partial<VisitOptions>): Promise<void>;
+    clear(): void;
+    isCleared(): boolean;
+    frame(name: string): Frame;
+    get(): Page;
+    merge(data: Partial<Page>): void;
+    setUrlHash(hash: string): void;
+    remember(frame: string, data: Frame['rememberedState']): void;
+    scrollRegions(regions: Page['scrollRegions']): void;
+    swap({ components, page, preserveState, }: {
+        components: {
+            [name: string]: Component;
+        };
+        page: Page;
+        preserveState: PreserveStateOption;
+    }): Promise<unknown>;
+    resolve(frames: {
+        [name: string]: Frame;
+    }): Promise<{
+        [name: string]: Component;
+    }>;
+    isTheSame(name: string, frame: Frame): boolean;
+    on(event: PageEvent, callback: VoidFunction): VoidFunction;
+    fireEventsFor(event: PageEvent): void;
+}
+export declare const page: CurrentPage;
+export {};

package/types/poll.d.ts

@@ -0,0 +1,13 @@
+import { PollOptions } from './types';
+export declare class Poll {
+    protected id: number | null;
+    protected throttle: boolean;
+    protected keepAlive: boolean;
+    protected cb: VoidFunction;
+    protected interval: number;
+    protected cbCount: number;
+    constructor(interval: number, cb: VoidFunction, options: PollOptions);
+    stop(): void;
+    start(): void;
+    isInBackground(hidden: boolean): void;
+}

package/types/polls.d.ts

@@ -0,0 +1,14 @@
+import { Poll } from './poll';
+import { PollOptions } from './types';
+declare class Polls {
+    protected polls: Poll[];
+    constructor();
+    add(interval: number, cb: VoidFunction, options: PollOptions): {
+        stop: VoidFunction;
+        start: VoidFunction;
+    };
+    clear(): void;
+    protected setupVisibilityListener(): void;
+}
+export declare const polls: Polls;
+export {};

package/types/prefetched.d.ts

@@ -0,0 +1,23 @@
+import { Response } from './response';
+import { ActiveVisit, CacheForOption, InFlightPrefetch, InternalActiveVisit, PrefetchedResponse, PrefetchOptions, PrefetchRemovalTimer } from './types';
+declare class PrefetchedRequests {
+    protected cached: PrefetchedResponse[];
+    protected inFlightRequests: InFlightPrefetch[];
+    protected removalTimers: PrefetchRemovalTimer[];
+    protected currentUseId: string | null;
+    add(params: ActiveVisit, sendFunc: (params: InternalActiveVisit) => void, { cacheFor }: PrefetchOptions): Promise<void> | Promise<Response>;
+    removeAll(): void;
+    remove(params: ActiveVisit): void;
+    protected extractStaleValues(cacheFor: PrefetchOptions['cacheFor']): [number, number];
+    protected cacheForToStaleAndExpires(cacheFor: PrefetchOptions['cacheFor']): [CacheForOption, CacheForOption];
+    protected clearTimer(params: ActiveVisit): void;
+    protected scheduleForRemoval(params: ActiveVisit, expiresIn: number): void;
+    get(params: ActiveVisit): InFlightPrefetch | PrefetchedResponse | null;
+    use(prefetched: PrefetchedResponse | InFlightPrefetch, params: ActiveVisit): Promise<void | undefined>;
+    protected removeSingleUseItems(params: ActiveVisit): void;
+    findCached(params: ActiveVisit): PrefetchedResponse | null;
+    findInFlight(params: ActiveVisit): InFlightPrefetch | null;
+    protected paramsAreEqual(params1: ActiveVisit, params2: ActiveVisit): boolean;
+}
+export declare const prefetchedRequests: PrefetchedRequests;
+export {};

package/types/progress.d.ts

@@ -1,3 +1,5 @@
+export declare const reveal: (force?: boolean) => void;
+export declare const hide: () => void;
 export default function setupProgress({ delay, color, includeCSS, showSpinner, }?: {
     delay?: number | undefined;
     color?: string | undefined;

package/types/request.d.ts

@@ -0,0 +1,22 @@
+import { AxiosProgressEvent, AxiosRequestConfig } from 'axios';
+import { RequestParams } from './requestParams';
+import { Response } from './response';
+import { ActiveVisit, Page } from './types';
+export declare class Request {
+    protected page: Page;
+    protected response: Response;
+    protected cancelToken: AbortController;
+    protected requestParams: RequestParams;
+    protected requestHasFinished: boolean;
+    constructor(params: ActiveVisit, page: Page);
+    static create(params: ActiveVisit, page: Page): Request;
+    send(): Promise<void | undefined>;
+    protected finish(): void;
+    protected fireFinishEvents(): void;
+    cancel({ cancelled, interrupted }: {
+        cancelled?: boolean;
+        interrupted?: boolean;
+    }): void;
+    protected onProgress(progress: AxiosProgressEvent): void;
+    protected getHeaders(): AxiosRequestConfig['headers'];
+}

package/types/requestParams.d.ts

@@ -0,0 +1,34 @@
+import { AxiosRequestConfig } from 'axios';
+import { Response } from './response';
+import { ActiveVisit, InternalActiveVisit, Page, PreserveStateOption, VisitCallbacks } from './types';
+export declare class RequestParams {
+    protected callbacks: {
+        name: keyof VisitCallbacks;
+        args: any[];
+    }[];
+    protected params: InternalActiveVisit;
+    constructor(params: InternalActiveVisit);
+    static create(params: ActiveVisit): RequestParams;
+    data(): import("./types").RequestPayload;
+    queryParams(): import("./types").RequestPayload;
+    isPartial(): boolean;
+    onCancelToken(cb: VoidFunction): void;
+    markAsFinished(): void;
+    markAsCancelled({ cancelled, interrupted }: {
+        cancelled?: boolean | undefined;
+        interrupted?: boolean | undefined;
+    }): void;
+    wasCancelledAtAll(): boolean;
+    onFinish(): void;
+    onStart(): void;
+    onPrefetching(): void;
+    onPrefetchResponse(response: Response): void;
+    all(): InternalActiveVisit;
+    headers(): AxiosRequestConfig['headers'];
+    setPreserveOptions(page: Page): void;
+    runCallbacks(): void;
+    merge(toMerge: Partial<ActiveVisit>): void;
+    protected wrapCallback(params: ActiveVisit, name: keyof VisitCallbacks): (...args: any[]) => void;
+    protected recordCallback(name: keyof VisitCallbacks, args: any[]): void;
+    protected resolvePreserveOption(value: PreserveStateOption, page: Page): boolean;
+}

package/types/requestStream.d.ts

@@ -0,0 +1,18 @@
+import { Request } from './request';
+export declare class RequestStream {
+    protected requests: Request[];
+    protected maxConcurrent: number;
+    protected interruptible: boolean;
+    constructor({ maxConcurrent, interruptible }: {
+        maxConcurrent: number;
+        interruptible: boolean;
+    });
+    send(request: Request): void;
+    interruptInFlight(): void;
+    cancelInFlight(): void;
+    protected cancel({ cancelled, interrupted }: {
+        cancelled?: boolean | undefined;
+        interrupted?: boolean | undefined;
+    } | undefined, force: boolean): void;
+    protected shouldCancel(force: boolean): boolean;
+}

package/types/response.d.ts

@@ -0,0 +1,31 @@
+import { AxiosResponse } from 'axios';
+import { RequestParams } from './requestParams';
+import { ActiveVisit, ErrorBag, Errors, Page, Frame } from './types';
+export declare class Response {
+    protected requestParams: RequestParams;
+    protected response: AxiosResponse;
+    protected originatingPage: Page;
+    constructor(requestParams: RequestParams, response: AxiosResponse, originatingPage: Page);
+    static create(params: RequestParams, response: AxiosResponse, originatingPage: Page): Response;
+    handlePrefetch(): Promise<void>;
+    handle(): Promise<void>;
+    process(): Promise<boolean | void>;
+    mergeParams(params: ActiveVisit): void;
+    protected handleNonInertiaResponse(): Promise<boolean | void>;
+    protected isInertiaResponse(): boolean;
+    protected hasStatus(status: number): boolean;
+    protected getHeader(header: string): string;
+    protected hasHeader(header: string): boolean;
+    protected isLocationVisit(): boolean;
+    /**
+     * @link https://inertiajs.com/redirects#external-redirects
+     */
+    protected locationVisit(url: URL): boolean | void;
+    protected setFrame(): Promise<void>;
+    protected getDataFromResponse(response: any): any;
+    protected shouldSetFrame(pageResponse: Frame): boolean;
+    protected pageUrl(pageResponse: Frame): string;
+    protected mergeProps(pageResponse: Frame): void;
+    protected setRememberedState(pageResponse: Frame): Promise<void>;
+    protected getScopedErrors(errors: Errors & ErrorBag): Errors;
+}

package/types/router.d.ts

@@ -1,61 +1,36 @@
-import { AxiosResponse } from 'axios';
-import { ActiveVisit, GlobalEvent, GlobalEventNames, GlobalEventResult, LocationVisit, Page, PageHandler, PageResolver, PreserveStateOption, RequestPayload, VisitId, VisitOptions } from './types';
+import { RequestStream } from './requestStream';
+import { ActiveVisit, GlobalEvent, GlobalEventNames, GlobalEventResult, InFlightPrefetch, Page, PendingVisit, PendingVisitOptions, PollOptions, PrefetchedResponse, PrefetchOptions, ReloadOptions, RequestPayload, PageResolver, RouterInitParams, Visit, VisitCallbacks, VisitHelperOptions, VisitOptions } from './types';
 export declare class Router {
-    protected page: Page;
-    protected resolveComponent: PageResolver;
-    protected swapComponent: PageHandler;
-    protected navigationType?: string;
-    protected activeVisit?: ActiveVisit;
-    protected visitId: VisitId;
-    init({ initialPage, resolveComponent, swapComponent, }: {
-        initialPage: Page;
-        resolveComponent: PageResolver;
-        swapComponent: PageHandler;
-    }): void;
-    protected setNavigationType(): void;
-    protected clearRememberedStateOnReload(): void;
-    protected handleInitialPageVisit(page: Page): void;
-    protected setupEventListeners(): void;
-    protected scrollRegions(): NodeListOf<Element>;
-    protected handleScrollEvent(event: Event): void;
-    protected saveScrollPositions(): void;
-    protected resetScrollPositions(): void;
-    protected restoreScrollPositions(): void;
-    protected isBackForwardVisit(): boolean;
-    protected handleBackForwardVisit(page: Page): void;
-    protected locationVisit(url: URL, preserveScroll: LocationVisit['preserveScroll']): boolean | void;
-    protected isLocationVisit(): boolean;
-    protected handleLocationVisit(page: Page): void;
-    protected isLocationVisitResponse(response: AxiosResponse): boolean;
-    protected isInertiaResponse(response: AxiosResponse): boolean;
-    protected createVisitId(): VisitId;
-    protected cancelVisit(activeVisit: ActiveVisit, { cancelled, interrupted }: {
-        cancelled?: boolean;
-        interrupted?: boolean;
-    }): void;
-    protected finishVisit(visit: ActiveVisit): void;
-    protected resolvePreserveOption(value: PreserveStateOption, page: Page): boolean | string;
-    cancel(): void;
-    visit(href: string | URL, { method, data, replace, preserveScroll, preserveState, preserveURL, only, headers, errorBag, forceFormData, target, component, hint, onCancelToken, onBefore, onStart, onProgress, onFinish, onCancel, onSuccess, onError, transformProps, queryStringArrayFormat, }?: VisitOptions): void;
-    protected setPage(page: Page, { visitId, replace, preserveURL, preserveScroll, preserveState, target, }?: {
-        visitId?: VisitId;
-        replace?: boolean;
-        preserveURL?: boolean;
-        preserveScroll?: PreserveStateOption;
-        preserveState?: PreserveStateOption;
-        target?: string | null;
-    }): Promise<Page>;
-    protected pushState(page: Page): void;
-    protected replaceState(page: Page): void;
-    protected handlePopstateEvent(event: PopStateEvent): void;
-    get(url: URL | string, data?: RequestPayload, options?: Exclude<VisitOptions, 'method' | 'data'>): void;
-    reload(options?: Exclude<VisitOptions, 'preserveScroll' | 'preserveState'>): void;
-    replace(url: URL | string, options?: Exclude<VisitOptions, 'replace'>): void;
-    post(url: URL | string, data?: RequestPayload, options?: Exclude<VisitOptions, 'method' | 'data'>): void;
-    put(url: URL | string, data?: RequestPayload, options?: Exclude<VisitOptions, 'method' | 'data'>): void;
-    patch(url: URL | string, data?: RequestPayload, options?: Exclude<VisitOptions, 'method' | 'data'>): void;
-    delete(url: URL | string, options?: Exclude<VisitOptions, 'method'>): void;
+    static resolveComponent: PageResolver;
+    protected frame: string;
+    protected syncRequestStream: RequestStream;
+    protected asyncRequestStream: RequestStream;
+    constructor({ frame, initialState, swapComponent }: RouterInitParams);
+    get(url: URL | string, data?: RequestPayload, options?: VisitHelperOptions): void;
+    post(url: URL | string, data?: RequestPayload, options?: VisitHelperOptions): void;
+    put(url: URL | string, data?: RequestPayload, options?: VisitHelperOptions): void;
+    patch(url: URL | string, data?: RequestPayload, options?: VisitHelperOptions): void;
+    delete(url: URL | string, options?: Omit<VisitOptions, 'method'>): void;
+    reload(options?: ReloadOptions): void;
     remember(data: unknown, key?: string): void;
     restore(key?: string): unknown;
     on<TEventName extends GlobalEventNames>(type: TEventName, callback: (event: GlobalEvent<TEventName>) => GlobalEventResult<TEventName>): VoidFunction;
+    cancel(): void;
+    cancelAll(): void;
+    poll(interval: number, requestOptions?: ReloadOptions, options?: PollOptions): {
+        stop: VoidFunction;
+        start: VoidFunction;
+    };
+    visit(href: string | URL, options?: VisitOptions): void;
+    getCached(href: string | URL, options?: VisitOptions): InFlightPrefetch | PrefetchedResponse | null;
+    flush(href: string | URL, options?: VisitOptions): void;
+    flushAll(): void;
+    getPrefetching(href: string | URL, options?: VisitOptions): InFlightPrefetch | PrefetchedResponse | null;
+    prefetch(href: string | URL, options: Partial<Visit & VisitCallbacks> | undefined, { cacheFor }: PrefetchOptions): void;
+    clearHistory(): void;
+    decryptHistory(): Promise<Page>;
+    protected getPrefetchParams(href: string | URL, options: VisitOptions): ActiveVisit;
+    protected getPendingVisit(href: string | URL, options: VisitOptions, pendingVisitOptions?: Partial<PendingVisitOptions>): PendingVisit;
+    protected getVisitEvents(options: VisitOptions): VisitCallbacks;
+    protected loadDeferredProps(): void;
 }

package/types/scroll.d.ts

@@ -0,0 +1,8 @@
+import { Page } from './types';
+export declare class Scroll {
+    static save(page: Page): void;
+    protected static regions(): NodeListOf<Element>;
+    static reset(page: Page): void;
+    static restore(page: Page): void;
+    static onScroll(event: Event): void;
+}

package/types/sessionStorage.d.ts

@@ -0,0 +1,10 @@
+export declare class SessionStorage {
+    static locationVisitKey: string;
+    static set(key: string, value: any): void;
+    static get(key: string): any;
+    static merge(key: string, value: any): void;
+    static remove(key: string): void;
+    static removeNested(key: string, nestedKey: string): void;
+    static exists(key: string): boolean;
+    static clear(): void;
+}

package/types/shouldIntercept.d.ts

@@ -1 +1 @@
-export default function shouldIntercept(event: KeyboardEvent): boolean;
+export default function shouldIntercept(event: MouseEvent | KeyboardEvent): boolean;

package/types/time.d.ts

@@ -0,0 +1 @@
+export declare const timeToMs: (time: string | number) => number;

package/types/types.d.ts

@@ -1,4 +1,5 @@
 import { AxiosProgressEvent, AxiosResponse } from 'axios';
+import { Response } from './response';
 declare module 'axios' {
     interface AxiosProgressEvent {
         percentage: number | undefined;
@@ -14,29 +15,38 @@ export type RequestPayload = Record<string, FormDataConvertible> | FormData;
 export interface PageProps {
     [key: string]: unknown;
 }
-export interface Page<SharedProps extends PageProps = PageProps> {
+export interface Frame<SharedProps extends PageProps = PageProps> {
     component: string;
     props: PageProps & SharedProps & {
         errors: Errors & ErrorBag;
+        deferred?: Record<string, VisitOptions['only']>;
     };
     url: string;
-    target?: string | null;
+    deferredProps?: Record<string, VisitOptions['only']>;
+    mergeProps?: string[];
+    /** @internal */
+    rememberedState?: Record<string, unknown>;
+}
+export interface Page {
+    frames: {
+        [name: string]: Frame;
+    };
     version: string | null;
+    clearHistory?: boolean;
+    encryptHistory?: boolean;
     /** @internal */
     scrollRegions: Array<{
         top: number;
         left: number;
     }>;
-    /** @internal */
-    rememberedState: Record<string, unknown>;
 }
 export type PageResolver = (name: string) => Component;
-export type PageHandler = ({ component, page, preserveState, }: {
+export type FrameHandler = ({ component, frame, preserveState, }: {
     component: Component;
-    page: Page;
+    frame: Frame;
     preserveState: PreserveStateOption;
 }) => Promise<unknown>;
-export type PreserveStateOption = boolean | string | ((page: Page) => boolean);
+export type PreserveStateOption = boolean | 'errors' | ((page: Page) => boolean);
 export type Progress = AxiosProgressEvent;
 export type LocationVisit = {
     preserveScroll: boolean;
@@ -45,18 +55,21 @@ export type Visit = {
     method: Method;
     data: RequestPayload;
     replace: boolean;
-    preserveURL: boolean;
     preserveScroll: PreserveStateOption;
     preserveState: PreserveStateOption;
-    transformProps: (props: PageProps) => void;
     only: Array<string>;
+    except: Array<string>;
     headers: Record<string, string>;
     errorBag: string | null;
     forceFormData: boolean;
-    target: string | null;
-    hint: string | null;
-    component: string | null;
     queryStringArrayFormat: 'indices' | 'brackets';
+    async: boolean;
+    showProgress: boolean;
+    prefetch: boolean;
+    fresh: boolean;
+    reset: string[];
+    preserveUrl: boolean;
+    frame: string;
 };
 export type GlobalEventsMap = {
     before: {
@@ -127,7 +140,24 @@ export type GlobalEventsMap = {
         };
         result: boolean | void;
     };
+    prefetched: {
+        parameters: [AxiosResponse, ActiveVisit];
+        details: {
+            response: AxiosResponse;
+            fetchedAt: number;
+            visit: ActiveVisit;
+        };
+        result: void;
+    };
+    prefetching: {
+        parameters: [ActiveVisit];
+        details: {
+            visit: ActiveVisit;
+        };
+        result: void;
+    };
 };
+export type PageEvent = 'newComponent' | 'firstLoad';
 export type GlobalEventNames = keyof GlobalEventsMap;
 export type GlobalEvent<TEventName extends GlobalEventNames> = CustomEvent<GlobalEventDetails<TEventName>>;
 export type GlobalEventParameters<TEventName extends GlobalEventNames> = GlobalEventsMap[TEventName]['parameters'];
@@ -135,7 +165,7 @@ export type GlobalEventResult<TEventName extends GlobalEventNames> = GlobalEvent
 export type GlobalEventDetails<TEventName extends GlobalEventNames> = GlobalEventsMap[TEventName]['details'];
 export type GlobalEventTrigger<TEventName extends GlobalEventNames> = (...params: GlobalEventParameters<TEventName>) => GlobalEventResult<TEventName>;
 export type GlobalEventCallback<TEventName extends GlobalEventNames> = (...params: GlobalEventParameters<TEventName>) => GlobalEventResult<TEventName>;
-export type VisitOptions = Partial<Visit & {
+export type VisitCallbacks = {
     onCancelToken: {
         ({ cancel }: {
             cancel: VoidFunction;
@@ -148,16 +178,33 @@ export type VisitOptions = Partial<Visit & {
     onCancel: GlobalEventCallback<'cancel'>;
     onSuccess: GlobalEventCallback<'success'>;
     onError: GlobalEventCallback<'error'>;
-}>;
-export type PendingVisit = Visit & {
+    onPrefetched: GlobalEventCallback<'prefetched'>;
+    onPrefetching: GlobalEventCallback<'prefetching'>;
+};
+export type VisitOptions = Partial<Visit & VisitCallbacks>;
+export type ReloadOptions = Omit<VisitOptions, 'preserveScroll' | 'preserveState'>;
+export type PollOptions = {
+    keepAlive?: boolean;
+    autoStart?: boolean;
+};
+export type VisitHelperOptions = Omit<VisitOptions, 'method' | 'data'>;
+export type RouterInitParams = {
+    frame: string;
+    initialState: Frame & {
+        version: string | null;
+    };
+    swapComponent: FrameHandler;
+};
+export type PendingVisitOptions = {
     url: URL;
     completed: boolean;
     cancelled: boolean;
     interrupted: boolean;
-    noProgress: boolean;
 };
-export type ActiveVisit = PendingVisit & Required<VisitOptions> & {
-    cancelToken: AbortController;
+export type PendingVisit = Visit & PendingVisitOptions;
+export type ActiveVisit = PendingVisit & Required<VisitOptions>;
+export type InternalActiveVisit = ActiveVisit & {
+    onPrefetchResponse?: (response: Response) => void;
 };
 export type VisitId = unknown;
 export type Component = unknown;
@@ -165,6 +212,33 @@ export type InertiaAppResponse = Promise<{
     head: string[];
     body: string;
 } | void>;
+export type LinkPrefetchOption = 'mount' | 'hover' | 'click';
+export type CacheForOption = number | string;
+export type PrefetchOptions = {
+    cacheFor: CacheForOption | CacheForOption[];
+};
+type PrefetchObject = {
+    params: ActiveVisit;
+    response: Promise<Response>;
+};
+export type InFlightPrefetch = PrefetchObject & {
+    staleTimestamp: null;
+    inFlight: true;
+};
+export type PrefetchCancellationToken = {
+    isCancelled: boolean;
+    cancel: () => void;
+};
+export type PrefetchedResponse = PrefetchObject & {
+    staleTimestamp: number;
+    timestamp: number;
+    singleUse: boolean;
+    inFlight: false;
+};
+export type PrefetchRemovalTimer = {
+    params: ActiveVisit;
+    timer: number;
+};
 declare global {
     interface DocumentEventMap {
         'inertia:before': GlobalEvent<'before'>;
@@ -178,3 +252,4 @@ declare global {
         'inertia:navigate': GlobalEvent<'navigate'>;
     }
 }
+export {};

package/types/url.d.ts

@@ -1,4 +1,7 @@
-import { FormDataConvertible, Method } from './types';
+import { FormDataConvertible, Method, RequestPayload, VisitOptions } from './types';
 export declare function hrefToUrl(href: string | URL): URL;
+export declare const transformUrlAndData: (href: string | URL, data: RequestPayload, method: Method, forceFormData: VisitOptions['forceFormData'], queryStringArrayFormat: VisitOptions['queryStringArrayFormat']) => [URL, RequestPayload];
 export declare function mergeDataIntoQueryString(method: Method, href: URL | string, data: Record<string, FormDataConvertible>, qsArrayFormat?: 'indices' | 'brackets'): [string, Record<string, FormDataConvertible>];
 export declare function urlWithoutHash(url: URL | Location): URL;
+export declare const setHashIfSameUrl: (originUrl: URL | Location, destinationUrl: URL | Location) => void;
+export declare const isSameUrlWithoutHash: (url1: URL | Location, url2: URL | Location) => boolean;