@hotwired/turbo 7.2.0-beta.1 → 7.2.0-beta.2

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

@@ -6,5 +6,5 @@ export declare class ErrorRenderer extends Renderer<HTMLBodyElement, PageSnapsho
     replaceHeadAndBody(): void;
     activateScriptElements(): void;
     get newHead(): HTMLHeadElement;
-    get scriptElements(): HTMLScriptElement[];
+    get scriptElements(): NodeListOf<HTMLScriptElement>;
 }

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

@@ -11,9 +11,9 @@ declare type ElementType = "script" | "stylesheet";
 export declare class HeadSnapshot extends Snapshot<HTMLHeadElement> {
     readonly detailsByOuterHTML: ElementDetailMap;
     get trackedElementSignature(): string;
-    getScriptElementsNotInSnapshot(snapshot: HeadSnapshot): Element[];
-    getStylesheetElementsNotInSnapshot(snapshot: HeadSnapshot): Element[];
-    getElementsMatchingTypeNotInSnapshot(matchedType: ElementType, snapshot: HeadSnapshot): Element[];
+    getScriptElementsNotInSnapshot(snapshot: HeadSnapshot): HTMLScriptElement[];
+    getStylesheetElementsNotInSnapshot(snapshot: HeadSnapshot): HTMLLinkElement[];
+    getElementsMatchingTypeNotInSnapshot<T extends Element>(matchedType: ElementType, snapshot: HeadSnapshot): T[];
     get provisionalElements(): Element[];
     getMetaValue(name: string): string | null;
     findMetaElementByName(name: string): Element | undefined;

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

@@ -5,7 +5,7 @@ import { Locatable } from "../url";
 import { Visit, VisitDelegate, VisitOptions } from "./visit";
 export declare type NavigatorDelegate = VisitDelegate & {
     allowsVisitingLocationWithAction(location: URL, action?: Action): boolean;
-    visitProposedToLocation(location: URL, options: Partial<VisitOptions>): void;
+    visitProposedToLocation(location: URL, options: Partial<VisitOptions>): Promise<void>;
     notifyApplicationAfterVisitingSamePageLocation(oldURL: URL, newURL: URL): void;
 };
 export declare class Navigator {
@@ -14,8 +14,8 @@ export declare class Navigator {
     currentVisit?: Visit;
     lastVisit?: Visit;
     constructor(delegate: NavigatorDelegate);
-    proposeVisit(location: URL, options?: Partial<VisitOptions>): void;
-    startVisit(locatable: Locatable, restorationIdentifier: string, options?: Partial<VisitOptions>): void;
+    proposeVisit(location: URL, options?: Partial<VisitOptions>): Promise<void>;
+    startVisit(locatable: Locatable, restorationIdentifier: string, options?: Partial<VisitOptions>): Promise<void>;
     submitForm(form: HTMLFormElement, submitter?: HTMLElement): void;
     stop(): void;
     get adapter(): import("../native/adapter").Adapter;

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

@@ -5,24 +5,24 @@ export declare class PageRenderer extends Renderer<HTMLBodyElement, PageSnapshot
     static renderElement(currentElement: HTMLBodyElement, newElement: HTMLBodyElement): void;
     get shouldRender(): boolean;
     get reloadReason(): ReloadReason;
-    prepareToRender(): void;
+    prepareToRender(): Promise<void>;
     render(): Promise<void>;
     finishRendering(): void;
     get currentHeadSnapshot(): import("./head_snapshot").HeadSnapshot;
     get newHeadSnapshot(): import("./head_snapshot").HeadSnapshot;
     get newElement(): HTMLBodyElement;
-    mergeHead(): void;
+    mergeHead(): Promise<void>;
     replaceBody(): void;
     get trackedElementsAreIdentical(): boolean;
-    copyNewHeadStylesheetElements(): void;
+    copyNewHeadStylesheetElements(): Promise<void>;
     copyNewHeadScriptElements(): void;
     removeCurrentHeadProvisionalElements(): void;
     copyNewHeadProvisionalElements(): void;
     activateNewBody(): void;
     activateNewBodyScriptElements(): void;
     assignNewBody(): void;
-    get newHeadStylesheetElements(): Element[];
-    get newHeadScriptElements(): Element[];
+    get newHeadStylesheetElements(): HTMLLinkElement[];
+    get newHeadScriptElements(): HTMLScriptElement[];
     get currentHeadProvisionalElements(): Element[];
     get newHeadProvisionalElements(): Element[];
     get newBodyScriptElements(): NodeListOf<HTMLScriptElement>;

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

@@ -1,5 +1,5 @@
 import { Adapter } from "../native/adapter";
-import { FetchRequest, FetchRequestDelegate } from "../../http/fetch_request";
+import { FetchRequest, FetchRequestDelegate, FetchRequestHeaders } from "../../http/fetch_request";
 import { FetchResponse } from "../../http/fetch_response";
 import { History } from "./history";
 import { Snapshot } from "../snapshot";
@@ -39,6 +39,11 @@ export declare type VisitOptions = {
     response?: VisitResponse;
     visitCachedSnapshot(snapshot: Snapshot): void;
     willRender: boolean;
+    updateHistory: boolean;
+    restorationIdentifier?: string;
+    shouldCacheSnapshot: boolean;
+    frame?: string;
+    acceptsStreamResponse: boolean;
 };
 export declare type VisitResponse = {
     statusCode: number;
@@ -59,6 +64,9 @@ export declare class Visit implements FetchRequestDelegate {
     readonly timingMetrics: TimingMetrics;
     readonly visitCachedSnapshot: (snapshot: Snapshot) => void;
     readonly willRender: boolean;
+    readonly updateHistory: boolean;
+    readonly promise: Promise<void>;
+    private resolvingFunctions;
     followedRedirect: boolean;
     frame?: number;
     historyChanged: boolean;
@@ -68,6 +76,8 @@ export declare class Visit implements FetchRequestDelegate {
     request?: FetchRequest;
     response?: VisitResponse;
     scrolled: boolean;
+    shouldCacheSnapshot: boolean;
+    acceptsStreamResponse: boolean;
     snapshotHTML?: string;
     snapshotCached: boolean;
     state: VisitState;
@@ -94,6 +104,7 @@ export declare class Visit implements FetchRequestDelegate {
     loadCachedSnapshot(): void;
     followRedirect(): void;
     goToSamePageAnchor(): void;
+    prepareHeadersForRequest(headers: FetchRequestHeaders, request: FetchRequest): void;
     requestStarted(): void;
     requestPreventedHandlingResponse(_request: FetchRequest, _response: FetchResponse): void;
     requestSucceededWithResponse(request: FetchRequest, response: FetchResponse): Promise<void>;

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

@@ -5,17 +5,20 @@ import { AppearanceObserver, AppearanceObserverDelegate } from "../../observers/
 import { FormSubmission, FormSubmissionDelegate } from "../drive/form_submission";
 import { Snapshot } from "../snapshot";
 import { ViewDelegate, ViewRenderOptions } from "../view";
-import { FormInterceptor, FormInterceptorDelegate } from "./form_interceptor";
+import { FormSubmitObserver, FormSubmitObserverDelegate } from "../../observers/form_submit_observer";
 import { FrameView } from "./frame_view";
-import { LinkInterceptor, LinkInterceptorDelegate } from "./link_interceptor";
-import { FormLinkInterceptor, FormLinkInterceptorDelegate } from "../../observers/form_link_interceptor";
-export declare class FrameController implements AppearanceObserverDelegate, FetchRequestDelegate, FormInterceptorDelegate, FormSubmissionDelegate, FrameElementDelegate, FormLinkInterceptorDelegate, LinkInterceptorDelegate, ViewDelegate<FrameElement, Snapshot<FrameElement>> {
+import { LinkClickObserver, LinkClickObserverDelegate } from "../../observers/link_click_observer";
+import { FormLinkClickObserver, FormLinkClickObserverDelegate } from "../../observers/form_link_click_observer";
+export declare type TurboFrameMissingEvent = CustomEvent<{
+    fetchResponse: FetchResponse;
+}>;
+export declare class FrameController implements AppearanceObserverDelegate, FetchRequestDelegate, FormSubmitObserverDelegate, FormSubmissionDelegate, FrameElementDelegate, FormLinkClickObserverDelegate, LinkClickObserverDelegate, ViewDelegate<FrameElement, Snapshot<FrameElement>> {
     readonly element: FrameElement;
     readonly view: FrameView;
     readonly appearanceObserver: AppearanceObserver;
-    readonly formLinkInterceptor: FormLinkInterceptor;
-    readonly linkInterceptor: LinkInterceptor;
-    readonly formInterceptor: FormInterceptor;
+    readonly formLinkClickObserver: FormLinkClickObserver;
+    readonly linkClickObserver: LinkClickObserver;
+    readonly formSubmitObserver: FormSubmitObserver;
     formSubmission?: FormSubmission;
     fetchResponseLoaded: (_fetchResponse: FetchResponse) => void;
     private currentFetchRequest;
@@ -23,7 +26,11 @@ export declare class FrameController implements AppearanceObserverDelegate, Fetc
     private connected;
     private hasBeenLoaded;
     private ignoredAttributes;
+    private action;
+    private frame?;
+    readonly restorationIdentifier: string;
     private previousFrameElement?;
+    private currentNavigationElement?;
     constructor(element: FrameElement);
     connect(): void;
     disconnect(): void;
@@ -34,13 +41,13 @@ export declare class FrameController implements AppearanceObserverDelegate, Fetc
     private loadSourceURL;
     loadResponse(fetchResponse: FetchResponse): Promise<void>;
     elementAppearedInViewport(_element: Element): void;
-    shouldInterceptFormLinkClick(link: Element): boolean;
-    formLinkClickIntercepted(link: Element, form: HTMLFormElement): void;
-    shouldInterceptLinkClick(element: Element, _url: string): boolean;
-    linkClickIntercepted(element: Element, url: string): void;
-    shouldInterceptFormSubmission(element: HTMLFormElement, submitter?: HTMLElement): boolean;
-    formSubmissionIntercepted(element: HTMLFormElement, submitter?: HTMLElement): void;
-    prepareHeadersForRequest(headers: FetchRequestHeaders, _request: FetchRequest): void;
+    willSubmitFormLinkToLocation(link: Element): boolean;
+    submittedFormLinkToLocation(link: Element, _location: URL, form: HTMLFormElement): void;
+    willFollowLinkToLocation(element: Element): boolean;
+    followedLinkToLocation(element: Element, location: URL): void;
+    willSubmitForm(element: HTMLFormElement, submitter?: HTMLElement): boolean;
+    formSubmitted(element: HTMLFormElement, submitter?: HTMLElement): void;
+    prepareHeadersForRequest(headers: FetchRequestHeaders, request: FetchRequest): void;
     requestStarted(_request: FetchRequest): void;
     requestPreventedHandlingResponse(_request: FetchRequest, _response: FetchResponse): void;
     requestSucceededWithResponse(request: FetchRequest, response: FetchResponse): Promise<void>;
@@ -56,13 +63,15 @@ export declare class FrameController implements AppearanceObserverDelegate, Fetc
     viewRenderedSnapshot(_snapshot: Snapshot, _isPreview: boolean): void;
     preloadOnLoadLinksForView(element: Element): void;
     viewInvalidated(): void;
-    frameExtracted(element: FrameElement): void;
+    willRenderFrame(currentElement: FrameElement, _newElement: FrameElement): void;
     visitCachedSnapshot: ({ element }: Snapshot) => void;
     private visit;
     private navigateFrame;
     private proposeVisitIfNavigatedWithAction;
+    changeHistory(): void;
+    private sessionWillHandleMissingFrame;
     private findFrameElement;
-    extractForeignFrameElement(container: ParentNode): Promise<FrameElement>;
+    extractForeignFrameElement(container: ParentNode): Promise<FrameElement | null>;
     private formActionIsVisitable;
     private shouldInterceptNavigation;
     get id(): string;
@@ -77,4 +86,5 @@ export declare class FrameController implements AppearanceObserverDelegate, Fetc
     get rootLocation(): URL;
     private isIgnoringChangesTo;
     private ignoringChangesToAttribute;
+    private withCurrentNavigationElement;
 }

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

@@ -1,16 +1,18 @@
-import { FormInterceptor, FormInterceptorDelegate } from "./form_interceptor";
-import { LinkInterceptor, LinkInterceptorDelegate } from "./link_interceptor";
-export declare class FrameRedirector implements LinkInterceptorDelegate, FormInterceptorDelegate {
+import { FormSubmitObserver, FormSubmitObserverDelegate } from "../../observers/form_submit_observer";
+import { LinkClickObserver, LinkClickObserverDelegate } from "../../observers/link_click_observer";
+import { Session } from "../session";
+export declare class FrameRedirector implements LinkClickObserverDelegate, FormSubmitObserverDelegate {
+    readonly session: Session;
     readonly element: Element;
-    readonly linkInterceptor: LinkInterceptor;
-    readonly formInterceptor: FormInterceptor;
-    constructor(element: Element);
+    readonly linkClickObserver: LinkClickObserver;
+    readonly formSubmitObserver: FormSubmitObserver;
+    constructor(session: Session, element: Element);
     start(): void;
     stop(): void;
-    shouldInterceptLinkClick(element: Element, _url: string): boolean;
-    linkClickIntercepted(element: Element, url: string): void;
-    shouldInterceptFormSubmission(element: HTMLFormElement, submitter?: HTMLElement): boolean;
-    formSubmissionIntercepted(element: HTMLFormElement, submitter?: HTMLElement): void;
+    willFollowLinkToLocation(element: Element): boolean;
+    followedLinkToLocation(element: Element, url: URL): void;
+    willSubmitForm(element: HTMLFormElement, submitter?: HTMLElement): boolean;
+    formSubmitted(element: HTMLFormElement, submitter?: HTMLElement): void;
     private shouldSubmit;
     private shouldRedirect;
     private findFrameElement;

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

@@ -2,7 +2,7 @@ import { FrameElement } from "../../elements/frame_element";
 import { Render, Renderer } from "../renderer";
 import { Snapshot } from "../snapshot";
 export interface FrameRendererDelegate {
-    frameExtracted(element: FrameElement): void;
+    willRenderFrame(currentElement: FrameElement, newElement: FrameElement): void;
 }
 export declare class FrameRenderer extends Renderer<FrameElement> {
     private readonly delegate;

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

@@ -1,5 +1,5 @@
 import { Adapter } from "./native/adapter";
-import { Session } from "./session";
+import { FormMode, Session } from "./session";
 import { Cache } from "./cache";
 import { Locatable } from "./url";
 import { StreamMessage } from "./streams/stream_message";
@@ -12,18 +12,19 @@ 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, TurboFrameLoadEvent, TurboFrameRenderEvent, TurboLoadEvent, TurboRenderEvent, TurboVisitEvent, } from "./session";
+export { TurboBeforeCacheEvent, TurboBeforeRenderEvent, TurboBeforeVisitEvent, TurboClickEvent, TurboFetchRequestErrorEvent, TurboFrameLoadEvent, TurboFrameRenderEvent, TurboLoadEvent, TurboRenderEvent, TurboVisitEvent, } from "./session";
 export { TurboSubmitStartEvent, TurboSubmitEndEvent } from "./drive/form_submission";
+export { TurboFrameMissingEvent } from "./frames/frame_controller";
 export { TurboBeforeFetchRequestEvent, TurboBeforeFetchResponseEvent } from "../http/fetch_request";
 export { TurboBeforeStreamRenderEvent } from "../elements/stream_element";
 export { StreamActions } 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;
+export declare function visit(location: Locatable, options?: Partial<VisitOptions>): Promise<void>;
 export declare function connectStreamSource(source: StreamSource): void;
 export declare function disconnectStreamSource(source: StreamSource): void;
 export declare function renderStreamMessage(message: StreamMessage | string): void;
 export declare function clearCache(): void;
 export declare function setProgressBarDelay(delay: number): void;
 export declare function setConfirmMethod(confirmMethod: (message: string, element: HTMLFormElement) => Promise<boolean>): void;
-export declare function setFormMode(mode: string): void;
+export declare function setFormMode(mode: FormMode): void;

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

@@ -2,7 +2,7 @@ import { Visit, VisitOptions } from "../drive/visit";
 import { FormSubmission } from "../drive/form_submission";
 import { ReloadReason } from "./browser_adapter";
 export interface Adapter {
-    visitProposedToLocation(location: URL, options?: Partial<VisitOptions>): void;
+    visitProposedToLocation(location: URL, options?: Partial<VisitOptions>): Promise<void>;
     visitStarted(visit: Visit): void;
     visitCompleted(visit: Visit): void;
     visitFailed(visit: Visit): void;

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

@@ -17,7 +17,7 @@ export declare class BrowserAdapter implements Adapter {
     formProgressBarTimeout?: number;
     location?: URL;
     constructor(session: Session);
-    visitProposedToLocation(location: URL, options?: Partial<VisitOptions>): void;
+    visitProposedToLocation(location: URL, options?: Partial<VisitOptions>): Promise<void>;
     visitStarted(visit: Visit): void;
     visitRequestStarted(visit: Visit): void;
     visitRequestCompleted(visit: Visit): void;

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

@@ -17,7 +17,6 @@ export declare abstract class Renderer<E extends Element, S extends Snapshot<E>
     prepareToRender(): void;
     abstract render(): Promise<void>;
     finishRendering(): void;
-    createScriptElement(element: Element): Element;
     preservingPermanentElements(callback: () => void): void;
     focusFirstAutofocusableElement(): void;
     enteringBardo(currentPermanentElement: Element): void;
@@ -26,5 +25,4 @@ export declare abstract class Renderer<E extends Element, S extends Snapshot<E>
     get currentElement(): E;
     get newElement(): E;
     get permanentElementMap(): import("./snapshot").PermanentElementMap;
-    get cspNonce(): string | null;
 }

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

@@ -5,7 +5,7 @@ import { FormSubmitObserver, FormSubmitObserverDelegate } from "../observers/for
 import { FrameRedirector } from "./frames/frame_redirector";
 import { History, HistoryDelegate } from "./drive/history";
 import { LinkClickObserver, LinkClickObserverDelegate } from "../observers/link_click_observer";
-import { FormLinkInterceptor, FormLinkInterceptorDelegate } from "../observers/form_link_interceptor";
+import { FormLinkClickObserver, FormLinkClickObserverDelegate } from "../observers/form_link_click_observer";
 import { Locatable } from "./url";
 import { Navigator, NavigatorDelegate } from "./drive/navigator";
 import { PageObserver, PageObserverDelegate } from "../observers/page_observer";
@@ -20,6 +20,8 @@ import { FrameElement } from "../elements/frame_element";
 import { FrameViewRenderOptions } from "./frames/frame_view";
 import { FetchResponse } from "../http/fetch_response";
 import { Preloader, PreloaderDelegate } from "./drive/preloader";
+import { FetchRequest } from "../http/fetch_request";
+export declare type FormMode = "on" | "off" | "optin";
 export declare type TimingData = unknown;
 export declare type TurboBeforeCacheEvent = CustomEvent;
 export declare type TurboBeforeRenderEvent = CustomEvent<{
@@ -36,6 +38,10 @@ export declare type TurboFrameLoadEvent = CustomEvent;
 export declare type TurboBeforeFrameRenderEvent = CustomEvent<{
     newFrame: FrameElement;
 } & FrameViewRenderOptions>;
+export declare type TurboFetchRequestErrorEvent = CustomEvent<{
+    request: FetchRequest;
+    error: Error;
+}>;
 export declare type TurboFrameRenderEvent = CustomEvent<{
     fetchResponse: FetchResponse;
 }>;
@@ -48,7 +54,7 @@ export declare type TurboVisitEvent = CustomEvent<{
     url: string;
     action: Action;
 }>;
-export declare class Session implements FormSubmitObserverDelegate, HistoryDelegate, FormLinkInterceptorDelegate, LinkClickObserverDelegate, NavigatorDelegate, PageObserverDelegate, PageViewDelegate, PreloaderDelegate {
+export declare class Session implements FormSubmitObserverDelegate, HistoryDelegate, FormLinkClickObserverDelegate, LinkClickObserverDelegate, NavigatorDelegate, PageObserverDelegate, PageViewDelegate, PreloaderDelegate {
     readonly navigator: Navigator;
     readonly history: History;
     readonly preloader: Preloader;
@@ -60,34 +66,34 @@ export declare class Session implements FormSubmitObserverDelegate, HistoryDeleg
     readonly formSubmitObserver: FormSubmitObserver;
     readonly scrollObserver: ScrollObserver;
     readonly streamObserver: StreamObserver;
-    readonly formLinkInterceptor: FormLinkInterceptor;
+    readonly formLinkClickObserver: FormLinkClickObserver;
     readonly frameRedirector: FrameRedirector;
     drive: boolean;
     enabled: boolean;
     progressBarDelay: number;
     started: boolean;
-    formMode: string;
+    formMode: FormMode;
     start(): void;
     disable(): void;
     stop(): void;
     registerAdapter(adapter: Adapter): void;
-    visit(location: Locatable, options?: Partial<VisitOptions>): void;
+    visit(location: Locatable, options?: Partial<VisitOptions>): Promise<void>;
     connectStreamSource(source: StreamSource): void;
     disconnectStreamSource(source: StreamSource): void;
     renderStreamMessage(message: StreamMessage | string): void;
     clearCache(): void;
     setProgressBarDelay(delay: number): void;
-    setFormMode(mode: string): void;
+    setFormMode(mode: FormMode): void;
     get location(): URL;
     get restorationIdentifier(): string;
     historyPoppedToLocationWithRestorationIdentifier(location: URL, restorationIdentifier: string): void;
     scrollPositionChanged(position: Position): void;
-    shouldInterceptFormLinkClick(_link: Element): boolean;
-    formLinkClickIntercepted(_link: Element, _form: HTMLFormElement): void;
+    willSubmitFormLinkToLocation(link: Element, location: URL): boolean;
+    submittedFormLinkToLocation(): void;
     willFollowLinkToLocation(link: Element, location: URL, event: MouseEvent): boolean;
     followedLinkToLocation(link: Element, location: URL): void;
     allowsVisitingLocationWithAction(location: URL, action?: Action): boolean;
-    visitProposedToLocation(location: URL, options: Partial<VisitOptions>): void;
+    visitProposedToLocation(location: URL, options: Partial<VisitOptions>): Promise<void>;
     visitStarted(visit: Visit): void;
     visitCompleted(visit: Visit): void;
     locationWithActionIsSamePage(location: URL, action?: Action): boolean;
@@ -105,6 +111,7 @@ export declare class Session implements FormSubmitObserverDelegate, HistoryDeleg
     viewInvalidated(reason: ReloadReason): void;
     frameLoaded(frame: FrameElement): void;
     frameRendered(fetchResponse: FetchResponse, frame: FrameElement): void;
+    frameMissing(frame: FrameElement, fetchResponse: FetchResponse): Promise<void>;
     applicationAllowsFollowingLinkToLocation(link: Element, location: URL, ev: MouseEvent): boolean;
     applicationAllowsVisitingLocation(location: URL): boolean;
     notifyApplicationAfterClickingLinkToLocation(link: Element, location: URL, event: MouseEvent): CustomEvent<{
@@ -132,8 +139,8 @@ export declare class Session implements FormSubmitObserverDelegate, HistoryDeleg
     notifyApplicationAfterFrameRender(fetchResponse: FetchResponse, frame: FrameElement): CustomEvent<{
         fetchResponse: FetchResponse;
     }>;
-    formElementDriveEnabled(element?: Element): boolean;
-    elementDriveEnabled(element?: Element): boolean;
+    submissionIsNavigatable(form: HTMLFormElement, submitter?: HTMLElement): boolean;
+    elementIsNavigatable(element: Element): boolean;
     getActionForLink(link: Element): Action;
     get snapshot(): PageSnapshot;
 }

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

@@ -1,10 +1,6 @@
-import { StreamElement } from "../../elements/stream_element";
 export declare class StreamMessage {
     static readonly contentType = "text/vnd.turbo-stream.html";
-    readonly templateElement: HTMLTemplateElement;
+    readonly fragment: DocumentFragment;
     static wrap(message: StreamMessage | string): StreamMessage;
-    constructor(html: string);
-    get fragment(): DocumentFragment;
-    get foreignElements(): StreamElement[];
-    get templateChildren(): Element[];
+    constructor(fragment: DocumentFragment);
 }

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

@@ -8,3 +8,7 @@ export declare type StreamSource = {
     addEventListener(type: "message", listener: (event: MessageEvent) => void, options?: boolean | AddEventListenerOptions): void;
     removeEventListener(type: "message", listener: (event: MessageEvent) => void, options?: boolean | EventListenerOptions): void;
 };
+export declare type ResolvingFunctions<T = unknown> = {
+    resolve(value: T | PromiseLike<T>): void;
+    reject(reason?: any): void;
+};

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

@@ -32,7 +32,7 @@ export declare abstract class View<E extends Element, S extends Snapshot<E> = Sn
     };
     render(renderer: R): Promise<void>;
     invalidate(reason: ReloadReason): void;
-    prepareToRenderSnapshot(renderer: R): void;
+    prepareToRenderSnapshot(renderer: R): Promise<void>;
     markAsPreview(isPreview: boolean): void;
     renderSnapshot(renderer: R): Promise<void>;
     finishRenderingSnapshot(renderer: R): void;

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

@@ -1,19 +1,19 @@
 import { FetchResponse } from "../http/fetch_response";
 import { Snapshot } from "../core/snapshot";
+import { LinkClickObserverDelegate } from "../observers/link_click_observer";
+import { FormSubmitObserverDelegate } from "../observers/form_submit_observer";
 export declare enum FrameLoadingStyle {
     eager = "eager",
     lazy = "lazy"
 }
 export declare type FrameElementObservedAttribute = keyof FrameElement & ("disabled" | "complete" | "loading" | "src");
-export interface FrameElementDelegate {
+export interface FrameElementDelegate extends LinkClickObserverDelegate, FormSubmitObserverDelegate {
     connect(): void;
     disconnect(): void;
     completeChanged(): void;
     loadingStyleChanged(): void;
     sourceURLChanged(): void;
     disabledChanged(): void;
-    formSubmissionIntercepted(element: HTMLFormElement, submitter?: HTMLElement): void;
-    linkClickIntercepted(element: Element, url: string): void;
     loadResponse(response: FetchResponse): void;
     fetchResponseLoaded: (fetchResponse: FetchResponse) => void;
     visitCachedSnapshot: (snapshot: Snapshot) => void;
@@ -21,13 +21,13 @@ export interface FrameElementDelegate {
 }
 export declare class FrameElement extends HTMLElement {
     static delegateConstructor: new (element: FrameElement) => FrameElementDelegate;
-    loaded: Promise<FetchResponse | void>;
+    loaded: Promise<void>;
     readonly delegate: FrameElementDelegate;
     static get observedAttributes(): FrameElementObservedAttribute[];
     constructor();
     connectedCallback(): void;
     disconnectedCallback(): void;
-    reload(): void;
+    reload(): Promise<void>;
     attributeChangedCallback(name: string): void;
     get src(): string | null;
     set src(value: string | null);

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

@@ -1,4 +1,6 @@
-export declare type TurboBeforeStreamRenderEvent = CustomEvent;
+export declare type TurboBeforeStreamRenderEvent = CustomEvent<{
+    newStream: StreamElement;
+}>;
 export declare class StreamElement extends HTMLElement {
     connectedCallback(): Promise<void>;
     private renderPromise?;

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

@@ -57,5 +57,6 @@ export declare class FetchRequest {
     };
     get isIdempotent(): boolean;
     get abortSignal(): AbortSignal;
+    acceptResponseType(mimeType: string): void;
     private allowRequestToBeIntercepted;
 }

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

@@ -0,0 +1,14 @@
+import { LinkClickObserver, LinkClickObserverDelegate } from "./link_click_observer";
+export declare type FormLinkClickObserverDelegate = {
+    willSubmitFormLinkToLocation(link: Element, location: URL, event: MouseEvent): boolean;
+    submittedFormLinkToLocation(link: Element, location: URL, form: HTMLFormElement): void;
+};
+export declare class FormLinkClickObserver implements LinkClickObserverDelegate {
+    readonly linkClickObserver: LinkClickObserver;
+    readonly delegate: FormLinkClickObserverDelegate;
+    constructor(delegate: FormLinkClickObserverDelegate, element: HTMLElement);
+    start(): void;
+    stop(): void;
+    willFollowLinkToLocation(link: Element, location: URL, originalEvent: MouseEvent): boolean;
+    followedLinkToLocation(link: Element, location: URL): void;
+}

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

@@ -4,8 +4,9 @@ export interface FormSubmitObserverDelegate {
 }
 export declare class FormSubmitObserver {
     readonly delegate: FormSubmitObserverDelegate;
+    readonly eventTarget: EventTarget;
     started: boolean;
-    constructor(delegate: FormSubmitObserverDelegate);
+    constructor(delegate: FormSubmitObserverDelegate, eventTarget: EventTarget);
     start(): void;
     stop(): void;
     submitCaptured: () => void;

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

@@ -4,12 +4,13 @@ export interface LinkClickObserverDelegate {
 }
 export declare class LinkClickObserver {
     readonly delegate: LinkClickObserverDelegate;
+    readonly eventTarget: EventTarget;
     started: boolean;
-    constructor(delegate: LinkClickObserverDelegate);
+    constructor(delegate: LinkClickObserverDelegate, eventTarget: EventTarget);
     start(): void;
     stop(): void;
     clickCaptured: () => void;
-    clickBubbled: (event: MouseEvent) => void;
+    clickBubbled: (event: Event) => void;
     clickEventIsSignificant(event: MouseEvent): boolean;
     findLinkFromClickTarget(target: EventTarget | null): HTMLAnchorElement | null | undefined;
     getLocationForLink(link: Element): URL;

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

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

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

@@ -9,7 +9,7 @@ export declare class DeprecatedAdapterSupportTest extends DOMTestCase implements
     teardown(): Promise<void>;
     "test visit proposal location includes deprecated absoluteURL property"(): Promise<void>;
     "test visit start location includes deprecated absoluteURL property"(): Promise<void>;
-    visitProposedToLocation(location: URL, _options?: Partial<VisitOptions>): void;
+    visitProposedToLocation(location: URL, _options?: Partial<VisitOptions>): Promise<void>;
     visitStarted(visit: Visit): void;
     visitCompleted(_visit: Visit): void;
     visitFailed(_visit: Visit): void;

package/dist/types/util.d.ts

@@ -1,8 +1,11 @@
+import { Action } from "./core/types";
 export declare type DispatchOptions<T extends CustomEvent> = {
     target: EventTarget;
     cancelable: boolean;
     detail: T["detail"];
 };
+export declare function activateScriptElement(element: HTMLScriptElement): HTMLScriptElement;
+export declare function createDocumentFragment(html: string): DocumentFragment;
 export declare function dispatch<T extends CustomEvent>(eventName: string, { target, cancelable, detail }?: Partial<DispatchOptions<T>>): CustomEvent<T["detail"]>;
 export declare function nextAnimationFrame(): Promise<void>;
 export declare function nextEventLoopTick(): Promise<void>;
@@ -13,6 +16,9 @@ export declare function uuid(): string;
 export declare function getAttribute(attributeName: string, ...elements: (Element | undefined)[]): string | null;
 export declare function markAsBusy(...elements: Element[]): void;
 export declare function clearBusyState(...elements: Element[]): void;
+export declare function waitForLoad(element: HTMLLinkElement, timeoutInMilliseconds?: number): Promise<void>;
+export declare function getHistoryMethodForAction(action: Action): (data: any, unused: string, url?: string | URL | null | undefined) => void;
+export declare function getVisitAction(...elements: (Element | undefined)[]): Action | null;
 export declare function getMetaElement(name: string): HTMLMetaElement | null;
 export declare function getMetaContent(name: string): string | null;
 export declare function setMetaContent(name: string, content: string): HTMLMetaElement;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hotwired/turbo",
-  "version": "7.2.0-beta.1",
+  "version": "7.2.0-beta.2",
   "description": "The speed of a single-page web application without having to write any JavaScript",
   "module": "dist/turbo.es2017-esm.js",
   "main": "dist/turbo.es2017-umd.js",

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

@@ -1,12 +0,0 @@
-export interface FormInterceptorDelegate {
-    shouldInterceptFormSubmission(element: HTMLFormElement, submitter?: HTMLElement): boolean;
-    formSubmissionIntercepted(element: HTMLFormElement, submitter?: HTMLElement): void;
-}
-export declare class FormInterceptor {
-    readonly delegate: FormInterceptorDelegate;
-    readonly element: Element;
-    constructor(delegate: FormInterceptorDelegate, element: Element);
-    start(): void;
-    stop(): void;
-    submitBubbled: EventListener;
-}

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

@@ -1,16 +0,0 @@
-export interface LinkInterceptorDelegate {
-    shouldInterceptLinkClick(element: Element, url: string): boolean;
-    linkClickIntercepted(element: Element, url: string): void;
-}
-export declare class LinkInterceptor {
-    readonly delegate: LinkInterceptorDelegate;
-    readonly element: Element;
-    private clickEvent?;
-    constructor(delegate: LinkInterceptorDelegate, element: Element);
-    start(): void;
-    stop(): void;
-    clickBubbled: (event: Event) => void;
-    linkClicked: EventListener;
-    willVisit: EventListener;
-    respondsToEventTarget(target: EventTarget | null): boolean | null;
-}