@hotwired/turbo 7.1.0 → 7.3.0

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

@@ -3,29 +3,38 @@ import { ProgressBar } from "../drive/progress_bar";
 import { Visit, VisitOptions } from "../drive/visit";
 import { FormSubmission } from "../drive/form_submission";
 import { Session } from "../session";
+export type ReloadReason = StructuredReason | undefined;
+interface StructuredReason {
+    reason: string;
+    context?: {
+        [key: string]: any;
+    };
+}
 export declare class BrowserAdapter implements Adapter {
     readonly session: Session;
     readonly progressBar: ProgressBar;
     visitProgressBarTimeout?: number;
     formProgressBarTimeout?: number;
+    location?: URL;
     constructor(session: Session);
     visitProposedToLocation(location: URL, options?: Partial<VisitOptions>): void;
     visitStarted(visit: Visit): void;
     visitRequestStarted(visit: Visit): void;
     visitRequestCompleted(visit: Visit): void;
     visitRequestFailedWithStatusCode(visit: Visit, statusCode: number): void;
-    visitRequestFinished(visit: Visit): void;
-    visitCompleted(visit: Visit): void;
-    pageInvalidated(): void;
-    visitFailed(visit: Visit): void;
-    visitRendered(visit: Visit): void;
-    formSubmissionStarted(formSubmission: FormSubmission): void;
-    formSubmissionFinished(formSubmission: FormSubmission): void;
+    visitRequestFinished(_visit: Visit): void;
+    visitCompleted(_visit: Visit): void;
+    pageInvalidated(reason: ReloadReason): void;
+    visitFailed(_visit: Visit): void;
+    visitRendered(_visit: Visit): void;
+    formSubmissionStarted(_formSubmission: FormSubmission): void;
+    formSubmissionFinished(_formSubmission: FormSubmission): void;
     showVisitProgressBarAfterDelay(): void;
     hideVisitProgressBar(): void;
     showFormProgressBarAfterDelay(): void;
     hideFormProgressBar(): void;
     showProgressBar: () => void;
-    reload(): void;
+    reload(reason: ReloadReason): void;
     get navigator(): import("../drive/navigator").Navigator;
 }
+export {};

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

@@ -1,22 +1,28 @@
+import { BardoDelegate } from "./bardo";
 import { Snapshot } from "./snapshot";
-export declare abstract class Renderer<E extends Element, S extends Snapshot<E> = Snapshot<E>> {
+import { ReloadReason } from "./native/browser_adapter";
+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;
     readonly isPreview: boolean;
     readonly willRender: boolean;
     readonly promise: Promise<void>;
+    renderElement: Render<E>;
     private resolvingFunctions?;
-    constructor(currentSnapshot: S, newSnapshot: S, isPreview: boolean, willRender?: boolean);
+    private activeElement;
+    constructor(currentSnapshot: S, newSnapshot: S, renderElement: Render<E>, isPreview: boolean, willRender?: boolean);
     get shouldRender(): boolean;
+    get reloadReason(): ReloadReason;
     prepareToRender(): void;
     abstract render(): Promise<void>;
     finishRendering(): void;
-    createScriptElement(element: Element): Element;
-    preservingPermanentElements(callback: () => void): void;
+    preservingPermanentElements(callback: () => void): Promise<void>;
     focusFirstAutofocusableElement(): void;
+    enteringBardo(currentPermanentElement: Element): void;
+    leavingBardo(currentPermanentElement: Element): void;
     get connectedSnapshot(): S;
     get currentElement(): E;
     get newElement(): E;
-    get permanentElementMap(): Record<string, [Element, Element]>;
-    get cspNonce(): string | null | undefined;
+    get permanentElementMap(): import("./snapshot").PermanentElementMap;
 }

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

@@ -1,25 +1,59 @@
 import { Adapter } from "./native/adapter";
