@hotwired/turbo 7.1.0 → 7.2.0

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 declare type FormMode = "on" | "off" | "optin";
+export declare type TimingData = unknown;
+export declare type TurboBeforeCacheEvent = CustomEvent;
+export declare type TurboBeforeRenderEvent = CustomEvent<{
+    newBody: HTMLBodyElement;
+} & PageViewRenderOptions>;
+export declare type TurboBeforeVisitEvent = CustomEvent<{
+    url: string;
+}>;
+export declare type TurboClickEvent = CustomEvent<{
+    url: string;
+    originalEvent: MouseEvent;
+}>;
+export declare type TurboFrameLoadEvent = CustomEvent;
+export declare type TurboBeforeFrameRenderEvent = CustomEvent<{
+    newFrame: FrameElement;
+} & FrameViewRenderOptions>;
+export declare type TurboFrameRenderEvent = CustomEvent<{
+    fetchResponse: FetchResponse;
+}>;
+export declare type TurboLoadEvent = CustomEvent<{
+    url: string;
+    timing: TimingData;
+}>;
+export declare type TurboRenderEvent = CustomEvent;
+export declare 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 function getPermanentElementById(node: ParentNode, id: string): Element | null;
+export declare function queryPermanentElementsAll(node: ParentNode): NodeListOf<Element>;
 export declare 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 declare type TurboStreamAction = (this: StreamElement) => void;
