inertiax-core 10.2.2 → 11.0.0

package/types/page.d.ts

@@ -1,9 +1,10 @@
-import { Component, Page, PageEvent, PageHandler, PageResolver, PreserveStateOption, RouterInitParams, VisitOptions } from './types';
-export declare class CurrentPage {
-    protected name: string;
+import { Component, FlashData, Page, PageEvent, PageHandler, PageResolver, RouterInitParams, Visit } from './types';
+declare class CurrentFramePage {
+    protected readonly frameId: string;
     protected page: Page;
-    protected swapComponent: PageHandler;
+    protected swapComponent: PageHandler<any>;
     protected resolveComponent: PageResolver;
+    protected onFlashCallback?: (flash: Page['flash']) => void;
     protected componentId: {};
     protected listeners: {
         event: PageEvent;
@@ -11,24 +12,93 @@ export declare class CurrentPage {
     }[];
     protected isFirstPageLoad: boolean;
     protected cleared: boolean;
-    constructor({ name, initialPage, swapComponent, resolveComponent }: RouterInitParams);
-    set(page: Page, { replace, preserveScroll, preserveState, preserveUrl, }?: Partial<Pick<VisitOptions, 'replace' | 'preserveScroll' | 'preserveState' | 'preserveUrl'>>): Promise<void>;
+    protected pendingDeferredProps: Pick<Page, 'deferredProps' | 'url' | 'component'> | null;
+    protected historyQuotaExceeded: boolean;
+    protected optimisticBaseline: Partial<Page['props']>;
+    protected pendingOptimistics: {
+        id: number;
+        callback: (props: Page['props']) => Partial<Page['props']> | void;
+    }[];
+    protected optimisticCounter: number;
+    constructor(frameId: string);
+    init<ComponentType = Component>({ initialPage, swapComponent, resolveComponent, onFlash, }: RouterInitParams<ComponentType>): this;
+    set(page: Page, { replace, updateBrowserUrl, preserveScroll, preserveState, viewTransition, }?: {
+        replace?: boolean;
+        updateBrowserUrl?: boolean;
+        preserveScroll?: boolean;
+        preserveState?: boolean;
+        viewTransition?: Visit['viewTransition'];
+    }): Promise<void>;
     setQuietly(page: Page, { preserveState, }?: {
-        preserveState?: PreserveStateOption;
+        preserveState?: boolean;
     }): Promise<unknown>;
     clear(): void;
     isCleared(): boolean;
     get(): Page;
+    getWithoutFlashData(): Page;
+    hasOnceProps(): boolean;
     merge(data: Partial<Page>): void;
+    setPropsQuietly(props: Page['props']): Promise<unknown>;
+    setFlash(flash: FlashData): void;
     setUrlHash(hash: string): void;
     remember(data: Page['rememberedState']): void;
-    swap({ component, page, preserveState, }: {
+    swap({ component, page, preserveState, viewTransition, }: {
         component: Component;
         page: Page;
-        preserveState: PreserveStateOption;
+        preserveState: boolean;
+        viewTransition: Visit['viewTransition'];
     }): Promise<unknown>;
-    resolve(component: string): Promise<Component>;
+    resolve(component: string, page?: Page): Promise<Component>;
+    nextOptimisticId(): number;
+    setBaseline(key: string, value: unknown): void;
+    updateBaseline(key: string, value: unknown): void;
+    hasBaseline(key: string): boolean;
+    registerOptimistic(id: number, callback: (props: Page['props']) => Partial<Page['props']> | void): void;
+    unregisterOptimistic(id: number): void;
+    replayOptimistics(): Partial<Page['props']>;
+    pendingOptimisticCount(): number;
+    clearOptimisticState(): void;
     isTheSame(page: Page): boolean;
     on(event: PageEvent, callback: VoidFunction): VoidFunction;
     fireEventsFor(event: PageEvent): void;
+    mergeOncePropsIntoResponse(response: Page, { force }?: {
+        force?: boolean;
+    }): void;
+}
+declare class PageStore {
+    protected frames: Map<string, CurrentFramePage>;
+    protected forFrame(frameId?: string): CurrentFramePage;
+    init<ComponentType = Component>(params: RouterInitParams<ComponentType>, frameId?: string): CurrentFramePage;
+    set(page: Page, options?: Parameters<CurrentFramePage['set']>[1], frameId?: string): Promise<void>;
+    setQuietly(page: Page, options?: Parameters<CurrentFramePage['setQuietly']>[1], frameId?: string): Promise<unknown>;
+    clear(frameId?: string): void;
+    isCleared(frameId?: string): boolean;
+    get(frameId?: string): Page;
+    getWithoutFlashData(frameId?: string): Page;
+    hasOnceProps(frameId?: string): boolean;
+    merge(data: Partial<Page>, frameId?: string): void;
+    setPropsQuietly(props: Page['props'], frameId?: string): Promise<unknown>;
+    setFlash(flash: FlashData, frameId?: string): void;
+    setUrlHash(hash: string, frameId?: string): void;
+    remember(data: Page['rememberedState'], frameId?: string): void;
+    swap(args: Parameters<CurrentFramePage['swap']>[0], frameId?: string): Promise<unknown>;
+    resolve(component: string, page?: Page, frameId?: string): Promise<Component>;
+    nextOptimisticId(frameId?: string): number;
+    setBaseline(key: string, value: unknown, frameId?: string): void;
+    updateBaseline(key: string, value: unknown, frameId?: string): void;
+    hasBaseline(key: string, frameId?: string): boolean;
+    registerOptimistic(id: number, callback: (props: Page['props']) => Partial<Page['props']> | void, frameId?: string): void;
+    unregisterOptimistic(id: number, frameId?: string): void;
+    replayOptimistics(frameId?: string): Partial<Page['props']>;
+    pendingOptimisticCount(frameId?: string): number;
+    clearOptimisticState(frameId?: string): void;
+    isTheSame(page: Page, frameId?: string): boolean;
+    on(event: PageEvent, callback: VoidFunction, frameId?: string): VoidFunction;
+    fireEventsFor(event: PageEvent, frameId?: string): void;
+    mergeOncePropsIntoResponse(response: Page, options?: {
+        force?: boolean;
+    }, frameId?: string): void;
+    deleteFrame(frameId: string): void;
 }
+export declare const page: PageStore;
+export {};

package/types/partialReload.d.ts

@@ -0,0 +1,6 @@
+import { ActiveVisit } from './types';
+type VisitFilter = Pick<ActiveVisit, 'only' | 'except'>;
+export declare const isPathOrSubPath: (path: string, candidate: string) => boolean;
+export declare const partialReloadRequestsProp: (visit: VisitFilter, prop: string) => boolean;
+export declare const partialReloadRequestsSomeProps: (visit: VisitFilter, props: string[]) => boolean;
+export {};

package/types/poll.d.ts

@@ -1,13 +1,28 @@
 import { PollOptions } from './types';
+type PollHooks = {
+    onStart: (cancel: VoidFunction) => void;
+    onFinish: VoidFunction;
+};
+export type PollCallback = (hooks: PollHooks) => void;
 export declare class Poll {
-    protected id: number | null;
+    protected intervalId: number | null;
+    protected timeoutId: number | null;
     protected throttle: boolean;
     protected keepAlive: boolean;
-    protected cb: VoidFunction;
+    protected cb: PollCallback;
     protected interval: number;
     protected cbCount: number;
-    constructor(interval: number, cb: VoidFunction, options: PollOptions);
+    protected mode: 'overlap' | 'cancel' | 'rest';
+    protected inFlight: boolean;
+    protected currentCancel: VoidFunction | null;
+    protected stopped: boolean;
+    protected instanceId: number;
+    constructor(interval: number, cb: PollCallback, options: PollOptions);
     stop(): void;
     start(): void;
     isInBackground(hidden: boolean): void;
+    protected scheduleNext(): void;
+    protected tick(): void;
+    protected fire(): void;
 }
+export {};

package/types/polls.d.ts

@@ -1,11 +1,13 @@
-import { Poll } from './poll';
+import { Poll, PollCallback } from './poll';
 import { PollOptions } from './types';
 declare class Polls {
     protected polls: Poll[];
     constructor();
-    add(interval: number, cb: VoidFunction, options: PollOptions): {
+    get count(): number;
+    add(interval: number, cb: PollCallback, options: PollOptions): {
         stop: VoidFunction;
         start: VoidFunction;
+        destroy: VoidFunction;
     };
     clear(): void;
     protected setupVisibilityListener(): void;

package/types/prefetched.d.ts

@@ -1,13 +1,15 @@
 import { Response } from './response';
-import { ActiveVisit, CacheForOption, InFlightPrefetch, InternalActiveVisit, PrefetchedResponse, PrefetchOptions, PrefetchRemovalTimer } from './types';
+import { ActiveVisit, CacheForOption, InFlightPrefetch, InternalActiveVisit, Page, 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>;
+    add(params: ActiveVisit, sendFunc: (params: InternalActiveVisit) => void, { cacheFor, cacheTags }: PrefetchOptions): Promise<void> | Promise<Response>;
     removeAll(): void;
+    removeByTags(tags: string[]): void;
     remove(params: ActiveVisit): void;
+    protected removeFromInFlight(params: ActiveVisit): void;
     protected extractStaleValues(cacheFor: PrefetchOptions['cacheFor']): [number, number];
     protected cacheForToStaleAndExpires(cacheFor: PrefetchOptions['cacheFor']): [CacheForOption, CacheForOption];
     protected clearTimer(params: ActiveVisit): void;
@@ -17,7 +19,10 @@ declare class PrefetchedRequests {
     protected removeSingleUseItems(params: ActiveVisit): void;
     findCached(params: ActiveVisit): PrefetchedResponse | null;
     findInFlight(params: ActiveVisit): InFlightPrefetch | null;
+    protected withoutPurposePrefetchHeader(params: ActiveVisit): ActiveVisit;
     protected paramsAreEqual(params1: ActiveVisit, params2: ActiveVisit): boolean;
+    updateCachedOncePropsFromCurrentPage(frameId?: string): void;
+    protected getShortestOncePropTtl(page: Page): number | null;
 }
 export declare const prefetchedRequests: PrefetchedRequests;
 export {};

package/types/progress-component.d.ts

@@ -2,12 +2,12 @@ import { ProgressSettings } from './types';
 declare const _default: {
     configure: (options: Partial<ProgressSettings>) => void;
     isStarted: () => boolean;
-    done: (force?: boolean | undefined) => void;
+    done: (force?: boolean) => void;
     set: (n: number) => void;
     remove: () => void;
     start: () => void;
     status: null;
-    show: () => HTMLStyleElement | undefined;
+    show: () => void;
     hide: () => void;
 };
 export default _default;

package/types/progress.d.ts

@@ -1,8 +1,16 @@
-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;
-    includeCSS?: boolean | undefined;
-    showSpinner?: boolean | undefined;
-}): void;
+import { ProgressOptions } from './types';
+declare class Progress {
+    hideCount: number;
+    start(): void;
+    reveal(force?: boolean): void;
+    hide(): void;
+    set(status: number): void;
+    finish(): void;
+    reset(): void;
+    remove(): void;
+    isStarted(): boolean;
+    getStatus(): number | null;
+}
+export declare const progress: Progress;
+export default function setupProgress({ delay, color, includeCSS, showSpinner, popover, }?: ProgressOptions): void;
+export {};

package/types/queryString.d.ts

@@ -0,0 +1,13 @@
+import type { QueryStringArrayFormatOption } from './types';
+/**
+ * Returns true if the given URL query string contains indexed array parameters.
+ */
+export declare function hasIndices(url: URL): boolean;
+/**
+ * Parse a query string into a nested object.
+ */
+export declare function parse(query: string): Record<string, unknown>;
+/**
+ * Convert an object to a query string.
+ */
+export declare function stringify(data: Record<string, unknown>, arrayFormat: QueryStringArrayFormatOption): string;

package/types/request.d.ts

@@ -1,15 +1,27 @@
-import { AxiosProgressEvent, AxiosRequestConfig } from 'axios';
 import { RequestParams } from './requestParams';
 import { Response } from './response';
-import { ActiveVisit, Page } from './types';
+import type { Router } from './router';
+import type { ActiveVisit, Page } from './types';
+import { HttpProgressEvent, HttpRequestHeaders } 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;
+    protected optimistic: boolean;
+    protected router?: Router;
+    constructor(params: ActiveVisit, page: Page, { optimistic, router }?: {
+        optimistic?: boolean;
+        router?: Router;
+    });
+    static create(params: ActiveVisit, page: Page, options?: {
+        optimistic?: boolean;
+        router?: Router;
+    }): Request;
+    isPrefetch(): boolean;
+    isOptimistic(): boolean;
+    isPendingOptimistic(): boolean;
     send(): Promise<void | undefined>;
     protected finish(): void;
     protected fireFinishEvents(): void;
@@ -17,6 +29,6 @@ export declare class Request {
         cancelled?: boolean;
         interrupted?: boolean;
     }): void;
-    protected onProgress(progress: AxiosProgressEvent): void;
-    protected getHeaders(): AxiosRequestConfig['headers'];
+    protected onProgress(progress: HttpProgressEvent): void;
+    protected getHeaders(): HttpRequestHeaders;
 }

package/types/requestParams.d.ts

@@ -1,6 +1,5 @@
-import { AxiosRequestConfig } from 'axios';
 import { Response } from './response';
-import { ActiveVisit, InternalActiveVisit, Page, PreserveStateOption, VisitCallbacks } from './types';
+import { ActiveVisit, HttpRequestHeaders, InternalActiveVisit, Page, PreserveStateOption, VisitCallbacks } from './types';
 export declare class RequestParams {
     protected callbacks: {
         name: keyof VisitCallbacks;
@@ -12,6 +11,8 @@ export declare class RequestParams {
     data(): import("./types").RequestPayload | null;
     queryParams(): import("./types").RequestPayload;
     isPartial(): boolean;
+    isPrefetch(): boolean;
+    isDeferredPropsRequest(): boolean;
     onCancelToken(cb: VoidFunction): void;
     markAsFinished(): void;
     markAsCancelled({ cancelled, interrupted }: {
@@ -23,12 +24,13 @@ export declare class RequestParams {
     onStart(): void;
     onPrefetching(): void;
     onPrefetchResponse(response: Response): void;
+    onPrefetchError(error: Error): void;
     all(): InternalActiveVisit;
-    headers(): AxiosRequestConfig['headers'];
+    headers(): HttpRequestHeaders;
     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;
+    static resolvePreserveOption(value: PreserveStateOption, page: Page): boolean;
 }

package/types/requestStream.d.ts

@@ -9,10 +9,14 @@ export declare class RequestStream {
     });
     send(request: Request): void;
     interruptInFlight(): void;
-    cancelInFlight(): void;
-    protected cancel({ cancelled, interrupted }: {
+    cancelInFlight({ prefetch, optimistic }?: {
+        prefetch?: boolean | undefined;
+        optimistic?: boolean | undefined;
+    }): void;
+    protected cancel({ cancelled, interrupted }?: {
         cancelled?: boolean | undefined;
         interrupted?: boolean | undefined;
-    } | undefined, force: boolean): void;
-    protected shouldCancel(force: boolean): boolean;
+    }, force?: boolean): void;
+    protected shouldCancel(): boolean;
+    hasPendingOptimistic(): boolean;
 }

package/types/resetFormFields.d.ts

@@ -0,0 +1,2 @@
+export declare const FormComponentResetSymbol: unique symbol;
+export declare function resetFormFields(formElement: HTMLFormElement, defaults: FormData, fieldNames?: string[]): void;

package/types/response.d.ts

@@ -1,21 +1,28 @@
-import { AxiosResponse } from 'axios';
 import { RequestParams } from './requestParams';
-import { ActiveVisit, ErrorBag, Errors, Page } from './types';
+import type { Router } from './router';
+import { ActiveVisit, ErrorBag, Errors, HttpResponse, Page, PageProps } from './types';
 export declare class Response {
     protected requestParams: RequestParams;
-    protected response: AxiosResponse;
+    protected response: HttpResponse;
     protected originatingPage: Page;
-    constructor(requestParams: RequestParams, response: AxiosResponse, originatingPage: Page);
-    static create(params: RequestParams, response: AxiosResponse, originatingPage: Page): Response;
+    protected router?: Router | undefined;
+    protected wasPrefetched: boolean;
+    protected processed: boolean;
+    constructor(requestParams: RequestParams, response: HttpResponse, originatingPage: Page, router?: Router | undefined);
+    static create(params: RequestParams, response: HttpResponse, originatingPage: Page, router?: Router): Response;
+    isProcessed(): boolean;
     handlePrefetch(): Promise<void>;
     handle(): Promise<void>;
     process(): Promise<boolean | void>;
     mergeParams(params: ActiveVisit): void;
+    getPageResponse(): Page;
     protected handleNonInertiaResponse(): Promise<boolean | void>;
     protected isInertiaResponse(): boolean;
+    protected isHttpException(): boolean;
     protected hasStatus(status: number): boolean;
     protected getHeader(header: string): string;
     protected hasHeader(header: string): boolean;
+    protected isInertiaRedirect(): boolean;
     protected isLocationVisit(): boolean;
     /**
      * @link https://inertiajs.com/redirects#external-redirects
@@ -25,7 +32,23 @@ export declare class Response {
     protected getDataFromResponse(response: any): any;
     protected shouldSetPage(pageResponse: Page): boolean;
     protected pageUrl(pageResponse: Page): string;
+    protected preserveOptimisticProps(pageResponse: Page): void;
+    protected preserveEqualProps(pageResponse: Page): void;
     protected mergeProps(pageResponse: Page): void;
+    protected mergeRescuedProps(pageResponse: Page): string[];
+    /**
+     * By default, the Laravel adapter shares validation errors via Inertia::always(),
+     * so responses always include errors, even when empty. Components like
+     * InfiniteScroll and WhenVisible, as well as loading deferred props,
+     * perform async requests that should practically never reset errors.
+     */
+    protected shouldPreserveErrors(pageResponse: Page): boolean;
+    protected isObject(item: any): boolean;
+    protected deepMergeObjects(target: PageProps, source: PageProps): PageProps;
+    protected mergeOrMatchItems(existingItems: any[], newItems: any[], matchProp: string, matchPropsOn: string[], shouldAppend?: boolean): any[];
+    protected appendWithMatching(existingItems: any[], newItems: any[], newItemsMap: Map<any, any>, uniqueProperty: string): any[];
+    protected prependWithMatching(existingItems: any[], newItems: any[], newItemsMap: Map<any, any>, uniqueProperty: string): any[];
+    protected hasUniqueProperty(item: any, property: string): boolean;
     protected setRememberedState(pageResponse: Page): Promise<void>;
     protected getScopedErrors(errors: Errors & ErrorBag): Errors;
 }

package/types/router.d.ts

@@ -1,50 +1,74 @@
-import { PreserveStateOption } from '.';
-import { CurrentPage } from './page';
+import Queue from './queue';
 import { RequestStream } from './requestStream';
-import { ActiveVisit, ClientSideVisitOptions, GlobalEvent, GlobalEventNames, GlobalEventResult, InFlightPrefetch, Frames, PendingVisit, PendingVisitOptions, PollOptions, PrefetchedResponse, PrefetchOptions, ReloadOptions, RequestPayload, RouterInitParams, Visit, VisitCallbacks, VisitHelperOptions, VisitOptions } from './types';
+import { ActiveVisit, ClientSideVisitOptions, Component, FlashData, GlobalEvent, GlobalEventNames, GlobalEventResult, InFlightPrefetch, OptimisticCallback, Page, PageFlashData, PendingVisit, PollOptions, PrefetchedResponse, PrefetchOptions, ReloadOptions, RequestPayload, RouterInitParams, UrlMethodPair, VisitCallbacks, VisitHelperOptions, VisitOptions } from './types';
 export declare class Router {
-    name: string;
-    currentPage: CurrentPage;
+    readonly frameId: string;
     protected syncRequestStream: RequestStream;
     protected asyncRequestStream: RequestStream;
-    constructor({ name, initialPage, resolveComponent, swapComponent }: RouterInitParams);
-    static asFrames(): Frames;
-    static for(name: string): Router;
-    static setQuietly(frames: Frames, { preserveState, }?: {
-        preserveState?: PreserveStateOption;
-    }): Promise<unknown[]>;
-    static set(frames: Frames, { replace, preserveScroll, preserveState, }?: Partial<Pick<VisitOptions, 'replace' | 'preserveScroll' | 'preserveState'>>): Promise<void[]>;
-    destroy(): void;
-    get<T extends RequestPayload = RequestPayload>(url: URL | string, data?: T, options?: VisitHelperOptions<T>): void;
-    post<T extends RequestPayload = RequestPayload>(url: URL | string, data?: T, options?: VisitHelperOptions<T>): void;
-    put<T extends RequestPayload = RequestPayload>(url: URL | string, data?: T, options?: VisitHelperOptions<T>): void;
-    patch<T extends RequestPayload = RequestPayload>(url: URL | string, data?: T, options?: VisitHelperOptions<T>): void;
-    delete<T extends RequestPayload = RequestPayload>(url: URL | string, options?: Omit<VisitOptions<T>, 'method'>): void;
+    protected clientVisitQueue: Queue<Promise<void>>;
+    protected pendingOptimisticCallback: OptimisticCallback | undefined;
+    protected removePopstateHandler?: VoidFunction;
+    protected removePageshowHandler?: VoidFunction;
+    constructor(frameId?: string);
+    init<ComponentType = Component>({ initialPage, resolveComponent, swapComponent, onFlash, }: RouterInitParams<ComponentType>): void;
+    protected handleHistoryPopstate(state: any): void;
+    optimistic<TProps>(callback: OptimisticCallback<TProps>): this;
+    get<T extends RequestPayload = RequestPayload>(url: URL | string | UrlMethodPair, data?: T, options?: VisitHelperOptions<T>): void;
+    post<T extends RequestPayload = RequestPayload>(url: URL | string | UrlMethodPair, data?: T, options?: VisitHelperOptions<T>): void;
+    put<T extends RequestPayload = RequestPayload>(url: URL | string | UrlMethodPair, data?: T, options?: VisitHelperOptions<T>): void;
+    patch<T extends RequestPayload = RequestPayload>(url: URL | string | UrlMethodPair, data?: T, options?: VisitHelperOptions<T>): void;
+    delete<T extends RequestPayload = RequestPayload>(url: URL | string | UrlMethodPair, options?: Omit<VisitOptions<T>, 'method'>): void;
     reload<T extends RequestPayload = RequestPayload>(options?: ReloadOptions<T>): void;
+    protected doReload<T extends RequestPayload = RequestPayload>(options?: ReloadOptions<T> & {
+        deferredProps?: boolean;
+    }): void;
     remember(data: unknown, key?: string): void;
-    restore(key?: string): unknown;
+    restore<T = unknown>(key?: string): T | undefined;
     on<TEventName extends GlobalEventNames>(type: TEventName, callback: (event: GlobalEvent<TEventName>) => GlobalEventResult<TEventName>): VoidFunction;
-    cancel(): void;
-    cancelAll(): void;
-    poll(interval: number, requestOptions?: ReloadOptions, options?: PollOptions): {
+    once<TEventName extends GlobalEventNames>(type: TEventName, callback: (event: GlobalEvent<TEventName>) => GlobalEventResult<TEventName>): VoidFunction;
+    hasPendingOptimistic(): boolean;
+    get activePolls(): number;
+    cancelAll({ async, prefetch, sync }?: {
+        async?: boolean | undefined;
+        prefetch?: boolean | undefined;
+        sync?: boolean | undefined;
+    }): void;
+    /**
+     * Clean up all resources held by this router instance. Call this when the
+     * frame that owns this router is unmounted. Safe to call multiple times.
+     */
+    destroy(): void;
+    poll(interval: number, requestOptions?: ReloadOptions | (() => ReloadOptions), options?: PollOptions): {
         stop: VoidFunction;
         start: VoidFunction;
+        destroy: VoidFunction;
     };
-    visit<T extends RequestPayload = RequestPayload>(href: string | URL, options?: VisitOptions<T>): void;
-    getCached(href: string | URL, options?: VisitOptions): InFlightPrefetch | PrefetchedResponse | null;
-    flush(href: string | URL, options?: VisitOptions): void;
+    visit<T extends RequestPayload = RequestPayload>(href: string | URL | UrlMethodPair, options?: VisitOptions<T>): void;
+    getCached(href: string | URL | UrlMethodPair, options?: VisitOptions): InFlightPrefetch | PrefetchedResponse | null;
+    flush(href: string | URL | UrlMethodPair, options?: VisitOptions): void;
     flushAll(): void;
-    getPrefetching(href: string | URL, options?: VisitOptions): InFlightPrefetch | PrefetchedResponse | null;
-    prefetch(href: string | URL, options: Partial<Visit<RequestPayload> & VisitCallbacks> | undefined, { cacheFor }: PrefetchOptions): void;
+    flushByCacheTags(tags: string | string[]): void;
+    getPrefetching(href: string | URL | UrlMethodPair, options?: VisitOptions): InFlightPrefetch | PrefetchedResponse | null;
+    prefetch(href: string | URL | UrlMethodPair, options?: VisitOptions, prefetchOptions?: Partial<PrefetchOptions>): void;
     clearHistory(): void;
-    static decryptHistory(): Promise<Frames>;
-    replace(params: ClientSideVisitOptions): void;
-    push(params: ClientSideVisitOptions): void;
-    protected clientVisit(params: ClientSideVisitOptions, { replace }?: {
+    decryptHistory(): Promise<Page>;
+    resolveComponent(component: string, page?: Page): Promise<Component>;
+    replace<TProps = Page['props']>(params: ClientSideVisitOptions<TProps>): void;
+    replaceProp<TProps = Page['props']>(name: string, value: unknown | ((oldValue: unknown, props: TProps) => unknown), options?: Pick<ClientSideVisitOptions, 'onError' | 'onFinish' | 'onSuccess'>): void;
+    appendToProp<TProps = Page['props']>(name: string, value: unknown | unknown[] | ((oldValue: unknown, props: TProps) => unknown | unknown[]), options?: Pick<ClientSideVisitOptions, 'onError' | 'onFinish' | 'onSuccess'>): void;
+    prependToProp<TProps = Page['props']>(name: string, value: unknown | unknown[] | ((oldValue: unknown, props: TProps) => unknown | unknown[]), options?: Pick<ClientSideVisitOptions, 'onError' | 'onFinish' | 'onSuccess'>): void;
+    push<TProps = Page['props']>(params: ClientSideVisitOptions<TProps>): void;
+    flash<TFlash extends PageFlashData = PageFlashData>(keyOrData: string | ((flash: FlashData) => TFlash) | TFlash, value?: unknown): void;
+    protected clientVisit<TProps = Page['props']>(params: ClientSideVisitOptions<TProps>, { replace }?: {
         replace?: boolean;
     }): void;
-    protected getPrefetchParams(href: string | URL, options: VisitOptions): ActiveVisit;
-    protected getPendingVisit(href: string | URL, options: VisitOptions, pendingVisitOptions?: Partial<PendingVisitOptions>): PendingVisit;
+    protected performClientVisit<TProps = Page['props']>(params: ClientSideVisitOptions<TProps>, { replace }?: {
+        replace?: boolean;
+    }): Promise<void>;
+    protected performInstantSwap(visit: PendingVisit): Promise<void>;
+    protected getPrefetchParams(href: string | URL | UrlMethodPair, options: VisitOptions): ActiveVisit;
+    protected getPendingVisit(href: string | URL | UrlMethodPair, options: VisitOptions): PendingVisit;
     protected getVisitEvents(options: VisitOptions): VisitCallbacks;
-    protected loadDeferredProps(): void;
+    protected applyOptimisticUpdate(optimistic: OptimisticCallback, events: VisitCallbacks): void;
+    protected loadDeferredProps(deferred: Page['deferredProps']): void;
 }

package/types/scroll.d.ts

@@ -1,10 +1,14 @@
 import { ScrollRegion } from './types';
 export declare class Scroll {
-    static save(): void;
+    static save(frameId?: string): void;
+    static getScrollRegions(): ScrollRegion[];
     protected static regions(): NodeListOf<Element>;
-    static reset(frame: string): void;
-    static restore(scrollRegions: ScrollRegion[]): void;
-    static restoreDocument(): void;
+    static scrollToTop(): void;
+    static reset(): void;
+    static scrollToAnchor(): void;
+    static restore(scrollRegions: ScrollRegion[], frameId?: string): void;
+    static restoreScrollRegions(scrollRegions: ScrollRegion[]): void;
+    static restoreDocument(frameId?: string): void;
     static onScroll(event: Event): void;
-    static onWindowScroll(): void;
+    static onWindowScroll(frameId?: string): void;
 }

package/types/server.d.ts

@@ -2,8 +2,10 @@ import { InertiaAppResponse, Page } from './types';
 type AppCallback = (page: Page) => InertiaAppResponse;
 type ServerOptions = {
     port?: number;
+    host?: string;
     cluster?: boolean;
+    formatErrors?: boolean;
 };
 type Port = number;
-declare const _default: (render: AppCallback, options?: Port | ServerOptions) => void;
+declare const _default: (render: AppCallback, options?: Port | ServerOptions) => AppCallback;
 export default _default;

package/types/ssrErrors.d.ts

@@ -0,0 +1,29 @@
+/**
+ * SSR Error Classification
+ *
+ * This module detects common SSR errors and provides helpful hints
+ * to developers on how to fix them. The most common issue is using
+ * browser-specific APIs (like window, document) that don't exist
+ * in the Node.js server environment.
+ */
+export type SSRErrorType = 'browser-api' | 'component-resolution' | 'render' | 'unknown';
+type SourceMapResolver = (file: string, line: number, column: number) => {
+    file: string;
+    line: number;
+    column: number;
+} | null;
+export declare function setSourceMapResolver(resolver: SourceMapResolver | null): void;
+export interface ClassifiedSSRError {
+    error: string;
+    type: SSRErrorType;
+    component?: string;
+    url?: string;
+    browserApi?: string;
+    hint: string;
+    stack?: string;
+    sourceLocation?: string;
+    timestamp: string;
+}
+export declare function classifySSRError(error: Error, component?: string, url?: string): ClassifiedSSRError;
+export declare function formatConsoleError(classified: ClassifiedSSRError, root?: string, formatErrors?: boolean, suppressedWarnings?: string[]): string;
+export {};

package/types/ssrUtils.d.ts

@@ -0,0 +1,2 @@
+import type { Page } from './types';
+export declare function buildSSRBody(id: string, page: Page, html: string): string;

package/types/time.d.ts

@@ -1 +1,2 @@
-export declare const timeToMs: (time: string | number) => number;
+import { CacheForOption } from './types';
+export declare const timeToMs: (time: CacheForOption) => number;