+import { ReloadReason } from "./native/browser_adapter";
 import { CacheObserver } from "../observers/cache_observer";
 import { FormSubmitObserver, FormSubmitObserverDelegate } from "../observers/form_submit_observer";
 import { FrameRedirector } from "./frames/frame_redirector";
 import { History, HistoryDelegate } from "./drive/history";
 import { LinkClickObserver, LinkClickObserverDelegate } from "../observers/link_click_observer";
+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";
 import { ScrollObserver } from "../observers/scroll_observer";
 import { StreamMessage } from "./streams/stream_message";
+import { StreamMessageRenderer } from "./streams/stream_message_renderer";
 import { StreamObserver } from "../observers/stream_observer";
 import { Action, Position, StreamSource } from "./types";
-import { PageView, PageViewDelegate } from "./drive/page_view";
+import { PageView, PageViewDelegate, PageViewRenderOptions } from "./drive/page_view";
 import { Visit, VisitOptions } from "./drive/visit";
 import { PageSnapshot } from "./drive/page_snapshot";
 import { FrameElement } from "../elements/frame_element";
+import { FrameViewRenderOptions } from "./frames/frame_view";
 import { FetchResponse } from "../http/fetch_response";
-export declare type TimingData = {};
-export declare class Session implements FormSubmitObserverDelegate, HistoryDelegate, LinkClickObserverDelegate, NavigatorDelegate, PageObserverDelegate, PageViewDelegate {
+import { Preloader, PreloaderDelegate } from "./drive/preloader";
+export type FormMode = "on" | "off" | "optin";
+export type TimingData = unknown;
+export type TurboBeforeCacheEvent = CustomEvent;
+export type TurboBeforeRenderEvent = CustomEvent<{
+    newBody: HTMLBodyElement;
+} & PageViewRenderOptions>;
+export type TurboBeforeVisitEvent = CustomEvent<{
+    url: string;
+}>;
+export type TurboClickEvent = CustomEvent<{
+    url: string;
+    originalEvent: MouseEvent;
+}>;
+export type TurboFrameLoadEvent = CustomEvent;
+export type TurboBeforeFrameRenderEvent = CustomEvent<{
+    newFrame: FrameElement;
+} & FrameViewRenderOptions>;
+export type TurboFrameRenderEvent = CustomEvent<{
+    fetchResponse: FetchResponse;
+}>;
+export type TurboLoadEvent = CustomEvent<{
+    url: string;
+    timing: TimingData;
+}>;
+export type TurboRenderEvent = CustomEvent;
+export type TurboVisitEvent = CustomEvent<{
+    url: string;
+    action: Action;
+}>;
+export declare class Session implements FormSubmitObserverDelegate, HistoryDelegate, FormLinkClickObserverDelegate, LinkClickObserverDelegate, NavigatorDelegate, PageObserverDelegate, PageViewDelegate, PreloaderDelegate {
     readonly navigator: Navigator;
     readonly history: History;
+    readonly preloader: Preloader;
     readonly view: PageView;
     adapter: Adapter;
     readonly pageObserver: PageObserver;
@@ -28,11 +62,14 @@ export declare class Session implements FormSubmitObserverDelegate, HistoryDeleg
     readonly formSubmitObserver: FormSubmitObserver;
     readonly scrollObserver: ScrollObserver;
     readonly streamObserver: StreamObserver;
+    readonly formLinkClickObserver: FormLinkClickObserver;
     readonly frameRedirector: FrameRedirector;
+    readonly streamMessageRenderer: StreamMessageRenderer;
     drive: boolean;
     enabled: boolean;
     progressBarDelay: number;
     started: boolean;
+    formMode: FormMode;
     start(): void;
     disable(): void;
     stop(): void;
@@ -43,13 +80,15 @@ export declare class Session implements FormSubmitObserverDelegate, HistoryDeleg
     renderStreamMessage(message: StreamMessage | string): void;
     clearCache(): void;
     setProgressBarDelay(delay: number): void;
+    setFormMode(mode: FormMode): void;
     get location(): URL;
     get restorationIdentifier(): string;
     historyPoppedToLocationWithRestorationIdentifier(location: URL, restorationIdentifier: string): void;
     scrollPositionChanged(position: Position): void;
-    willFollowLinkToLocation(link: Element, location: URL): boolean;
+    willSubmitFormLinkToLocation(link: Element, location: URL): boolean;
+    submittedFormLinkToLocation(): void;
+    willFollowLinkToLocation(link: Element, location: URL, event: MouseEvent): boolean;
     followedLinkToLocation(link: Element, location: URL): void;
-    convertLinkWithMethodClickToFormSubmission(link: Element): false | CustomEvent<any>;
     allowsVisitingLocationWithAction(location: URL, action?: Action): boolean;
     visitProposedToLocation(location: URL, options: Partial<VisitOptions>): void;
     visitStarted(visit: Visit): void;
@@ -63,25 +102,41 @@ export declare class Session implements FormSubmitObserverDelegate, HistoryDeleg
     pageWillUnload(): void;
     receivedMessageFromStream(message: StreamMessage): void;
     viewWillCacheSnapshot(): void;
-    allowsImmediateRender({ element }: PageSnapshot, resume: (value: any) => void): boolean;
-    viewRenderedSnapshot(snapshot: PageSnapshot, isPreview: boolean): void;
-    viewInvalidated(): void;
+    allowsImmediateRender({ element }: PageSnapshot, options: PageViewRenderOptions): boolean;
+    viewRenderedSnapshot(_snapshot: PageSnapshot, _isPreview: boolean): void;
+    preloadOnLoadLinksForView(element: Element): void;
+    viewInvalidated(reason: ReloadReason): void;
     frameLoaded(frame: FrameElement): void;
     frameRendered(fetchResponse: FetchResponse, frame: FrameElement): void;
-    applicationAllowsFollowingLinkToLocation(link: Element, location: URL): boolean;
+    applicationAllowsFollowingLinkToLocation(link: Element, location: URL, ev: MouseEvent): boolean;
     applicationAllowsVisitingLocation(location: URL): boolean;
-    notifyApplicationAfterClickingLinkToLocation(link: Element, location: URL): CustomEvent<any>;
-    notifyApplicationBeforeVisitingLocation(location: URL): CustomEvent<any>;
-    notifyApplicationAfterVisitingLocation(location: URL, action: Action): CustomEvent<any>;
+    notifyApplicationAfterClickingLinkToLocation(link: Element, location: URL, event: MouseEvent): CustomEvent<{
+        url: string;
+        originalEvent: MouseEvent;
+    }>;
+    notifyApplicationBeforeVisitingLocation(location: URL): CustomEvent<{
+        url: string;
+    }>;
+    notifyApplicationAfterVisitingLocation(location: URL, action: Action): CustomEvent<{
+        url: string;
+        action: Action;
+    }>;
     notifyApplicationBeforeCachingSnapshot(): CustomEvent<any>;
-    notifyApplicationBeforeRender(newBody: HTMLBodyElement, resume: (value: any) => void): CustomEvent<any>;
+    notifyApplicationBeforeRender(newBody: HTMLBodyElement, options: PageViewRenderOptions): CustomEvent<{
+        newBody: HTMLBodyElement;
+    } & PageViewRenderOptions>;
     notifyApplicationAfterRender(): CustomEvent<any>;
-    notifyApplicationAfterPageLoad(timing?: TimingData): CustomEvent<any>;
+    notifyApplicationAfterPageLoad(timing?: TimingData): CustomEvent<{
+        url: string;
+        timing: unknown;
+    }>;
     notifyApplicationAfterVisitingSamePageLocation(oldURL: URL, newURL: URL): void;
     notifyApplicationAfterFrameLoad(frame: FrameElement): CustomEvent<any>;
-    notifyApplicationAfterFrameRender(fetchResponse: FetchResponse, frame: FrameElement): CustomEvent<any>;
-    elementDriveEnabled(element?: Element): boolean;
+    notifyApplicationAfterFrameRender(fetchResponse: FetchResponse, frame: FrameElement): CustomEvent<{
+        fetchResponse: FetchResponse;
+    }>;
+    submissionIsNavigatable(form: HTMLFormElement, submitter?: HTMLElement): boolean;
+    elementIsNavigatable(element: Element): boolean;
     getActionForLink(link: Element): Action;
-    getTargetFrameForLink(link: Element): string | undefined;
     get snapshot(): PageSnapshot;
 }

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

@@ -1,13 +1,16 @@
 export declare class Snapshot<E extends Element = Element> {
     readonly element: E;
     constructor(element: E);
+    get activeElement(): Element | null;
     get children(): Element[];
     hasAnchor(anchor: string | undefined): boolean;
     getElementForAnchor(anchor: string | undefined): Element | null;
     get isConnected(): boolean;
     get firstAutofocusableElement(): Element | null;
-    get permanentElements(): Element[];
+    get permanentElements(): NodeListOf<Element>;
     getPermanentElementById(id: string): Element | null;
-    getPermanentElementMapForSnapshot(snapshot: Snapshot): Record<string, [Element, Element]>;
+    getPermanentElementMapForSnapshot(snapshot: Snapshot): PermanentElementMap;
 }
-export declare type PermanentElementMap = Record<string, [Element, Element]>;
+export declare function getPermanentElementById(node: ParentNode, id: string): Element | null;
+export declare function queryPermanentElementsAll(node: ParentNode): NodeListOf<Element>;
+export type PermanentElementMap = Record<string, [Element, Element]>;

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

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

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/streams/stream_message_renderer.d.ts

@@ -0,0 +1,7 @@
+import { StreamMessage } from "./stream_message";
+import { BardoDelegate } from "../bardo";
+export declare class StreamMessageRenderer implements BardoDelegate {
+    render({ fragment }: StreamMessage): void;
+    enteringBardo(currentPermanentElement: Element, newPermanentElement: Element): void;
+    leavingBardo(): void;
+}

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

@@ -1,12 +1,18 @@
-import { Renderer } from "./renderer";
+import { ReloadReason } from "./native/browser_adapter";
+import { Renderer, Render } from "./renderer";
 import { Snapshot } from "./snapshot";
 import { Position } from "./types";
-export interface ViewDelegate<S extends Snapshot> {
-    allowsImmediateRender(snapshot: S, resume: (value: any) => void): boolean;
+export interface ViewRenderOptions<E> {
+    resume: (value?: any) => void;
+    render: Render<E>;
+}
+export interface ViewDelegate<E extends Element, S extends Snapshot<E>> {
+    allowsImmediateRender(snapshot: S, options: ViewRenderOptions<E>): boolean;
+    preloadOnLoadLinksForView(element: Element): void;
     viewRenderedSnapshot(snapshot: S, isPreview: boolean): void;
-    viewInvalidated(): void;
+    viewInvalidated(reason: ReloadReason): void;
 }
-export declare abstract class View<E extends Element, S extends Snapshot<E> = Snapshot<E>, R extends Renderer<E, S> = Renderer<E, S>, D extends ViewDelegate<S> = ViewDelegate<S>> {
+export declare abstract class View<E extends Element, S extends Snapshot<E> = Snapshot<E>, R extends Renderer<E, S> = Renderer<E, S>, D extends ViewDelegate<E, S> = ViewDelegate<E, S>> {
     readonly delegate: D;
     readonly element: E;
     renderer?: R;
@@ -25,8 +31,8 @@ export declare abstract class View<E extends Element, S extends Snapshot<E> = Sn
         scrollTo(x: number, y: number): void;
     };
     render(renderer: R): Promise<void>;
-    invalidate(): void;
-    prepareToRenderSnapshot(renderer: R): void;
+    invalidate(reason: ReloadReason): 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,29 +1,35 @@
 import { FetchResponse } from "../http/fetch_response";
+import { Snapshot } from "../core/snapshot";
+import { LinkInterceptorDelegate } from "../core/frames/link_interceptor";
+import { FormSubmitObserverDelegate } from "../observers/form_submit_observer";
 export declare enum FrameLoadingStyle {
     eager = "eager",
     lazy = "lazy"
 }
-export interface FrameElementDelegate {
+export type FrameElementObservedAttribute = keyof FrameElement & ("disabled" | "complete" | "loading" | "src");
+export interface FrameElementDelegate extends LinkInterceptorDelegate, FormSubmitObserverDelegate {
     connect(): void;
     disconnect(): void;
+    completeChanged(): void;
     loadingStyleChanged(): void;
     sourceURLChanged(): void;
+    sourceURLReloaded(): Promise<void>;
     disabledChanged(): void;
-    formSubmissionIntercepted(element: HTMLFormElement, submitter?: HTMLElement): void;
-    linkClickIntercepted(element: Element, url: string): void;
     loadResponse(response: FetchResponse): void;
+    proposeVisitIfNavigatedWithAction(frame: FrameElement, element: Element, submitter?: HTMLElement): void;
     fetchResponseLoaded: (fetchResponse: FetchResponse) => void;
+    visitCachedSnapshot: (snapshot: Snapshot) => void;
     isLoading: boolean;
 }
 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(): string[];
+    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/index.d.ts

@@ -1,2 +1,3 @@
 export * from "./frame_element";
 export * from "./stream_element";
+export * from "./stream_source_element";

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

@@ -1,11 +1,17 @@
+type Render = (currentElement: StreamElement) => Promise<void>;
+export type TurboBeforeStreamRenderEvent = CustomEvent<{
+    newStream: StreamElement;
+    render: Render;
+}>;
 export declare class StreamElement extends HTMLElement {
+    static renderElement(newElement: StreamElement): Promise<void>;
     connectedCallback(): Promise<void>;
     private renderPromise?;
     render(): Promise<void>;
     disconnect(): void;
     removeDuplicateTargetChildren(): void;
     get duplicateChildren(): any[];
-    get performAction(): (this: StreamElement) => void;
+    get performAction(): import("../core/streams/stream_actions").TurboStreamAction;
     get targetElements(): any[];
     get templateContent(): DocumentFragment;
     get templateElement(): HTMLTemplateElement;
@@ -18,3 +24,4 @@ export declare class StreamElement extends HTMLElement {
     private get targetElementsById();
     private get targetElementsByQuery();
 }
+export {};

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

@@ -0,0 +1,7 @@
+import { StreamSource } from "../core/types";
+export declare class StreamSourceElement extends HTMLElement {
+    streamSource: StreamSource | null;
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    get src(): string;
+}

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

@@ -1,8 +1,20 @@
 import { FetchResponse } from "./fetch_response";
 import { FrameElement } from "../elements/frame_element";
+export type TurboBeforeFetchRequestEvent = CustomEvent<{
+    fetchOptions: RequestInit;
+    url: URL;
+    resume: (value?: any) => void;
+}>;
+export type TurboBeforeFetchResponseEvent = CustomEvent<{
+    fetchResponse: FetchResponse;
+}>;
+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;
@@ -18,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 {
@@ -47,7 +59,9 @@ export declare class FetchRequest {
     get defaultHeaders(): {
         Accept: string;
     };
-    get isIdempotent(): boolean;
+    get isSafe(): boolean;
     get abortSignal(): AbortSignal;
+    acceptResponseType(mimeType: string): void;
     private allowRequestToBeIntercepted;
+    private willDelegateErrorHandling;
 }

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

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

package/dist/types/index.d.ts

@@ -2,3 +2,5 @@ import "./polyfills";
 import "./elements";
 import "./script_warning";
 export * from "./core";
+export * from "./elements";
+export * from "./http";

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(): void;
+    removeTemporaryElements: EventListener;
+    get temporaryElements(): Element[];
+    get temporaryElementsWithDeprecation(): Element[];
 }

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

@@ -0,0 +1,14 @@
+import { LinkClickObserver, LinkClickObserverDelegate } from "./link_click_observer";
+export 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 linkInterceptor: 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

@@ -1,16 +1,17 @@
 export interface LinkClickObserverDelegate {
-    willFollowLinkToLocation(link: Element, location: URL): boolean;
+    willFollowLinkToLocation(link: Element, location: URL, event: MouseEvent): boolean;
     followedLinkToLocation(link: Element, location: URL): void;
 }
 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): Element | 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/polyfills/submit-event.d.ts

@@ -1,7 +1 @@
-declare type FormSubmitter = HTMLElement & {
-    form?: HTMLFormElement;
-    type?: string;
-};
-declare const submittersByForm: WeakMap<HTMLFormElement, HTMLElement>;
-declare function findSubmitterFromClickTarget(target: EventTarget | null): FormSubmitter | null;
-declare function clickCaptured(event: Event): void;
+export {};

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

@@ -1,6 +1 @@
-import { TurboDriveTestCase } from "../helpers/turbo_drive_test_case";
-export declare class AsyncScriptTests extends TurboDriveTestCase {
-    setup(): Promise<void>;
-    "test does not emit turbo:load when loaded asynchronously after DOMContentLoaded"(): Promise<void>;
-    "test following a link when loaded asynchronously after DOMContentLoaded"(): Promise<void>;
-}
+export {};

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

@@ -1,9 +1 @@
-import { TurboDriveTestCase } from "../helpers/turbo_drive_test_case";
-export declare class AutofocusTests extends TurboDriveTestCase {
-    setup(): Promise<void>;
-    "test autofocus first autofocus element on load"(): Promise<void>;
-    "test autofocus first [autofocus] element on visit"(): Promise<void>;
-    "test navigating a frame with a descendant link autofocuses [autofocus]:first-of-type"(): Promise<void>;
-    "test navigating a frame with a link targeting the frame autofocuses [autofocus]:first-of-type"(): Promise<void>;
-    "test navigating a frame with a turbo-frame targeting the frame autofocuses [autofocus]:first-of-type"(): Promise<void>;
-}
+export {};

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

@@ -1,5 +1 @@
-import { TurboDriveTestCase } from "../helpers/turbo_drive_test_case";
-export declare class CacheObserverTests extends TurboDriveTestCase {
-    setup(): Promise<void>;
-    "test removes stale elements"(): Promise<void>;
-}
+export {};

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

@@ -1,9 +1 @@
-import { TurboDriveTestCase } from "../helpers/turbo_drive_test_case";
-export declare class DriveDisabledTests extends TurboDriveTestCase {
-    path: string;
-    setup(): Promise<void>;
-    "test drive disabled by default; click normal link"(): Promise<void>;
-    "test drive disabled by default; click link inside data-turbo='true'"(): Promise<void>;
-    "test drive disabled by default; submit form inside data-turbo='true'"(): Promise<void>;
-    get formSubmitted(): Promise<boolean>;
-}
+export {};

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

@@ -1,8 +1 @@
-import { TurboDriveTestCase } from "../helpers/turbo_drive_test_case";
-export declare class DriveTests extends TurboDriveTestCase {
-    path: string;
-    setup(): Promise<void>;
-    "test drive enabled by default; click normal link"(): Promise<void>;
-    "test drive to external link"(): Promise<void>;
-    "test drive enabled by default; click link inside data-turbo='false'"(): Promise<void>;
-}
+export {};

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

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