+export declare 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/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,33 @@
 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 interface FrameElementDelegate {
+export declare type FrameElementObservedAttribute = keyof FrameElement & ("disabled" | "complete" | "loading" | "src");
+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;
     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 @@
+declare type Render = (currentElement: StreamElement) => Promise<void>;
+export declare 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,5 +1,17 @@
 import { FetchResponse } from "./fetch_response";
 import { FrameElement } from "../elements/frame_element";
+export declare type TurboBeforeFetchRequestEvent = CustomEvent<{
+    fetchOptions: RequestInit;
+    url: URL;
+    resume: (value: any) => void;
+}>;
+export declare type TurboBeforeFetchResponseEvent = CustomEvent<{
+    fetchResponse: FetchResponse;
+}>;
+export declare type TurboFetchRequestErrorEvent = CustomEvent<{
+    request: FetchRequest;
+    error: Error;
+}>;
 export interface FetchRequestDelegate {
     referrer?: URL;
     prepareHeadersForRequest?(headers: FetchRequestHeaders, request: FetchRequest): void;
@@ -49,5 +61,7 @@ export declare class FetchRequest {
     };
     get isIdempotent(): boolean;
     get abortSignal(): AbortSignal;
+    acceptResponseType(mimeType: string): void;
     private allowRequestToBeIntercepted;
+    private willDelegateErrorHandling;
 }

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

@@ -0,0 +1 @@
+export { 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/cache_observer.d.ts

@@ -2,5 +2,5 @@ export declare class CacheObserver {
     started: boolean;
     start(): void;
     stop(): void;
-    removeStaleElements(): void;
+    removeStaleElements: EventListener;
 }

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

@@ -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 | null | undefined;
     getLocationForLink(link: Element): URL;
 }

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_custom_body_tests.d.ts

@@ -0,0 +1 @@
+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 {};

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

@@ -1,84 +1 @@
-import { TurboDriveTestCase } from "../helpers/turbo_drive_test_case";
-export declare class FormSubmissionTests extends TurboDriveTestCase {
-    setup(): Promise<void>;
-    "test standard form submission renders a progress bar"(): Promise<void>;
-    "test form submission with confirmation confirmed"(): Promise<void>;
-    "test form submission with confirmation cancelled"(): Promise<void>;
-    "test from submission with confirmation overriden"(): Promise<void>;
-    "test standard form submission does not render a progress bar before expiring the delay"(): Promise<void>;
-    "test standard form submission with redirect response"(): Promise<void>;
-    "test standard POST form submission events"(): Promise<void>;
-    "test standard POST form submission merges values from both searchParams and body"(): Promise<void>;
-    "test standard POST form submission toggles submitter [disabled] attribute"(): Promise<void>;
-    "test standard GET form submission"(): Promise<void>;
-    "test standard GET form submission events"(): Promise<void>;
-    "test standard GET form submission does not incorporate the current page's URLSearchParams values into the submission"(): Promise<void>;
-    "test standard GET form submission does not merge values into the [action] attribute"(): Promise<void>;
-    "test standard GET form submission omits the [action] value's URLSearchParams from the submission"(): Promise<void>;
-    "test standard GET form submission toggles submitter [disabled] attribute"(): Promise<void>;
-    "test standard GET form submission appending keys"(): Promise<void>;
-    "test standard form submission with empty created response"(): Promise<void>;
-    "test standard form submission with empty no-content response"(): Promise<void>;
-    "test standard POST form submission with multipart/form-data enctype"(): Promise<void>;
-    "test standard GET form submission ignores enctype"(): Promise<void>;
-    "test standard POST form submission without an enctype"(): Promise<void>;
-    "test no-action form submission with single parameter"(): Promise<void>;
-    "test no-action form submission with multiple parameters"(): Promise<void>;
-    "test no-action form submission submitter parameters"(): Promise<void>;
-    "test input named action with no action attribute"(): Promise<void>;
-    "test input named action with action attribute"(): Promise<void>;
-    "test invalid form submission with unprocessable entity status"(): Promise<void>;
-    "test invalid form submission with long form"(): Promise<void>;
-    "test invalid form submission with server error status"(): Promise<void>;
-    "test submitter form submission reads button attributes"(): Promise<void>;
-    "test submitter POST form submission with multipart/form-data formenctype"(): Promise<void>;
-    "test submitter GET submission from submitter with data-turbo-frame"(): Promise<void>;
-    "test submitter POST submission from submitter with data-turbo-frame"(): Promise<void>;
-    "test frame form GET submission from submitter with data-turbo-frame=_top"(): Promise<void>;
-    "test frame form POST submission from submitter with data-turbo-frame=_top"(): Promise<void>;
-    "test frame POST form targetting frame submission"(): Promise<void>;
-    "test frame POST form targetting frame toggles submitter's [disabled] attribute"(): Promise<void>;
-    "test frame GET form targetting frame submission"(): Promise<void>;
-    "test frame GET form targetting frame toggles submitter's [disabled] attribute"(): Promise<void>;
-    "test frame form GET submission from submitter referencing another frame"(): Promise<void>;
-    "test frame form POST submission from submitter referencing another frame"(): Promise<void>;
-    "test frame form submission with redirect response"(): Promise<void>;
-    "test frame form submission toggles the ancestor frame's [aria-busy] attribute"(): Promise<void>;
-    "test frame form submission toggles the target frame's [aria-busy] attribute"(): Promise<void>;
-    "test frame form submission with empty created response"(): Promise<void>;
-    "test frame form submission with empty no-content response"(): Promise<void>;
-    "test frame form submission within a frame submits the Turbo-Frame header"(): Promise<void>;
-    "test invalid frame form submission with unprocessable entity status"(): Promise<void>;
-    "test invalid frame form submission with internal server errror status"(): Promise<void>;
-    "test frame form submission with stream response"(): Promise<void>;
-    "test frame form submission with HTTP verb other than GET or POST"(): Promise<void>;
-    "test frame form submission with [data-turbo=false] on the form"(): Promise<void>;
-    "test frame form submission with [data-turbo=false] on the submitter"(): Promise<void>;
-    "test frame form submission ignores submissions with their defaultPrevented"(): Promise<void>;
-    "test form submission with [data-turbo=false] on the form"(): Promise<void>;
-    "test form submission with [data-turbo=false] on the submitter"(): Promise<void>;
-    "test form submission skipped within method=dialog"(): Promise<void>;
-    "test form submission skipped with submitter formmethod=dialog"(): Promise<void>;
-    "test form submission targetting frame skipped within method=dialog"(): Promise<void>;
-    "test form submission targetting frame skipped with submitter formmethod=dialog"(): Promise<void>;
-    "test form submission targets disabled frame"(): Promise<void>;
-    "test form submission targeting a frame submits the Turbo-Frame header"(): Promise<void>;
-    "test link method form submission inside frame"(): Promise<void>;
-    "test link method form submission inside frame with data-turbo-frame=_top"(): Promise<void>;
-    "test link method form submission inside frame with data-turbo-frame target"(): Promise<void>;
-    "test stream link method form submission inside frame"(): Promise<void>;
-    "test link method form submission within form inside frame"(): Promise<void>;
-    "test link method form submission inside frame with confirmation confirmed"(): Promise<void>;
-    "test link method form submission inside frame with confirmation cancelled"(): Promise<void>;
-    "test link method form submission outside frame"(): Promise<void>;
-    "test stream link method form submission outside frame"(): Promise<void>;
-    "test link method form submission within form outside frame"(): Promise<void>;
-    "test stream link method form submission within form outside frame"(): Promise<void>;
-    "test turbo:before-fetch-request fires on the form element"(): Promise<void>;
-    "test turbo:before-fetch-response fires on the form element"(): Promise<void>;
-    "test POST to external action ignored"(): Promise<void>;
-    "test POST to external action within frame ignored"(): Promise<void>;
-    "test POST to external action targetting frame ignored"(): Promise<void>;
-    get formSubmitStarted(): Promise<boolean>;
-    get formSubmitEnded(): Promise<boolean>;
-}
+export {};

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

@@ -1,7 +1 @@
-import { TurboDriveTestCase } from "../helpers/turbo_drive_test_case";
-export declare class FrameNavigationTests extends TurboDriveTestCase {
-    setup(): Promise<void>;
-    "test frame navigation with descendant link"(): Promise<void>;
-    "test frame navigation with self link"(): Promise<void>;
-    "test frame navigation with exterior link"(): Promise<void>;
-}
+export {};