@hotwired/turbo 7.2.4 → 7.3.0

package/dist/types/core/bardo.d.ts

@@ -6,7 +6,7 @@ export interface BardoDelegate {
 export declare class Bardo {
     readonly permanentElementMap: PermanentElementMap;
     readonly delegate: BardoDelegate;
-    static preservingPermanentElements(delegate: BardoDelegate, permanentElementMap: PermanentElementMap, callback: () => void): void;
+    static preservingPermanentElements(delegate: BardoDelegate, permanentElementMap: PermanentElementMap, callback: () => void): Promise<void>;
     constructor(delegate: BardoDelegate, permanentElementMap: PermanentElementMap);
     enter(): void;
     leave(): void;

package/dist/types/core/drive/form_submission.d.ts

@@ -1,4 +1,4 @@
-import { FetchRequest, FetchMethod, FetchRequestHeaders } from "../../http/fetch_request";
+import { FetchRequest, FetchMethod } from "../../http/fetch_request";
 import { FetchResponse } from "../../http/fetch_response";
 export interface FormSubmissionDelegate {
     formSubmissionStarted(formSubmission: FormSubmission): void;
@@ -7,7 +7,7 @@ export interface FormSubmissionDelegate {
     formSubmissionErrored(formSubmission: FormSubmission, error: Error): void;
     formSubmissionFinished(formSubmission: FormSubmission): void;
 }
-export declare type FormSubmissionResult = {
+export type FormSubmissionResult = {
     success: boolean;
     fetchResponse: FetchResponse;
 } | {
@@ -27,10 +27,10 @@ declare enum FormEnctype {
     multipart = "multipart/form-data",
     plain = "text/plain"
 }
-export declare type TurboSubmitStartEvent = CustomEvent<{
+export type TurboSubmitStartEvent = CustomEvent<{
     formSubmission: FormSubmission;
 }>;
-export declare type TurboSubmitEndEvent = CustomEvent<{
+export type TurboSubmitEndEvent = CustomEvent<{
     formSubmission: FormSubmission;
 } & {
     [K in keyof FormSubmissionResult]?: FormSubmissionResult[K];
@@ -45,24 +45,28 @@ export declare class FormSubmission {
     readonly mustRedirect: boolean;
     state: FormSubmissionState;
     result?: FormSubmissionResult;
+    originalSubmitText?: string;
     static confirmMethod(message: string, _element: HTMLFormElement, _submitter: HTMLElement | undefined): Promise<boolean>;
     constructor(delegate: FormSubmissionDelegate, formElement: HTMLFormElement, submitter?: HTMLElement, mustRedirect?: boolean);
     get method(): FetchMethod;
     get action(): string;
     get body(): FormData;
     get enctype(): FormEnctype;
-    get isIdempotent(): boolean;
+    get isSafe(): boolean;
     get stringFormData(): [string, string][];
     start(): Promise<void | FetchResponse>;
     stop(): true | undefined;
-    prepareHeadersForRequest(headers: FetchRequestHeaders, request: FetchRequest): void;
+    prepareRequest(request: FetchRequest): void;
     requestStarted(_request: FetchRequest): void;
     requestPreventedHandlingResponse(request: FetchRequest, response: FetchResponse): void;
     requestSucceededWithResponse(request: FetchRequest, response: FetchResponse): void;
     requestFailedWithResponse(request: FetchRequest, response: FetchResponse): void;
     requestErrored(request: FetchRequest, error: Error): void;
     requestFinished(_request: FetchRequest): void;
+    setSubmitsWith(): void;
+    resetSubmitterText(): void;
     requestMustRedirect(request: FetchRequest): boolean;
     requestAcceptsTurboStreamResponse(request: FetchRequest): boolean;
+    get submitsWith(): string | null | undefined;
 }
 export {};

package/dist/types/core/drive/head_snapshot.d.ts

@@ -1,13 +1,13 @@
 import { Snapshot } from "../snapshot";
-declare type ElementDetailMap = {
+type ElementDetailMap = {
     [outerHTML: string]: ElementDetails;
 };
-declare type ElementDetails = {
+type ElementDetails = {
     type?: ElementType;
     tracked: boolean;
     elements: Element[];
 };
-declare type ElementType = "script" | "stylesheet";
+type ElementType = "script" | "stylesheet";
 export declare class HeadSnapshot extends Snapshot<HTMLHeadElement> {
     readonly detailsByOuterHTML: ElementDetailMap;
     get trackedElementSignature(): string;

package/dist/types/core/drive/history.d.ts

@@ -2,11 +2,11 @@ import { Position } from "../types";
 export interface HistoryDelegate {
     historyPoppedToLocationWithRestorationIdentifier(location: URL, restorationIdentifier: string): void;
 }
-declare type HistoryMethod = (this: typeof history, state: any, title: string, url?: string | null | undefined) => void;
-export declare type RestorationData = {
+type HistoryMethod = (this: typeof history, state: any, title: string, url?: string | null | undefined) => void;
+export type RestorationData = {
     scrollPosition?: Position;
 };
-export declare type RestorationDataMap = {
+export type RestorationDataMap = {
     [restorationIdentifier: string]: RestorationData;
 };
 export declare class History {

package/dist/types/core/drive/navigator.d.ts

@@ -3,7 +3,7 @@ import { FetchResponse } from "../../http/fetch_response";
 import { FormSubmission } from "./form_submission";
 import { Locatable } from "../url";
 import { Visit, VisitDelegate, VisitOptions } from "./visit";
-export declare type NavigatorDelegate = VisitDelegate & {
+export type NavigatorDelegate = VisitDelegate & {
     allowsVisitingLocationWithAction(location: URL, action?: Action): boolean;
     visitProposedToLocation(location: URL, options: Partial<VisitOptions>): void;
     notifyApplicationAfterVisitingSamePageLocation(oldURL: URL, newURL: URL): void;
@@ -31,5 +31,5 @@ export declare class Navigator {
     visitScrolledToSamePageLocation(oldURL: URL, newURL: URL): void;
     get location(): URL;
     get restorationIdentifier(): string;
-    getActionForFormSubmission(formSubmission: FormSubmission): Action;
+    getActionForFormSubmission({ submitter, formElement }: FormSubmission): Action;
 }

package/dist/types/core/drive/page_renderer.d.ts

@@ -12,15 +12,17 @@ export declare class PageRenderer extends Renderer<HTMLBodyElement, PageSnapshot
     get newHeadSnapshot(): import("./head_snapshot").HeadSnapshot;
     get newElement(): HTMLBodyElement;
     mergeHead(): Promise<void>;
-    replaceBody(): void;
+    replaceBody(): Promise<void>;
     get trackedElementsAreIdentical(): boolean;
     copyNewHeadStylesheetElements(): Promise<void>;
     copyNewHeadScriptElements(): void;
+    mergeProvisionalElements(): Promise<void>;
+    isCurrentElementInElementList(element: Element, elementList: Element[]): boolean;
     removeCurrentHeadProvisionalElements(): void;
     copyNewHeadProvisionalElements(): void;
     activateNewBody(): void;
     activateNewBodyScriptElements(): void;
-    assignNewBody(): void;
+    assignNewBody(): Promise<void>;
     get newHeadStylesheetElements(): HTMLLinkElement[];
     get newHeadScriptElements(): HTMLScriptElement[];
     get currentHeadProvisionalElements(): Element[];

package/dist/types/core/drive/page_view.d.ts

@@ -4,11 +4,11 @@ import { PageRenderer } from "./page_renderer";
 import { PageSnapshot } from "./page_snapshot";
 import { SnapshotCache } from "./snapshot_cache";
 import { Visit } from "./visit";
-export declare type PageViewRenderOptions = ViewRenderOptions<HTMLBodyElement>;
+export type PageViewRenderOptions = ViewRenderOptions<HTMLBodyElement>;
 export interface PageViewDelegate extends ViewDelegate<HTMLBodyElement, PageSnapshot> {
     viewWillCacheSnapshot(): void;
 }
-declare type PageViewRenderer = PageRenderer | ErrorRenderer;
+type PageViewRenderer = PageRenderer | ErrorRenderer;
 export declare class PageView extends View<HTMLBodyElement, PageSnapshot, PageViewRenderer, PageViewDelegate> {
     readonly snapshotCache: SnapshotCache;
     lastRenderedLocation: URL;

package/dist/types/core/drive/visit.d.ts

@@ -1,5 +1,5 @@
 import { Adapter } from "../native/adapter";
-import { FetchRequest, FetchRequestDelegate, FetchRequestHeaders } from "../../http/fetch_request";
+import { FetchRequest, FetchRequestDelegate } from "../../http/fetch_request";
 import { FetchResponse } from "../../http/fetch_response";
 import { History } from "./history";
 import { Snapshot } from "../snapshot";
@@ -21,7 +21,7 @@ export declare enum TimingMetric {
     requestEnd = "requestEnd",
     visitEnd = "visitEnd"
 }
-export declare type TimingMetrics = Partial<{
+export type TimingMetrics = Partial<{
     [metric in TimingMetric]: any;
 }>;
 export declare enum VisitState {
@@ -31,7 +31,7 @@ export declare enum VisitState {
     failed = "failed",
     completed = "completed"
 }
-export declare type VisitOptions = {
+export type VisitOptions = {
     action: Action;
     historyChanged: boolean;
     referrer?: URL;
@@ -46,7 +46,7 @@ export declare type VisitOptions = {
     frame?: string;
     acceptsStreamResponse: boolean;
 };
-export declare type VisitResponse = {
+export type VisitResponse = {
     statusCode: number;
     redirected: boolean;
     responseHTML?: string;
@@ -104,7 +104,7 @@ export declare class Visit implements FetchRequestDelegate {
     loadCachedSnapshot(): void;
     followRedirect(): void;
     goToSamePageAnchor(): void;
-    prepareHeadersForRequest(headers: FetchRequestHeaders, request: FetchRequest): void;
+    prepareRequest(request: FetchRequest): void;
     requestStarted(): void;
     requestPreventedHandlingResponse(_request: FetchRequest, _response: FetchResponse): void;
     requestSucceededWithResponse(request: FetchRequest, response: FetchResponse): Promise<void>;

package/dist/types/core/errors.d.ts

@@ -0,0 +1,2 @@
+export declare class TurboFrameMissingError extends Error {
+}

package/dist/types/core/frames/frame_controller.d.ts

@@ -1,5 +1,5 @@
 import { FrameElement, FrameElementDelegate, FrameLoadingStyle } from "../../elements/frame_element";
-import { FetchRequest, FetchRequestDelegate, FetchRequestHeaders } from "../../http/fetch_request";
+import { FetchRequest, FetchRequestDelegate } from "../../http/fetch_request";
 import { FetchResponse } from "../../http/fetch_response";
 import { AppearanceObserver, AppearanceObserverDelegate } from "../../observers/appearance_observer";
 import { FormSubmission, FormSubmissionDelegate } from "../drive/form_submission";
@@ -11,16 +11,15 @@ import { FrameView } from "./frame_view";
 import { LinkInterceptor, LinkInterceptorDelegate } from "./link_interceptor";
 import { FormLinkClickObserver, FormLinkClickObserverDelegate } from "../../observers/form_link_click_observer";
 import { VisitOptions } from "../drive/visit";
-import { PageSnapshot } from "../drive/page_snapshot";
-declare type VisitFallback = (location: Response | Locatable, options: Partial<VisitOptions>) => Promise<void>;
-export declare type TurboFrameMissingEvent = CustomEvent<{
+type VisitFallback = (location: Response | Locatable, options: Partial<VisitOptions>) => Promise<void>;
+export type TurboFrameMissingEvent = CustomEvent<{
     response: Response;
     visit: VisitFallback;
 }>;
-export declare class FrameController implements AppearanceObserverDelegate, FetchRequestDelegate, FormSubmitObserverDelegate, FormSubmissionDelegate, FrameElementDelegate, FormLinkClickObserverDelegate, LinkInterceptorDelegate, ViewDelegate<FrameElement, Snapshot<FrameElement>> {
+export declare class FrameController implements AppearanceObserverDelegate<FrameElement>, FetchRequestDelegate, FormSubmitObserverDelegate, FormSubmissionDelegate, FrameElementDelegate, FormLinkClickObserverDelegate, LinkInterceptorDelegate, ViewDelegate<FrameElement, Snapshot<FrameElement>> {
     readonly element: FrameElement;
     readonly view: FrameView;
-    readonly appearanceObserver: AppearanceObserver;
+    readonly appearanceObserver: AppearanceObserver<FrameElement>;
     readonly formLinkClickObserver: FormLinkClickObserver;
     readonly linkInterceptor: LinkInterceptor;
     readonly formSubmitObserver: FormSubmitObserver;
@@ -35,7 +34,6 @@ export declare class FrameController implements AppearanceObserverDelegate, Fetc
     readonly restorationIdentifier: string;
     private previousFrameElement?;
     private currentNavigationElement?;
-    pageSnapshot?: PageSnapshot;
     constructor(element: FrameElement);
     connect(): void;
     disconnect(): void;
@@ -46,14 +44,14 @@ export declare class FrameController implements AppearanceObserverDelegate, Fetc
     loadingStyleChanged(): void;
     private loadSourceURL;
     loadResponse(fetchResponse: FetchResponse): Promise<void>;
-    elementAppearedInViewport(_element: Element): void;
+    elementAppearedInViewport(element: FrameElement): void;
     willSubmitFormLinkToLocation(link: Element): boolean;
     submittedFormLinkToLocation(link: Element, _location: URL, form: HTMLFormElement): void;
     shouldInterceptLinkClick(element: Element, _location: string, _event: MouseEvent): boolean;
     linkClickIntercepted(element: Element, location: string): void;
     willSubmitForm(element: HTMLFormElement, submitter?: HTMLElement): boolean;
     formSubmitted(element: HTMLFormElement, submitter?: HTMLElement): void;
-    prepareHeadersForRequest(headers: FetchRequestHeaders, request: FetchRequest): void;
+    prepareRequest(request: FetchRequest): void;
     requestStarted(_request: FetchRequest): void;
     requestPreventedHandlingResponse(_request: FetchRequest, _response: FetchResponse): void;
     requestSucceededWithResponse(request: FetchRequest, response: FetchResponse): Promise<void>;
@@ -71,11 +69,15 @@ export declare class FrameController implements AppearanceObserverDelegate, Fetc
     viewInvalidated(): void;
     willRenderFrame(currentElement: FrameElement, _newElement: FrameElement): void;
     visitCachedSnapshot: ({ element }: Snapshot) => void;
+    private loadFrameResponse;
     private visit;
     private navigateFrame;
     proposeVisitIfNavigatedWithAction(frame: FrameElement, element: Element, submitter?: HTMLElement): void;
     changeHistory(): void;
+    private handleUnvisitableFrameResponse;
     private willHandleFrameMissingFromResponse;
+    private handleFrameMissingFromResponse;
+    private throwFrameMissingError;
     private visitResponse;
     private findFrameElement;
     extractForeignFrameElement(container: ParentNode): Promise<FrameElement | null>;

package/dist/types/core/frames/frame_view.d.ts

@@ -1,8 +1,8 @@
 import { FrameElement } from "../../elements";
 import { Snapshot } from "../snapshot";
 import { View, ViewRenderOptions } from "../view";
-export declare type FrameViewRenderOptions = ViewRenderOptions<FrameElement>;
+export type FrameViewRenderOptions = ViewRenderOptions<FrameElement>;
 export declare class FrameView extends View<FrameElement> {
-    invalidate(): void;
+    missing(): void;
     get snapshot(): Snapshot<FrameElement>;
 }

package/dist/types/core/index.d.ts

@@ -12,10 +12,11 @@ declare const session: Session;
 declare const cache: Cache;
 declare const navigator: import("./drive/navigator").Navigator;
 export { navigator, session, cache, PageRenderer, PageSnapshot, FrameRenderer };
-export { TurboBeforeCacheEvent, TurboBeforeRenderEvent, TurboBeforeVisitEvent, TurboClickEvent, TurboBeforeFrameRenderEvent, TurboFrameLoadEvent, TurboFrameRenderEvent, TurboLoadEvent, TurboRenderEvent, TurboVisitEvent, } from "./session";
-export { TurboSubmitStartEvent, TurboSubmitEndEvent } from "./drive/form_submission";
-export { TurboFrameMissingEvent } from "./frames/frame_controller";
-export { StreamActions, TurboStreamAction, TurboStreamActions } from "./streams/stream_actions";
+export type { TurboBeforeCacheEvent, TurboBeforeRenderEvent, TurboBeforeVisitEvent, TurboClickEvent, TurboBeforeFrameRenderEvent, TurboFrameLoadEvent, TurboFrameRenderEvent, TurboLoadEvent, TurboRenderEvent, TurboVisitEvent, } from "./session";
+export type { TurboSubmitStartEvent, TurboSubmitEndEvent } from "./drive/form_submission";
+export type { TurboFrameMissingEvent } from "./frames/frame_controller";
+export { StreamActions } from "./streams/stream_actions";
+export type { TurboStreamAction, TurboStreamActions } from "./streams/stream_actions";
 export declare function start(): void;
 export declare function registerAdapter(adapter: Adapter): void;
 export declare function visit(location: Locatable, options?: Partial<VisitOptions>): void;

package/dist/types/core/native/browser_adapter.d.ts

@@ -3,7 +3,7 @@ import { ProgressBar } from "../drive/progress_bar";
 import { Visit, VisitOptions } from "../drive/visit";
 import { FormSubmission } from "../drive/form_submission";
 import { Session } from "../session";
-export declare type ReloadReason = StructuredReason | undefined;
+export type ReloadReason = StructuredReason | undefined;
 interface StructuredReason {
     reason: string;
     context?: {

package/dist/types/core/renderer.d.ts

@@ -1,7 +1,7 @@
 import { BardoDelegate } from "./bardo";
 import { Snapshot } from "./snapshot";
 import { ReloadReason } from "./native/browser_adapter";
-export declare type Render<E> = (newElement: E, currentElement: E) => void;
+export type Render<E> = (currentElement: E, newElement: E) => void;
 export declare abstract class Renderer<E extends Element, S extends Snapshot<E> = Snapshot<E>> implements BardoDelegate {
     readonly currentSnapshot: S;
     readonly newSnapshot: S;
@@ -17,7 +17,7 @@ export declare abstract class Renderer<E extends Element, S extends Snapshot<E>
     prepareToRender(): void;
     abstract render(): Promise<void>;
     finishRendering(): void;
-    preservingPermanentElements(callback: () => void): void;
+    preservingPermanentElements(callback: () => void): Promise<void>;
     focusFirstAutofocusableElement(): void;
     enteringBardo(currentPermanentElement: Element): void;
     leavingBardo(currentPermanentElement: Element): void;

package/dist/types/core/session.d.ts

@@ -21,32 +21,32 @@ import { FrameElement } from "../elements/frame_element";
 import { FrameViewRenderOptions } from "./frames/frame_view";
 import { FetchResponse } from "../http/fetch_response";
 import { Preloader, PreloaderDelegate } from "./drive/preloader";
-export declare type FormMode = "on" | "off" | "optin";
-export declare type TimingData = unknown;
-export declare type TurboBeforeCacheEvent = CustomEvent;
-export declare type TurboBeforeRenderEvent = CustomEvent<{
+export type FormMode = "on" | "off" | "optin";
+export type TimingData = unknown;
+export type TurboBeforeCacheEvent = CustomEvent;
+export type TurboBeforeRenderEvent = CustomEvent<{
     newBody: HTMLBodyElement;
 } & PageViewRenderOptions>;
-export declare type TurboBeforeVisitEvent = CustomEvent<{
+export type TurboBeforeVisitEvent = CustomEvent<{
     url: string;
 }>;
-export declare type TurboClickEvent = CustomEvent<{
+export type TurboClickEvent = CustomEvent<{
     url: string;
     originalEvent: MouseEvent;
 }>;
-export declare type TurboFrameLoadEvent = CustomEvent;
-export declare type TurboBeforeFrameRenderEvent = CustomEvent<{
+export type TurboFrameLoadEvent = CustomEvent;
+export type TurboBeforeFrameRenderEvent = CustomEvent<{
     newFrame: FrameElement;
 } & FrameViewRenderOptions>;
-export declare type TurboFrameRenderEvent = CustomEvent<{
+export type TurboFrameRenderEvent = CustomEvent<{
     fetchResponse: FetchResponse;
 }>;
-export declare type TurboLoadEvent = CustomEvent<{
+export type TurboLoadEvent = CustomEvent<{
     url: string;
     timing: TimingData;
 }>;
-export declare type TurboRenderEvent = CustomEvent;
-export declare type TurboVisitEvent = CustomEvent<{
+export type TurboRenderEvent = CustomEvent;
+export type TurboVisitEvent = CustomEvent<{
     url: string;
     action: Action;
 }>;

package/dist/types/core/snapshot.d.ts

@@ -13,4 +13,4 @@ export declare class Snapshot<E extends Element = Element> {
 }
 export declare function getPermanentElementById(node: ParentNode, id: string): Element | null;
 export declare function queryPermanentElementsAll(node: ParentNode): NodeListOf<Element>;
-export declare type PermanentElementMap = Record<string, [Element, Element]>;
+export type PermanentElementMap = Record<string, [Element, Element]>;

package/dist/types/core/streams/stream_actions.d.ts

@@ -1,6 +1,6 @@
 import { StreamElement } from "../../elements/stream_element";
-export declare type TurboStreamAction = (this: StreamElement) => void;
-export declare type TurboStreamActions = {
+export type TurboStreamAction = (this: StreamElement) => void;
+export type TurboStreamActions = {
     [action: string]: TurboStreamAction;
 };
 export declare const StreamActions: TurboStreamActions;

package/dist/types/core/types.d.ts

@@ -1,10 +1,9 @@
-export declare type Action = "advance" | "replace" | "restore";
-export declare function isAction(action: any): action is Action;
-export declare type Position = {
+export type Action = "advance" | "replace" | "restore";
+export type Position = {
     x: number;
     y: number;
 };
-export declare type StreamSource = {
+export type StreamSource = {
     addEventListener(type: "message", listener: (event: MessageEvent) => void, options?: boolean | AddEventListenerOptions): void;
     removeEventListener(type: "message", listener: (event: MessageEvent) => void, options?: boolean | EventListenerOptions): void;
 };

package/dist/types/core/url.d.ts

@@ -1,4 +1,4 @@
-export declare type Locatable = URL | string;
+export type Locatable = URL | string;
 export declare function expandURL(locatable: Locatable): URL;
 export declare function getAnchor(url: URL): string | undefined;
 export declare function getAction(form: HTMLFormElement, submitter?: HTMLElement): URL;

package/dist/types/core/view.d.ts

@@ -3,7 +3,7 @@ import { Renderer, Render } from "./renderer";
 import { Snapshot } from "./snapshot";
 import { Position } from "./types";
 export interface ViewRenderOptions<E> {
-    resume: (value: any) => void;
+    resume: (value?: any) => void;
     render: Render<E>;
 }
 export interface ViewDelegate<E extends Element, S extends Snapshot<E>> {

package/dist/types/elements/frame_element.d.ts

@@ -6,7 +6,7 @@ export declare enum FrameLoadingStyle {
     eager = "eager",
     lazy = "lazy"
 }
-export declare type FrameElementObservedAttribute = keyof FrameElement & ("disabled" | "complete" | "loading" | "src");
+export type FrameElementObservedAttribute = keyof FrameElement & ("disabled" | "complete" | "loading" | "src");
 export interface FrameElementDelegate extends LinkInterceptorDelegate, FormSubmitObserverDelegate {
     connect(): void;
     disconnect(): void;

package/dist/types/elements/stream_element.d.ts

@@ -1,5 +1,5 @@
-declare type Render = (currentElement: StreamElement) => Promise<void>;
-export declare type TurboBeforeStreamRenderEvent = CustomEvent<{
+type Render = (currentElement: StreamElement) => Promise<void>;
+export type TurboBeforeStreamRenderEvent = CustomEvent<{
     newStream: StreamElement;
     render: Render;
 }>;

package/dist/types/http/fetch_request.d.ts

@@ -1,20 +1,20 @@
 import { FetchResponse } from "./fetch_response";
 import { FrameElement } from "../elements/frame_element";
-export declare type TurboBeforeFetchRequestEvent = CustomEvent<{
+export type TurboBeforeFetchRequestEvent = CustomEvent<{
     fetchOptions: RequestInit;
     url: URL;
-    resume: (value: any) => void;
+    resume: (value?: any) => void;
 }>;
-export declare type TurboBeforeFetchResponseEvent = CustomEvent<{
+export type TurboBeforeFetchResponseEvent = CustomEvent<{
     fetchResponse: FetchResponse;
 }>;
-export declare type TurboFetchRequestErrorEvent = CustomEvent<{
+export type TurboFetchRequestErrorEvent = CustomEvent<{
     request: FetchRequest;
     error: Error;
 }>;
 export interface FetchRequestDelegate {
     referrer?: URL;
-    prepareHeadersForRequest?(headers: FetchRequestHeaders, request: FetchRequest): void;
+    prepareRequest(request: FetchRequest): void;
     requestStarted(request: FetchRequest): void;
     requestPreventedHandlingResponse(request: FetchRequest, response: FetchResponse): void;
     requestSucceededWithResponse(request: FetchRequest, response: FetchResponse): void;
@@ -30,8 +30,8 @@ export declare enum FetchMethod {
     delete = 4
 }
 export declare function fetchMethodFromString(method: string): FetchMethod | undefined;
-export declare type FetchRequestBody = FormData | URLSearchParams;
-export declare type FetchRequestHeaders = {
+export type FetchRequestBody = FormData | URLSearchParams;
+export type FetchRequestHeaders = {
     [header: string]: string;
 };
 export interface FetchRequestOptions {
@@ -59,7 +59,7 @@ export declare class FetchRequest {
     get defaultHeaders(): {
         Accept: string;
     };
-    get isIdempotent(): boolean;
+    get isSafe(): boolean;
     get abortSignal(): AbortSignal;
     acceptResponseType(mimeType: string): void;
     private allowRequestToBeIntercepted;

package/dist/types/http/index.d.ts

@@ -1 +1 @@
-export { TurboBeforeFetchRequestEvent, TurboBeforeFetchResponseEvent, TurboFetchRequestErrorEvent, } from "./fetch_request";
+export type { TurboBeforeFetchRequestEvent, TurboBeforeFetchResponseEvent, TurboFetchRequestErrorEvent, } from "./fetch_request";

package/dist/types/observers/appearance_observer.d.ts

@@ -1,12 +1,12 @@
-export interface AppearanceObserverDelegate {
-    elementAppearedInViewport(element: Element): void;
+export interface AppearanceObserverDelegate<T extends Element> {
+    elementAppearedInViewport(element: T): void;
 }
-export declare class AppearanceObserver {
-    readonly delegate: AppearanceObserverDelegate;
-    readonly element: Element;
+export declare class AppearanceObserver<T extends Element> {
+    readonly delegate: AppearanceObserverDelegate<T>;
+    readonly element: T;
     readonly intersectionObserver: IntersectionObserver;
     started: boolean;
-    constructor(delegate: AppearanceObserverDelegate, element: Element);
+    constructor(delegate: AppearanceObserverDelegate<T>, element: T);
     start(): void;
     stop(): void;
     intersect: IntersectionObserverCallback;

package/dist/types/observers/cache_observer.d.ts

@@ -1,6 +1,10 @@
 export declare class CacheObserver {
+    readonly selector: string;
+    readonly deprecatedSelector: string;
     started: boolean;
     start(): void;
     stop(): void;
-    removeStaleElements: EventListener;
+    removeTemporaryElements: EventListener;
+    get temporaryElements(): Element[];
+    get temporaryElementsWithDeprecation(): Element[];
 }

package/dist/types/observers/form_link_click_observer.d.ts

@@ -1,5 +1,5 @@
 import { LinkClickObserver, LinkClickObserverDelegate } from "./link_click_observer";
-export declare type FormLinkClickObserverDelegate = {
+export type FormLinkClickObserverDelegate = {
     willSubmitFormLinkToLocation(link: Element, location: URL, event: MouseEvent): boolean;
     submittedFormLinkToLocation(link: Element, location: URL, form: HTMLFormElement): void;
 };

package/dist/types/observers/link_click_observer.d.ts

@@ -12,6 +12,6 @@ export declare class LinkClickObserver {
     clickCaptured: () => void;
     clickBubbled: (event: Event) => void;
     clickEventIsSignificant(event: MouseEvent): boolean;
-    findLinkFromClickTarget(target: EventTarget | null): HTMLAnchorElement | null | undefined;
+    findLinkFromClickTarget(target: EventTarget | null): HTMLAnchorElement | undefined;
     getLocationForLink(link: Element): URL;
 }

package/dist/types/polyfills/custom-elements-native-shim.d.ts

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

package/dist/types/tests/functional/frame_tests.d.ts

@@ -1,3 +1,10 @@
+declare global {
+    namespace Chai {
+        interface AssertStatic {
+            equalIgnoringWhitespace(actual: string | null | undefined, expected: string, message?: string): void;
+        }
+    }
+}
 declare global {
     interface Window {
         frameScriptEvaluationCount?: number;

package/dist/types/tests/helpers/dom_test_case.d.ts

@@ -1,5 +1,4 @@
-import { InternTestCase } from "./intern_test_case";
-export declare class DOMTestCase extends InternTestCase {
+export declare class DOMTestCase {
     fixtureElement: HTMLElement;
     setup(): Promise<void>;
     teardown(): Promise<void>;

package/dist/types/tests/helpers/page.d.ts

@@ -1,13 +1,15 @@
 import { JSHandle, Locator, Page } from "@playwright/test";
-declare type Target = string | null;
-declare type EventType = string;
-declare type EventDetail = any;
-declare type EventLog = [EventType, EventDetail, Target];
-declare type MutationAttributeName = string;
-declare type MutationAttributeValue = string | null;
-declare type MutationLog = [MutationAttributeName, Target, MutationAttributeValue];
+type Target = string | null;
+type EventType = string;
+type EventDetail = any;
+type EventLog = [EventType, EventDetail, Target];
+type MutationAttributeName = string;
+type MutationAttributeValue = string | null;
+type MutationLog = [MutationAttributeName, Target, MutationAttributeValue];
+type BodyHTML = string;
+type BodyMutationLog = [BodyHTML];
 export declare function attributeForSelector(page: Page, selector: string, attributeName: string): Promise<string | null>;
-declare type CancellableEvent = "turbo:click" | "turbo:before-visit";
+type CancellableEvent = "turbo:click" | "turbo:before-visit";
 export declare function cancelNextEvent(page: Page, eventName: CancellableEvent): Promise<void>;
 export declare function clickWithoutScrolling(page: Page, selector: string, options?: {}): Promise<false | void>;
 export declare function clearLocalStorage(page: Page): Promise<void>;
@@ -23,13 +25,17 @@ export declare function nextBody(_page: Page, timeout?: number): Promise<void>;
 export declare function nextEventNamed(page: Page, eventName: string): Promise<any>;
 export declare function nextEventOnTarget(page: Page, elementId: string, eventName: string): Promise<any>;
 export declare function listenForEventOnTarget(page: Page, elementId: string, eventName: string): Promise<void>;
+export declare function nextBodyMutation(page: Page): Promise<string | null>;
+export declare function noNextBodyMutation(page: Page): Promise<boolean>;
 export declare function nextAttributeMutationNamed(page: Page, elementId: string, attributeName: string): Promise<string | null>;
 export declare function noNextAttributeMutationNamed(page: Page, elementId: string, attributeName: string): Promise<boolean>;
 export declare function noNextEventNamed(page: Page, eventName: string): Promise<boolean>;
 export declare function noNextEventOnTarget(page: Page, elementId: string, eventName: string): Promise<boolean>;
 export declare function outerHTMLForSelector(page: Page, selector: string): Promise<string>;
 export declare function pathname(url: string): string;
+export declare function pathnameForIFrame(page: Page, name: string): Promise<string>;
 export declare function propertyForSelector(page: Page, selector: string, propertyName: string): Promise<any>;
+export declare function readBodyMutationLogs(page: Page, length?: number): Promise<BodyMutationLog[]>;
 export declare function readEventLogs(page: Page, length?: number): Promise<EventLog[]>;
 export declare function readMutationLogs(page: Page, length?: number): Promise<MutationLog[]>;
 export declare function search(url: string): string;
@@ -47,6 +53,7 @@ export declare function strictElementEquals(left: Locator, right: Locator): Prom
 export declare function textContent(page: Page, html: string): Promise<string | null>;
 export declare function visitAction(page: Page): Promise<string>;
 export declare function waitForPathname(page: Page, pathname: string): Promise<void>;
+export declare function waitUntilText(page: Page, text: string, state?: "visible" | "attached"): Promise<import("playwright-core").ElementHandle<HTMLElement | SVGElement>>;
 export declare function waitUntilSelector(page: Page, selector: string, state?: "visible" | "attached"): Promise<import("playwright-core").ElementHandle<HTMLElement | SVGElement>>;
 export declare function waitUntilNoSelector(page: Page, selector: string, state?: "hidden" | "detached"): Promise<import("playwright-core").ElementHandle<HTMLElement | SVGElement> | null>;
 export declare function willChangeBody(page: Page, callback: () => Promise<void>): Promise<boolean>;

package/dist/types/tests/unit/deprecated_adapter_support_tests.d.ts

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