@hotwired/turbo 7.1.0 → 7.2.0-beta.1

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,7 +31,7 @@ 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;
+    invalidate(reason: ReloadReason): void;
     prepareToRenderSnapshot(renderer: R): void;
     markAsPreview(isPreview: boolean): void;
     renderSnapshot(renderer: R): Promise<void>;

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

@@ -1,11 +1,14 @@
 import { FetchResponse } from "../http/fetch_response";
+import { Snapshot } from "../core/snapshot";
 export declare enum FrameLoadingStyle {
     eager = "eager",
     lazy = "lazy"
 }
+export declare type FrameElementObservedAttribute = keyof FrameElement & ("disabled" | "complete" | "loading" | "src");
 export interface FrameElementDelegate {
     connect(): void;
     disconnect(): void;
+    completeChanged(): void;
     loadingStyleChanged(): void;
     sourceURLChanged(): void;
     disabledChanged(): void;
@@ -13,13 +16,14 @@ export interface FrameElementDelegate {
     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>;
     readonly delegate: FrameElementDelegate;
-    static get observedAttributes(): string[];
+    static get observedAttributes(): FrameElementObservedAttribute[];
     constructor();
     connectedCallback(): void;
     disconnectedCallback(): void;

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

@@ -1,3 +1,4 @@
+export declare type TurboBeforeStreamRenderEvent = CustomEvent;
 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;

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

@@ -0,0 +1,14 @@
+import { LinkInterceptor, LinkInterceptorDelegate } from "../core/frames/link_interceptor";
+export declare type FormLinkInterceptorDelegate = {
+    shouldInterceptFormLinkClick(link: Element): boolean;
+    formLinkClickIntercepted(link: Element, form: HTMLFormElement): void;
+};
+export declare class FormLinkInterceptor implements LinkInterceptorDelegate {
+    readonly linkInterceptor: LinkInterceptor;
+    readonly delegate: FormLinkInterceptorDelegate;
+    constructor(delegate: FormLinkInterceptorDelegate, element: HTMLElement);
+    start(): void;
+    stop(): void;
+    shouldInterceptLinkClick(link: Element): boolean;
+    linkClickIntercepted(link: Element, action: string): void;
+}

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

@@ -1,5 +1,5 @@
 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 {
@@ -11,6 +11,6 @@ export declare class LinkClickObserver {
     clickCaptured: () => void;
     clickBubbled: (event: MouseEvent) => 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_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,57 +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 following a link sets the frame element's [src]"(): 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 {};

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

@@ -1,38 +1 @@
-import { TurboDriveTestCase } from "../helpers/turbo_drive_test_case";
-export declare class NavigationTests extends TurboDriveTestCase {
-    setup(): Promise<void>;
-    "test navigating renders a progress bar"(): Promise<void>;
-    "test navigating does not render a progress bar before expiring the delay"(): Promise<void>;
-    "test after loading the page"(): Promise<void>;
-    "test following a same-origin unannotated link"(): Promise<void>;
-    "test following a same-origin unannotated custom element link"(): Promise<void>;
-    "test following a same-origin unannotated link with search params"(): Promise<void>;
-    "test following a same-origin unannotated form[method=GET]"(): Promise<void>;
-    "test following a same-origin data-turbo-action=replace link"(): Promise<void>;
-    "test following a same-origin GET form[data-turbo-action=replace]"(): Promise<void>;
-    "test following a same-origin GET form button[data-turbo-action=replace]"(): Promise<void>;
-    "test following a same-origin POST form[data-turbo-action=replace]"(): Promise<void>;
-    "test following a same-origin POST form button[data-turbo-action=replace]"(): Promise<void>;
-    "test following a same-origin data-turbo=false link"(): Promise<void>;
-    "test following a same-origin unannotated link inside a data-turbo=false container"(): Promise<void>;
-    "test following a same-origin data-turbo=true link inside a data-turbo=false container"(): Promise<void>;
-    "test following a same-origin anchored link"(): Promise<void>;
-    "test following a same-origin link to a named anchor"(): Promise<void>;
-    "test following a cross-origin unannotated link"(): Promise<void>;
-    "test following a same-origin [target] link"(): Promise<void>;
-    "test following a same-origin [download] link"(): Promise<void>;
-    "test following a same-origin link inside an SVG element"(): Promise<void>;
-    "test following a cross-origin link inside an SVG element"(): Promise<void>;
-    "test clicking the back button"(): Promise<void>;
-    "test clicking the forward button"(): Promise<void>;
-    "test link targeting a disabled turbo-frame navigates the page"(): Promise<void>;
-    "test skip link with hash-only path scrolls to the anchor without a visit"(): Promise<void>;
-    "test skip link with hash-only path moves focus and changes tab order"(): Promise<void>;
-    "test same-page anchored replace link assumes the intention was a refresh"(): Promise<void>;
-    "test navigating back to anchored URL"(): Promise<void>;
-    "test following a redirection"(): Promise<void>;
-    "test clicking the back button after redirection"(): Promise<void>;
-    "test same-page anchor visits do not trigger visit events"(): Promise<void>;
-    "test correct referrer header"(): Promise<void>;
-    "test double-clicking on a link"(): Promise<void>;
-}
+export {};

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

@@ -1,6 +1 @@
-import { TurboDriveTestCase } from "../helpers/turbo_drive_test_case";
-export declare class PausableRenderingTests extends TurboDriveTestCase {
-    setup(): Promise<void>;
-    "test pauses and resumes rendering"(): Promise<void>;
-    "test aborts rendering"(): Promise<void>;
-}
+export {};

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

@@ -1,6 +1 @@
-import { TurboDriveTestCase } from "../helpers/turbo_drive_test_case";
-export declare class PausableRequestsTests extends TurboDriveTestCase {
-    setup(): Promise<void>;
-    "test pauses and resumes request"(): Promise<void>;
-    "test aborts request"(): Promise<void>;
-}
+export {};

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

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

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

@@ -1,41 +1,7 @@
-import { TurboDriveTestCase } from "../helpers/turbo_drive_test_case";
-import { Element } from "@theintern/leadfoot";
-export declare class RenderingTests extends TurboDriveTestCase {
-    setup(): Promise<void>;
-    "test triggers before-render and render events"(): Promise<void>;
-    "test triggers before-render and render events for error pages"(): Promise<void>;
-    "test reloads when tracked elements change"(): Promise<void>;
-    "test wont reload when tracked elements has a nonce"(): Promise<void>;
-    "test reloads when turbo-visit-control setting is reload"(): Promise<void>;
-    "test accumulates asset elements in head"(): Promise<void>;
-    "test replaces provisional elements in head"(): Promise<void>;
-    "test evaluates head stylesheet elements"(): Promise<void>;
-    "test does not evaluate head stylesheet elements inside noscript elements"(): Promise<void>;
-    "skip evaluates head script elements once"(): Promise<void>;
-    "test evaluates body script elements on each render"(): Promise<void>;
-    "test does not evaluate data-turbo-eval=false scripts"(): Promise<void>;
-    "test preserves permanent elements"(): Promise<void>;
-    "test preserves permanent elements within turbo-frames"(): Promise<void>;
-    "test preserves permanent elements within turbo-frames rendered without layouts"(): Promise<void>;
-    "test preserves permanent element video playback"(): Promise<void>;
-    "test before-cache event"(): Promise<void>;
-    "test mutation record as before-cache notification"(): Promise<void>;
-    "test error pages"(): Promise<void>;
-    get assetElements(): Promise<Element[]>;
-    get provisionalElements(): Promise<Element[]>;
-    get headElements(): Promise<Element[]>;
-    get permanentElement(): Promise<Element>;
-    get headScriptEvaluationCount(): Promise<number | undefined>;
-    get bodyScriptEvaluationCount(): Promise<number | undefined>;
-    get isStylesheetEvaluated(): Promise<boolean>;
-    get isNoscriptStylesheetEvaluated(): Promise<boolean>;
-    modifyBodyBeforeCaching(): Promise<any>;
-    beforeCache(callback: (body: HTMLElement) => void): Promise<any>;
-    modifyBodyAfterRemoval(): Promise<any>;
-}
 declare global {
     interface Window {
         headScriptEvaluationCount?: number;
         bodyScriptEvaluationCount?: number;
     }
 }
+export {};

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

@@ -1,6 +1 @@
-import { TurboDriveTestCase } from "../helpers/turbo_drive_test_case";
-export declare class ScrollRestorationTests extends TurboDriveTestCase {
-    "test landing on an anchor"(): Promise<void>;
-    "test reloading after scrolling"(): Promise<void>;
-    "test returning from history"(): Promise<void>;
-}
+export {};

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

@@ -1,6 +1 @@
-import { FunctionalTestCase } from "../helpers/functional_test_case";
-export declare class StreamTests extends FunctionalTestCase {
-    setup(): Promise<void>;
-    "test receiving a stream message"(): Promise<void>;
-    "test receiving a stream message with css selector target"(): Promise<void>;
-}
+export {};

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

@@ -1,15 +1 @@
-import { TurboDriveTestCase } from "../helpers/turbo_drive_test_case";
-export declare class VisitTests extends TurboDriveTestCase {
-    setup(): Promise<void>;
-    "test programmatically visiting a same-origin location"(): Promise<void>;
-    "skip programmatically visiting a cross-origin location falls back to window.location"(): Promise<void>;
-    "test visiting a location served with a non-HTML content type"(): Promise<void>;
-    "test canceling a before-visit event prevents navigation"(): Promise<void>;
-    "test navigation by history is not cancelable"(): Promise<void>;
-    "test turbo:before-fetch-request event.detail"(): Promise<void>;
-    "test turbo:before-fetch-request event.detail encodes searchParams"(): Promise<void>;
-    "test turbo:before-fetch-response open new site"(): Promise<void>;
-    "test cache does not override response after redirect"(): Promise<void>;
-    visitLocation(location: string): Promise<void>;
-    cancelNextVisit(): Promise<void>;
-}
+export {};

package/dist/types/tests/helpers/page.d.ts

@@ -0,0 +1,44 @@
+import { JSHandle, Locator, Page } from "@playwright/test";
+declare type EventLog = [string, any, string | null];
+declare type MutationLog = [string, string | null, string | null];
+export declare function attributeForSelector(page: Page, selector: string, attributeName: string): Promise<string | null>;
+export declare function clickWithoutScrolling(page: Page, selector: string, options?: {}): Promise<false | void>;
+export declare function clearLocalStorage(page: Page): Promise<void>;
+export declare function disposeAll(...handles: JSHandle[]): Promise<void[]>;
+export declare function getFromLocalStorage(page: Page, key: string): Promise<string | null>;
+export declare function getSearchParam(url: string, key: string): string | null;
+export declare function hash(url: string): string;
+export declare function hasSelector(page: Page, selector: string): Promise<boolean>;
+export declare function innerHTMLForSelector(page: Page, selector: string): Promise<string>;
+export declare function isScrolledToSelector(page: Page, selector: string): Promise<boolean>;
+export declare function nextBeat(): Promise<void>;
+export declare function nextBody(_page: Page, timeout?: number): Promise<void>;
+export declare function nextEventNamed(page: Page, eventName: string): Promise<any>;
+export declare function nextEventOnTarget(page: Page, elementId: string, eventName: string): Promise<any>;
+export declare function nextAttributeMutationNamed(page: Page, elementId: string, attributeName: string): Promise<string | null>;
+export declare function noNextEventNamed(page: Page, eventName: string): Promise<boolean>;
+export declare function noNextEventOnTarget(page: Page, elementId: string, eventName: string): Promise<boolean>;
+export declare function outerHTMLForSelector(page: Page, selector: string): Promise<string>;
+export declare function pathname(url: string): string;
+export declare function propertyForSelector(page: Page, selector: string, propertyName: string): Promise<any>;
+export declare function readEventLogs(page: Page, length?: number): Promise<EventLog[]>;
+export declare function readMutationLogs(page: Page, length?: number): Promise<MutationLog[]>;
+export declare function search(url: string): string;
+export declare function searchParams(url: string): URLSearchParams;
+export declare function selectorHasFocus(page: Page, selector: string): Promise<boolean>;
+export declare function setLocalStorageFromEvent(page: Page, eventName: string, storageKey: string, storageValue: string): Promise<void>;
+export declare function scrollPosition(page: Page): Promise<{
+    x: number;
+    y: number;
+}>;
+export declare function isScrolledToTop(page: Page): Promise<boolean>;
+export declare function scrollToSelector(page: Page, selector: string): Promise<void>;
+export declare function sleep(timeout?: number): Promise<void>;
+export declare function strictElementEquals(left: Locator, right: Locator): Promise<boolean>;
+export declare function textContent(page: Page, html: string): Promise<string | null>;
+export declare function visitAction(page: Page): Promise<string>;
+export declare function waitForPathname(page: Page, pathname: string): Promise<void>;
+export declare function waitUntilSelector(page: Page, selector: string, state?: "visible" | "attached"): Promise<import("playwright-core").ElementHandle<HTMLElement | SVGElement>>;
+export declare function waitUntilNoSelector(page: Page, selector: string, state?: "hidden" | "detached"): Promise<import("playwright-core").ElementHandle<HTMLElement | SVGElement> | null>;
+export declare function willChangeBody(page: Page, callback: () => Promise<void>): Promise<boolean>;
+export {};

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

@@ -9,16 +9,16 @@ export declare class DeprecatedAdapterSupportTest extends DOMTestCase implements
     teardown(): Promise<void>;
     "test visit proposal location includes deprecated absoluteURL property"(): Promise<void>;
     "test visit start location includes deprecated absoluteURL property"(): Promise<void>;
-    visitProposedToLocation(location: URL, options?: Partial<VisitOptions>): void;
+    visitProposedToLocation(location: URL, _options?: Partial<VisitOptions>): void;
     visitStarted(visit: Visit): void;
-    visitCompleted(visit: Visit): void;
-    visitFailed(visit: Visit): void;
-    visitRequestStarted(visit: Visit): void;
-    visitRequestCompleted(visit: Visit): void;
-    visitRequestFailedWithStatusCode(visit: Visit, statusCode: number): void;
-    visitRequestFinished(visit: Visit): void;
-    visitRendered(visit: Visit): void;
-    formSubmissionStarted(formSubmission: FormSubmission): void;
-    formSubmissionFinished(formSubmission: FormSubmission): void;
+    visitCompleted(_visit: Visit): void;
+    visitFailed(_visit: Visit): void;
+    visitRequestStarted(_visit: Visit): void;
+    visitRequestCompleted(_visit: Visit): void;
+    visitRequestFailedWithStatusCode(_visit: Visit, _statusCode: number): void;
+    visitRequestFinished(_visit: Visit): void;
+    visitRendered(_visit: Visit): void;
+    formSubmissionStarted(_formSubmission: FormSubmission): void;
+    formSubmissionFinished(_formSubmission: FormSubmission): void;
     pageInvalidated(): void;
 }

package/dist/types/util.d.ts

@@ -1,9 +1,9 @@
-export declare type DispatchOptions = {
+export declare type DispatchOptions<T extends CustomEvent> = {
     target: EventTarget;
     cancelable: boolean;
-    detail: any;
+    detail: T["detail"];
 };
-export declare function dispatch(eventName: string, { target, cancelable, detail }?: Partial<DispatchOptions>): CustomEvent<any>;
+export declare function dispatch<T extends CustomEvent>(eventName: string, { target, cancelable, detail }?: Partial<DispatchOptions<T>>): CustomEvent<T["detail"]>;
 export declare function nextAnimationFrame(): Promise<void>;
 export declare function nextEventLoopTick(): Promise<void>;
 export declare function nextMicrotask(): Promise<void>;
@@ -13,3 +13,6 @@ export declare function uuid(): string;
 export declare function getAttribute(attributeName: string, ...elements: (Element | undefined)[]): string | null;
 export declare function markAsBusy(...elements: Element[]): void;
 export declare function clearBusyState(...elements: Element[]): void;
+export declare function getMetaElement(name: string): HTMLMetaElement | null;
+export declare function getMetaContent(name: string): string | null;
+export declare function setMetaContent(name: string, content: string): HTMLMetaElement;