@hotwired/turbo 7.1.0 → 7.3.0

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

@@ -1,8 +1,13 @@
 import { PermanentElementMap } from "./snapshot";
+export interface BardoDelegate {
+    enteringBardo(currentPermanentElement: Element, newPermanentElement: Element): void;
+    leavingBardo(currentPermanentElement: Element): void;
+}
 export declare class Bardo {
     readonly permanentElementMap: PermanentElementMap;
-    static preservingPermanentElements(permanentElementMap: PermanentElementMap, callback: () => void): void;
-    constructor(permanentElementMap: PermanentElementMap);
+    readonly delegate: BardoDelegate;
+    static preservingPermanentElements(delegate: BardoDelegate, permanentElementMap: PermanentElementMap, callback: () => void): Promise<void>;
+    constructor(delegate: BardoDelegate, permanentElementMap: PermanentElementMap);
     enter(): void;
     leave(): void;
     replaceNewPermanentElementWithPlaceholder(permanentElement: Element): void;

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

@@ -0,0 +1,10 @@
+import { Session } from "./session";
+export declare class Cache {
+    readonly session: Session;
+    constructor(session: Session);
+    clear(): void;
+    resetCacheControl(): void;
+    exemptPageFromCache(): void;
+    exemptPageFromPreview(): void;
+    private setCacheControl;
+}

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

@@ -1,9 +1,10 @@
 import { PageSnapshot } from "./page_snapshot";
 import { Renderer } from "../renderer";
 export declare class ErrorRenderer extends Renderer<HTMLBodyElement, PageSnapshot> {
+    static renderElement(currentElement: HTMLBodyElement, newElement: HTMLBodyElement): void;
     render(): Promise<void>;
     replaceHeadAndBody(): void;
     activateScriptElements(): void;
     get newHead(): HTMLHeadElement;
-    get scriptElements(): HTMLScriptElement[];
+    get scriptElements(): NodeListOf<HTMLScriptElement>;
 }

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,6 +27,14 @@ declare enum FormEnctype {
     multipart = "multipart/form-data",
     plain = "text/plain"
 }
+export type TurboSubmitStartEvent = CustomEvent<{
+    formSubmission: FormSubmission;
+}>;
+export type TurboSubmitEndEvent = CustomEvent<{
+    formSubmission: FormSubmission;
+} & {
+    [K in keyof FormSubmissionResult]?: FormSubmissionResult[K];
+}>;
 export declare class FormSubmission {
     readonly delegate: FormSubmissionDelegate;
     readonly formElement: HTMLFormElement;
@@ -37,25 +45,28 @@ export declare class FormSubmission {
     readonly mustRedirect: boolean;
     state: FormSubmissionState;
     result?: FormSubmissionResult;
-    static confirmMethod(message: string, element: HTMLFormElement): boolean;
+    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][];
-    get confirmationMessage(): string | null;
-    get needsConfirmation(): boolean;
     start(): Promise<void | FetchResponse>;
     stop(): true | undefined;
-    prepareHeadersForRequest(headers: FetchRequestHeaders, request: FetchRequest): void;
-    requestStarted(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;
+    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,19 +1,19 @@
 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;
-    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/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 {
@@ -28,7 +28,7 @@ export declare class History {
     assumeControlOfScrollRestoration(): void;
     relinquishControlOfScrollRestoration(): void;
     onPopState: (event: PopStateEvent) => void;
-    onPageLoad: (event: Event) => Promise<void>;
+    onPageLoad: (_event: Event) => Promise<void>;
     shouldHandlePopState(): boolean;
     pageIsLoaded(): boolean;
 }

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

@@ -1,25 +1,30 @@
 import { Renderer } from "../renderer";
 import { PageSnapshot } from "./page_snapshot";
+import { ReloadReason } from "../native/browser_adapter";
 export declare class PageRenderer extends Renderer<HTMLBodyElement, PageSnapshot> {
+    static renderElement(currentElement: HTMLBodyElement, newElement: HTMLBodyElement): void;
     get shouldRender(): boolean;
-    prepareToRender(): void;
+    get reloadReason(): ReloadReason;
+    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;
-    replaceBody(): void;
+    mergeHead(): Promise<void>;
+    replaceBody(): Promise<void>;
     get trackedElementsAreIdentical(): boolean;
-    copyNewHeadStylesheetElements(): void;
+    copyNewHeadStylesheetElements(): Promise<void>;
     copyNewHeadScriptElements(): void;
+    mergeProvisionalElements(): Promise<void>;
+    isCurrentElementInElementList(element: Element, elementList: Element[]): boolean;
     removeCurrentHeadProvisionalElements(): void;
     copyNewHeadProvisionalElements(): void;
     activateNewBody(): void;
     activateNewBodyScriptElements(): void;
-    assignNewBody(): void;
-    get newHeadStylesheetElements(): Element[];
-    get newHeadScriptElements(): Element[];
+    assignNewBody(): Promise<void>;
+    get newHeadStylesheetElements(): HTMLLinkElement[];
+    get newHeadScriptElements(): HTMLScriptElement[];
     get currentHeadProvisionalElements(): Element[];
     get newHeadProvisionalElements(): Element[];
     get newBodyScriptElements(): NodeListOf<HTMLScriptElement>;

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

@@ -1,21 +1,23 @@
-import { View, ViewDelegate } from "../view";
+import { View, ViewDelegate, ViewRenderOptions } from "../view";
 import { ErrorRenderer } from "./error_renderer";
 import { PageRenderer } from "./page_renderer";
 import { PageSnapshot } from "./page_snapshot";
 import { SnapshotCache } from "./snapshot_cache";
-export interface PageViewDelegate extends ViewDelegate<PageSnapshot> {
+import { Visit } from "./visit";
+export type PageViewRenderOptions = ViewRenderOptions<HTMLBodyElement>;
+export interface PageViewDelegate extends ViewDelegate<HTMLBodyElement, PageSnapshot> {
     viewWillCacheSnapshot(): void;
 }
-declare type PageViewRenderer = PageRenderer | ErrorRenderer;
-export declare class PageView extends View<Element, PageSnapshot, PageViewRenderer, PageViewDelegate> {
+type PageViewRenderer = PageRenderer | ErrorRenderer;
+export declare class PageView extends View<HTMLBodyElement, PageSnapshot, PageViewRenderer, PageViewDelegate> {
     readonly snapshotCache: SnapshotCache;
     lastRenderedLocation: URL;
-    renderPage(snapshot: PageSnapshot, isPreview?: boolean, willRender?: boolean): Promise<void>;
-    renderError(snapshot: PageSnapshot): Promise<void>;
+    forceReloaded: boolean;
+    renderPage(snapshot: PageSnapshot, isPreview?: boolean, willRender?: boolean, visit?: Visit): Promise<void>;
+    renderError(snapshot: PageSnapshot, visit?: Visit): Promise<void>;
     clearSnapshotCache(): void;
-    cacheSnapshot(): Promise<PageSnapshot | undefined>;
+    cacheSnapshot(snapshot?: PageSnapshot): Promise<PageSnapshot | undefined>;
     getCachedSnapshotForLocation(location: URL): PageSnapshot | undefined;
     get snapshot(): PageSnapshot;
-    get shouldCacheSnapshot(): boolean;
 }
 export {};

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

@@ -0,0 +1,14 @@
+import { Navigator } from "./navigator";
+import { SnapshotCache } from "./snapshot_cache";
+export interface PreloaderDelegate {
+    readonly navigator: Navigator;
+}
+export declare class Preloader {
+    readonly delegate: PreloaderDelegate;
+    readonly selector: string;
+    constructor(delegate: PreloaderDelegate);
+    get snapshotCache(): SnapshotCache;
+    start(): void;
+    preloadOnLoadLinksForView(element: Element): void;
+    preloadURL(link: HTMLAnchorElement): Promise<void>;
+}

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

@@ -21,4 +21,5 @@ export declare class ProgressBar {
     refresh(): void;
     createStylesheetElement(): HTMLStyleElement;
     createProgressElement(): HTMLDivElement;
+    get cspNonce(): string | null;
 }

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

@@ -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,16 +31,22 @@ export declare enum VisitState {
     failed = "failed",
     completed = "completed"
 }
-export declare type VisitOptions = {
+export type VisitOptions = {
     action: Action;
     historyChanged: boolean;
     referrer?: URL;
+    snapshot?: PageSnapshot;
     snapshotHTML?: string;
     response?: VisitResponse;
     visitCachedSnapshot(snapshot: Snapshot): void;
     willRender: boolean;
+    updateHistory: boolean;
+    restorationIdentifier?: string;
+    shouldCacheSnapshot: boolean;
+    frame?: string;
+    acceptsStreamResponse: boolean;
 };
-export declare type VisitResponse = {
+export type VisitResponse = {
     statusCode: number;
     redirected: boolean;
     responseHTML?: string;
@@ -59,6 +65,7 @@ export declare class Visit implements FetchRequestDelegate {
     readonly timingMetrics: TimingMetrics;
     readonly visitCachedSnapshot: (snapshot: Snapshot) => void;
     readonly willRender: boolean;
+    readonly updateHistory: boolean;
     followedRedirect: boolean;
     frame?: number;
     historyChanged: boolean;
@@ -68,9 +75,12 @@ export declare class Visit implements FetchRequestDelegate {
     request?: FetchRequest;
     response?: VisitResponse;
     scrolled: boolean;
+    shouldCacheSnapshot: boolean;
+    acceptsStreamResponse: boolean;
     snapshotHTML?: string;
     snapshotCached: boolean;
     state: VisitState;
+    snapshot?: PageSnapshot;
     constructor(delegate: VisitDelegate, location: URL, restorationIdentifier: string | undefined, options?: Partial<VisitOptions>);
     get adapter(): Adapter;
     get view(): PageView;
@@ -94,18 +104,19 @@ export declare class Visit implements FetchRequestDelegate {
     loadCachedSnapshot(): void;
     followRedirect(): void;
     goToSamePageAnchor(): void;
+    prepareRequest(request: FetchRequest): void;
     requestStarted(): void;
-    requestPreventedHandlingResponse(request: FetchRequest, response: FetchResponse): void;
+    requestPreventedHandlingResponse(_request: FetchRequest, _response: FetchResponse): void;
     requestSucceededWithResponse(request: FetchRequest, response: FetchResponse): Promise<void>;
     requestFailedWithResponse(request: FetchRequest, response: FetchResponse): Promise<void>;
-    requestErrored(request: FetchRequest, error: Error): void;
+    requestErrored(_request: FetchRequest, _error: Error): void;
     requestFinished(): void;
     performScroll(): void;
     scrollToRestoredPosition(): true | undefined;
     scrollToAnchor(): true | undefined;
     recordTimingMetric(metric: TimingMetric): void;
     getTimingMetrics(): TimingMetrics;
-    getHistoryMethodForAction(action: Action): (data: any, title: string, url?: string | null | undefined) => void;
+    getHistoryMethodForAction(action: Action): (data: any, unused: string, url?: string | URL | null | undefined) => void;
     hasPreloadedResponse(): boolean;
     shouldIssueRequest(): boolean;
     cacheSnapshot(): 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,70 +1,100 @@
 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";
 import { Snapshot } from "../snapshot";
-import { ViewDelegate } from "../view";
-import { FormInterceptor, FormInterceptorDelegate } from "./form_interceptor";
+import { ViewDelegate, ViewRenderOptions } from "../view";
+import { Locatable } from "../url";
+import { FormSubmitObserver, FormSubmitObserverDelegate } from "../../observers/form_submit_observer";
 import { FrameView } from "./frame_view";
 import { LinkInterceptor, LinkInterceptorDelegate } from "./link_interceptor";
-export declare class FrameController implements AppearanceObserverDelegate, FetchRequestDelegate, FormInterceptorDelegate, FormSubmissionDelegate, FrameElementDelegate, LinkInterceptorDelegate, ViewDelegate<Snapshot<FrameElement>> {
+import { FormLinkClickObserver, FormLinkClickObserverDelegate } from "../../observers/form_link_click_observer";
+import { VisitOptions } from "../drive/visit";
+type VisitFallback = (location: Response | Locatable, options: Partial<VisitOptions>) => Promise<void>;
+export type TurboFrameMissingEvent = CustomEvent<{
+    response: Response;
+    visit: VisitFallback;
+}>;
+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 formInterceptor: FormInterceptor;
-    currentURL?: string | null;
+    readonly formSubmitObserver: FormSubmitObserver;
     formSubmission?: FormSubmission;
-    fetchResponseLoaded: (fetchResponse: FetchResponse) => void;
+    fetchResponseLoaded: (_fetchResponse: FetchResponse) => void;
     private currentFetchRequest;
     private resolveVisitPromise;
     private connected;
     private hasBeenLoaded;
-    private settingSourceURL;
+    private ignoredAttributes;
+    private action;
+    readonly restorationIdentifier: string;
+    private previousFrameElement?;
+    private currentNavigationElement?;
     constructor(element: FrameElement);
     connect(): void;
     disconnect(): void;
     disabledChanged(): void;
     sourceURLChanged(): void;
+    sourceURLReloaded(): Promise<void>;
+    completeChanged(): void;
     loadingStyleChanged(): void;
-    loadSourceURL(): Promise<void>;
+    private loadSourceURL;
     loadResponse(fetchResponse: FetchResponse): Promise<void>;
-    elementAppearedInViewport(element: Element): 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;
-    requestStarted(request: FetchRequest): void;
-    requestPreventedHandlingResponse(request: FetchRequest, response: FetchResponse): 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;
+    prepareRequest(request: FetchRequest): void;
+    requestStarted(_request: FetchRequest): void;
+    requestPreventedHandlingResponse(_request: FetchRequest, _response: FetchResponse): void;
     requestSucceededWithResponse(request: FetchRequest, response: FetchResponse): Promise<void>;
-    requestFailedWithResponse(request: FetchRequest, response: FetchResponse): void;
+    requestFailedWithResponse(request: FetchRequest, response: FetchResponse): Promise<void>;
     requestErrored(request: FetchRequest, error: Error): void;
-    requestFinished(request: FetchRequest): void;
+    requestFinished(_request: FetchRequest): void;
     formSubmissionStarted({ formElement }: FormSubmission): void;
     formSubmissionSucceededWithResponse(formSubmission: FormSubmission, response: FetchResponse): void;
     formSubmissionFailedWithResponse(formSubmission: FormSubmission, fetchResponse: FetchResponse): void;
     formSubmissionErrored(formSubmission: FormSubmission, error: Error): void;
     formSubmissionFinished({ formElement }: FormSubmission): void;
-    allowsImmediateRender(snapshot: Snapshot, resume: (value: any) => void): boolean;
-    viewRenderedSnapshot(snapshot: Snapshot, isPreview: boolean): void;
+    allowsImmediateRender({ element: newFrame }: Snapshot<FrameElement>, options: ViewRenderOptions<FrameElement>): boolean;
+    viewRenderedSnapshot(_snapshot: Snapshot, _isPreview: boolean): void;
+    preloadOnLoadLinksForView(element: Element): void;
     viewInvalidated(): void;
+    willRenderFrame(currentElement: FrameElement, _newElement: FrameElement): void;
+    visitCachedSnapshot: ({ element }: Snapshot) => void;
+    private loadFrameResponse;
     private visit;
     private navigateFrame;
-    private proposeVisitIfNavigatedWithAction;
+    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>;
+    extractForeignFrameElement(container: ParentNode): Promise<FrameElement | null>;
     private formActionIsVisitable;
     private shouldInterceptNavigation;
     get id(): string;
     get enabled(): boolean;
     get sourceURL(): string | undefined;
-    get reloadable(): boolean;
-    set reloadable(value: boolean);
     set sourceURL(sourceURL: string | undefined);
     get loadingStyle(): FrameLoadingStyle;
     get isLoading(): boolean;
+    get complete(): boolean;
+    set complete(value: boolean);
     get isActive(): boolean;
     get rootLocation(): URL;
+    private isIgnoringChangesTo;
+    private ignoringChangesToAttribute;
+    private withCurrentNavigationElement;
 }
+export {};

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

@@ -1,16 +1,18 @@
-import { FormInterceptor, FormInterceptorDelegate } from "./form_interceptor";
+import { FormSubmitObserver, FormSubmitObserverDelegate } from "../../observers/form_submit_observer";
 import { LinkInterceptor, LinkInterceptorDelegate } from "./link_interceptor";
-export declare class FrameRedirector implements LinkInterceptorDelegate, FormInterceptorDelegate {
+import { Session } from "../session";
+export declare class FrameRedirector implements LinkInterceptorDelegate, FormSubmitObserverDelegate {
+    readonly session: Session;
     readonly element: Element;
     readonly linkInterceptor: LinkInterceptor;
-    readonly formInterceptor: FormInterceptor;
-    constructor(element: Element);
+    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;
+    shouldInterceptLinkClick(element: Element, _location: string, _event: MouseEvent): boolean;
+    linkClickIntercepted(element: Element, url: string, event: MouseEvent): 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

@@ -1,6 +1,13 @@
 import { FrameElement } from "../../elements/frame_element";
-import { Renderer } from "../renderer";
+import { Render, Renderer } from "../renderer";
+import { Snapshot } from "../snapshot";
+export interface FrameRendererDelegate {
+    willRenderFrame(currentElement: FrameElement, newElement: FrameElement): void;
+}
 export declare class FrameRenderer extends Renderer<FrameElement> {
+    private readonly delegate;
+    static renderElement(currentElement: FrameElement, newElement: FrameElement): void;
+    constructor(delegate: FrameRendererDelegate, currentSnapshot: Snapshot<FrameElement>, newSnapshot: Snapshot<FrameElement>, renderElement: Render<FrameElement>, isPreview: boolean, willRender?: boolean);
     get shouldRender(): boolean;
     render(): Promise<void>;
     loadFrameElement(): void;

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

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

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

@@ -1,6 +1,6 @@
 export interface LinkInterceptorDelegate {
-    shouldInterceptLinkClick(element: Element, url: string): boolean;
-    linkClickIntercepted(element: Element, url: string): void;
+    shouldInterceptLinkClick(element: Element, url: string, originalEvent: MouseEvent): boolean;
+    linkClickIntercepted(element: Element, url: string, originalEvent: MouseEvent): void;
 }
 export declare class LinkInterceptor {
     readonly delegate: LinkInterceptorDelegate;
@@ -11,6 +11,6 @@ export declare class LinkInterceptor {
     stop(): void;
     clickBubbled: (event: Event) => void;
     linkClicked: EventListener;
-    willVisit: () => void;
+    willVisit: EventListener;
     respondsToEventTarget(target: EventTarget | null): boolean | null;
 }

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

@@ -1,14 +1,22 @@
 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";
 import { StreamSource } from "./types";
 import { VisitOptions } from "./drive/visit";
 import { PageRenderer } from "./drive/page_renderer";
 import { PageSnapshot } from "./drive/page_snapshot";
+import { FrameRenderer } from "./frames/frame_renderer";
 declare const session: Session;
+declare const cache: Cache;
 declare const navigator: import("./drive/navigator").Navigator;
-export { navigator, session, PageRenderer, PageSnapshot };
+export { navigator, session, cache, PageRenderer, PageSnapshot, FrameRenderer };
+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;
@@ -17,4 +25,5 @@ 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) => boolean): void;
+export declare function setConfirmMethod(confirmMethod: (message: string, element: HTMLFormElement, submitter: HTMLElement | undefined) => Promise<boolean>): void;
+export declare function setFormMode(mode: FormMode): void;

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

@@ -1,5 +1,6 @@
 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;
     visitStarted(visit: Visit): void;
@@ -12,5 +13,5 @@ export interface Adapter {
     visitRendered(visit: Visit): void;
     formSubmissionStarted?(formSubmission: FormSubmission): void;
     formSubmissionFinished?(formSubmission: FormSubmission): void;
-    pageInvalidated(): void;
+    pageInvalidated(reason: ReloadReason): void;
 }