@hotwired/turbo 7.1.0-rc.3 → 7.2.0-beta.2

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

@@ -1,9 +1,11 @@
 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";
@@ -11,15 +13,51 @@ import { ScrollObserver } from "../observers/scroll_observer";
 import { StreamMessage } from "./streams/stream_message";
 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";
+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<{
+    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 TurboFetchRequestErrorEvent = CustomEvent<{
+    request: FetchRequest;
+    error: Error;
+}>;
+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,30 +66,34 @@ export declare class Session implements FormSubmitObserverDelegate, HistoryDeleg
     readonly formSubmitObserver: FormSubmitObserver;
     readonly scrollObserver: ScrollObserver;
     readonly streamObserver: StreamObserver;
+    readonly formLinkClickObserver: FormLinkClickObserver;
     readonly frameRedirector: FrameRedirector;
     drive: boolean;
     enabled: boolean;
     progressBarDelay: number;
     started: boolean;
+    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: 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;
+    visitProposedToLocation(location: URL, options: Partial<VisitOptions>): Promise<void>;
     visitStarted(visit: Visit): void;
     visitCompleted(visit: Visit): void;
     locationWithActionIsSamePage(location: URL, action?: Action): boolean;
@@ -63,25 +105,42 @@ 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;
+    frameMissing(frame: FrameElement, fetchResponse: FetchResponse): Promise<void>;
+    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,6 +1,7 @@
 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;
@@ -8,6 +9,6 @@ export declare class Snapshot<E extends Element = Element> {
     get firstAutofocusableElement(): Element | null;
     get permanentElements(): 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]>;

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

@@ -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/stream_element.d.ts

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

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,13 @@
 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 interface FetchRequestDelegate {
     referrer?: URL;
     prepareHeadersForRequest?(headers: FetchRequestHeaders, request: FetchRequest): void;
@@ -49,5 +57,6 @@ export declare class FetchRequest {
     };
     get isIdempotent(): boolean;
     get abortSignal(): AbortSignal;
+    acceptResponseType(mimeType: string): void;
     private allowRequestToBeIntercepted;
 }

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_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 {};

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

@@ -1,56 +1,6 @@
-import { TurboDriveTestCase } from "../helpers/turbo_drive_test_case";
-export declare class FrameTests extends TurboDriveTestCase {
-    setup(): Promise<void>;
-    "test navigating a frame a second time does not leak event listeners"(): Promise<void>;
-    "test following a link preserves the current <turbo-frame> element's attributes"(): Promise<void>;
-    "test a frame whose src references itself does not infinitely loop"(): Promise<void>;
-    "test following a link driving a frame toggles the [aria-busy=true] attribute"(): Promise<void>;
-    "test following a link to a page without a matching frame results in an empty frame"(): Promise<void>;
-    "test following a link within a frame with a target set navigates the target frame"(): Promise<void>;
-    "test following a link in rapid succession cancels the previous request"(): Promise<void>;
-    "test following a link within a descendant frame whose ancestor declares a target set navigates the descendant frame"(): Promise<void>;
-    "test following a link that declares data-turbo-frame within a frame whose ancestor respects the override"(): Promise<void>;
-    "test following a form within a nested frame with form target top"(): Promise<void>;
-    "test following a form within a nested frame with child frame target top"(): Promise<void>;
-    "test following a link within a frame with target=_top navigates the page"(): Promise<void>;
-    "test following a link that declares data-turbo-frame='_self' within a frame with target=_top navigates the frame itself"(): Promise<void>;
-    "test following a link to a page with a <turbo-frame recurse> which lazily loads a matching frame"(): Promise<void>;
-    "test submitting a form that redirects to a page with a <turbo-frame recurse> which lazily loads a matching frame"(): Promise<void>;
-    "test removing [disabled] attribute from eager-loaded frame navigates it"(): Promise<void>;
-    "test evaluates frame script elements on each render"(): Promise<void>;
-    "test does not evaluate data-turbo-eval=false scripts"(): Promise<void>;
-    "test redirecting in a form is still navigatable after redirect"(): Promise<void>;
-    "test 'turbo:frame-render' is triggered after frame has finished rendering"(): Promise<void>;
-    "test navigating a frame fires events"(): Promise<void>;
-    "test following inner link reloads frame on every click"(): Promise<void>;
-    "test following outer link reloads frame on every click"(): Promise<void>;
-    "test following outer form reloads frame on every submit"(): Promise<void>;
-    "test an inner/outer link reloads frame on every click"(): Promise<void>;
-    "test an inner/outer form reloads frame on every submit"(): Promise<void>;
-    "test reconnecting after following a link does not reload the frame"(): Promise<void>;
-    "test navigating pushing URL state from a frame navigation fires events"(): Promise<void>;
-    "test navigating a frame with a form[method=get] that does not redirect still updates the [src]"(): Promise<void>;
-    "test navigating turbo-frame[data-turbo-action=advance] from within pushes URL state"(): Promise<void>;
-    "test navigating turbo-frame[data-turbo-action=advance] to the same URL clears the [aria-busy] and [data-turbo-preview] state"(): Promise<void>;
-    "test navigating a turbo-frame with an a[data-turbo-action=advance] preserves page state"(): Promise<void>;
-    "test a turbo-frame that has been driven by a[data-turbo-action] can be navigated normally"(): Promise<void>;
-    "test navigating turbo-frame from within with a[data-turbo-action=advance] pushes URL state"(): Promise<void>;
-    "test navigating frame with a[data-turbo-action=advance] pushes URL state"(): Promise<void>;
-    "test navigating frame with form[method=get][data-turbo-action=advance] pushes URL state"(): Promise<void>;
-    "test navigating frame with form[method=get][data-turbo-action=advance] to the same URL clears the [aria-busy] and [data-turbo-preview] state"(): Promise<void>;
-    "test navigating frame with form[method=post][data-turbo-action=advance] pushes URL state"(): Promise<void>;
-    "test navigating frame with form[method=post][data-turbo-action=advance] to the same URL clears the [aria-busy] and [data-turbo-preview] state"(): Promise<void>;
-    "test navigating frame with button[data-turbo-action=advance] pushes URL state"(): Promise<void>;
-    "test navigating back after pushing URL state from a turbo-frame[data-turbo-action=advance] restores the frames previous contents"(): Promise<void>;
-    "test navigating back then forward after pushing URL state from a turbo-frame[data-turbo-action=advance] restores the frames next contents"(): Promise<void>;
-    "test turbo:before-fetch-request fires on the frame element"(): Promise<void>;
-    "test turbo:before-fetch-response fires on the frame element"(): Promise<void>;
-    withoutChangingEventListenersCount(callback: () => void): Promise<void>;
-    fillInSelector(selector: string, value: string): Promise<void>;
-    get frameScriptEvaluationCount(): Promise<number | undefined>;
-}
 declare global {
     interface Window {
         frameScriptEvaluationCount?: number;
     }
 }
+export {};

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

@@ -1,4 +1 @@
-import { TurboDriveTestCase } from "../helpers/turbo_drive_test_case";
-export declare class ImportTests extends TurboDriveTestCase {
-    "test window variable with ESM"(): Promise<void>;
-}
+export {};

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

@@ -1,18 +1,6 @@
-import { TurboDriveTestCase } from "../helpers/turbo_drive_test_case";
 declare global {
     interface Window {
         savedElement: Element | null;
     }
 }
-export declare class LoadingTests extends TurboDriveTestCase {
-    setup(): Promise<void>;
-    "test eager loading within a details element"(): Promise<void>;
-    "test lazy loading within a details element"(): Promise<void>;
-    "test changing loading attribute from lazy to eager loads frame"(): Promise<void>;
-    "test navigating a visible frame with loading=lazy navigates"(): Promise<void>;
-    "test changing src attribute on a frame with loading=lazy defers navigation"(): Promise<void>;
-    "test changing src attribute on a frame with loading=eager navigates"(): Promise<void>;
-    "test reloading a frame reloads the content"(): Promise<void>;
-    "test navigating away from a page does not reload its frames"(): Promise<void>;
-    "test disconnecting and reconnecting a frame does not reload the frame"(): Promise<void>;
-}
+export {};