@hotwired/turbo 7.1.0 → 7.2.0-rc.1

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

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

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

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

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

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

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

@@ -27,6 +27,14 @@ declare enum FormEnctype {
     multipart = "multipart/form-data",
     plain = "text/plain"
 }
+export declare type TurboSubmitStartEvent = CustomEvent<{
+    formSubmission: FormSubmission;
+}>;
+export declare type TurboSubmitEndEvent = CustomEvent<{
+    formSubmission: FormSubmission;
+} & {
+    [K in keyof FormSubmissionResult]?: FormSubmissionResult[K];
+}>;
 export declare class FormSubmission {
     readonly delegate: FormSubmissionDelegate;
     readonly formElement: HTMLFormElement;
@@ -37,7 +45,7 @@ export declare class FormSubmission {
     readonly mustRedirect: boolean;
     state: FormSubmissionState;
     result?: FormSubmissionResult;
-    static confirmMethod(message: string, element: HTMLFormElement): boolean;
+    static confirmMethod(message: string, _element: HTMLFormElement, _submitter: HTMLElement | undefined): Promise<boolean>;
     constructor(delegate: FormSubmissionDelegate, formElement: HTMLFormElement, submitter?: HTMLElement, mustRedirect?: boolean);
     get method(): FetchMethod;
     get action(): string;
@@ -45,17 +53,16 @@ export declare class FormSubmission {
     get enctype(): FormEnctype;
     get isIdempotent(): boolean;
     get stringFormData(): [string, string][];
-    get confirmationMessage(): string | null;
-    get needsConfirmation(): boolean;
     start(): Promise<void | FetchResponse>;
     stop(): true | undefined;
     prepareHeadersForRequest(headers: FetchRequestHeaders, request: FetchRequest): void;
-    requestStarted(request: FetchRequest): void;
+    requestStarted(_request: FetchRequest): void;
     requestPreventedHandlingResponse(request: FetchRequest, response: FetchResponse): void;
     requestSucceededWithResponse(request: FetchRequest, response: FetchResponse): void;
     requestFailedWithResponse(request: FetchRequest, response: FetchResponse): void;
     requestErrored(request: FetchRequest, error: Error): void;
-    requestFinished(request: FetchRequest): void;
+    requestFinished(_request: FetchRequest): void;
     requestMustRedirect(request: FetchRequest): boolean;
+    requestAcceptsTurboStreamResponse(request: FetchRequest): boolean;
 }
 export {};

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

@@ -11,9 +11,9 @@ declare type ElementType = "script" | "stylesheet";
 export declare class HeadSnapshot extends Snapshot<HTMLHeadElement> {
     readonly detailsByOuterHTML: ElementDetailMap;
     get trackedElementSignature(): string;
-    getScriptElementsNotInSnapshot(snapshot: HeadSnapshot): Element[];
-    getStylesheetElementsNotInSnapshot(snapshot: HeadSnapshot): Element[];
-    getElementsMatchingTypeNotInSnapshot(matchedType: ElementType, snapshot: HeadSnapshot): Element[];
+    getScriptElementsNotInSnapshot(snapshot: HeadSnapshot): HTMLScriptElement[];
+    getStylesheetElementsNotInSnapshot(snapshot: HeadSnapshot): HTMLLinkElement[];
+    getElementsMatchingTypeNotInSnapshot<T extends Element>(matchedType: ElementType, snapshot: HeadSnapshot): T[];
     get provisionalElements(): Element[];
     getMetaValue(name: string): string | null;
     findMetaElementByName(name: string): Element | undefined;

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

@@ -28,7 +28,7 @@ export declare class History {
     assumeControlOfScrollRestoration(): void;
     relinquishControlOfScrollRestoration(): void;
     onPopState: (event: PopStateEvent) => void;
-    onPageLoad: (event: Event) => Promise<void>;
+    onPageLoad: (_event: Event) => Promise<void>;
     shouldHandlePopState(): boolean;
     pageIsLoaded(): boolean;
 }

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

@@ -4,17 +4,18 @@ import { FormSubmission } from "./form_submission";
 import { Locatable } from "../url";
 import { Visit, VisitDelegate, VisitOptions } from "./visit";
 export declare type NavigatorDelegate = VisitDelegate & {
-    allowsVisitingLocationWithAction(location: URL, action?: Action): boolean;
-    visitProposedToLocation(location: URL, options: Partial<VisitOptions>): void;
+    allowsVisitingLocation(location: URL, options: Partial<VisitOptions>): boolean;
+    visitProposedToLocation(location: URL, options: Partial<VisitOptions>): Promise<void>;
     notifyApplicationAfterVisitingSamePageLocation(oldURL: URL, newURL: URL): void;
 };
 export declare class Navigator {
     readonly delegate: NavigatorDelegate;
     formSubmission?: FormSubmission;
     currentVisit?: Visit;
+    lastVisit?: Visit;
     constructor(delegate: NavigatorDelegate);
-    proposeVisit(location: URL, options?: Partial<VisitOptions>): void;
-    startVisit(locatable: Locatable, restorationIdentifier: string, options?: Partial<VisitOptions>): void;
+    proposeVisit(location: URL, options?: Partial<VisitOptions>): Promise<void>;
+    startVisit(locatable: Locatable, restorationIdentifier: string, options?: Partial<VisitOptions>): Promise<void>;
     submitForm(form: HTMLFormElement, submitter?: HTMLElement): void;
     stop(): void;
     get adapter(): import("../native/adapter").Adapter;

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

@@ -1,25 +1,31 @@
 import { Renderer } from "../renderer";
 import { PageSnapshot } from "./page_snapshot";
+import { ReloadReason } from "../native/browser_adapter";
 export declare class PageRenderer extends Renderer<HTMLBodyElement, PageSnapshot> {
+    static renderElement(currentElement: HTMLBodyElement, newElement: HTMLBodyElement): Promise<void>;
     get shouldRender(): boolean;
-    prepareToRender(): void;
+    get reloadReason(): ReloadReason;
+    prepareToRender(): Promise<void>;
     render(): Promise<void>;
     finishRendering(): void;
     get currentHeadSnapshot(): import("./head_snapshot").HeadSnapshot;
     get newHeadSnapshot(): import("./head_snapshot").HeadSnapshot;
     get newElement(): HTMLBodyElement;
-    mergeHead(): void;
+    mergeHead(): Promise<void>;
     replaceBody(): void;
     get trackedElementsAreIdentical(): boolean;
-    copyNewHeadStylesheetElements(): void;
+    get bodyElementMatches(): boolean;
+    static get bodySelector(): string;
+    static getBodyElement(element: HTMLElement): HTMLElement;
+    copyNewHeadStylesheetElements(): Promise<void>;
     copyNewHeadScriptElements(): void;
     removeCurrentHeadProvisionalElements(): void;
     copyNewHeadProvisionalElements(): void;
     activateNewBody(): void;
     activateNewBodyScriptElements(): void;
     assignNewBody(): void;
-    get newHeadStylesheetElements(): Element[];
-    get newHeadScriptElements(): Element[];
+    get newHeadStylesheetElements(): HTMLLinkElement[];
+    get newHeadScriptElements(): HTMLScriptElement[];
     get currentHeadProvisionalElements(): Element[];
     get newHeadProvisionalElements(): Element[];
     get newBodyScriptElements(): NodeListOf<HTMLScriptElement>;

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

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

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

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

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

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

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

@@ -1,5 +1,5 @@
 import { Adapter } from "../native/adapter";
-import { FetchRequest, FetchRequestDelegate } from "../../http/fetch_request";
+import { FetchRequest, FetchRequestDelegate, FetchRequestHeaders } from "../../http/fetch_request";
 import { FetchResponse } from "../../http/fetch_response";
 import { History } from "./history";
 import { Snapshot } from "../snapshot";
@@ -39,6 +39,12 @@ export declare type VisitOptions = {
     response?: VisitResponse;
     visitCachedSnapshot(snapshot: Snapshot): void;
     willRender: boolean;
+    updateHistory: boolean;
+    restorationIdentifier?: string;
+    shouldCacheSnapshot: boolean;
+    frame?: string;
+    acceptsStreamResponse: boolean;
+    initiator: Element;
 };
 export declare type VisitResponse = {
     statusCode: number;
@@ -52,13 +58,16 @@ export declare enum SystemStatusCode {
 }
 export declare class Visit implements FetchRequestDelegate {
     readonly delegate: VisitDelegate;
-    readonly identifier: string;
     readonly restorationIdentifier: string;
     readonly action: Action;
     readonly referrer?: URL;
     readonly timingMetrics: TimingMetrics;
     readonly visitCachedSnapshot: (snapshot: Snapshot) => void;
     readonly willRender: boolean;
+    readonly updateHistory: boolean;
+    readonly promise: Promise<void>;
+    readonly initiator: Element;
+    private resolvingFunctions;
     followedRedirect: boolean;
     frame?: number;
     historyChanged: boolean;
@@ -68,6 +77,8 @@ export declare class Visit implements FetchRequestDelegate {
     request?: FetchRequest;
     response?: VisitResponse;
     scrolled: boolean;
+    shouldCacheSnapshot: boolean;
+    acceptsStreamResponse: boolean;
     snapshotHTML?: string;
     snapshotCached: boolean;
     state: VisitState;
@@ -94,18 +105,19 @@ export declare class Visit implements FetchRequestDelegate {
     loadCachedSnapshot(): void;
     followRedirect(): void;
     goToSamePageAnchor(): void;
+    prepareHeadersForRequest(headers: FetchRequestHeaders, request: FetchRequest): void;
     requestStarted(): void;
-    requestPreventedHandlingResponse(request: FetchRequest, response: FetchResponse): void;
+    requestPreventedHandlingResponse(_request: FetchRequest, _response: FetchResponse): void;
     requestSucceededWithResponse(request: FetchRequest, response: FetchResponse): Promise<void>;
     requestFailedWithResponse(request: FetchRequest, response: FetchResponse): Promise<void>;
-    requestErrored(request: FetchRequest, error: Error): void;
+    requestErrored(_request: FetchRequest, _error: Error): void;
     requestFinished(): void;
     performScroll(): void;
     scrollToRestoredPosition(): true | undefined;
     scrollToAnchor(): true | undefined;
     recordTimingMetric(metric: TimingMetric): void;
     getTimingMetrics(): TimingMetrics;
-    getHistoryMethodForAction(action: Action): (data: any, title: string, url?: string | null | undefined) => void;
+    getHistoryMethodForAction(action: Action): (data: any, unused: string, url?: string | URL | null | undefined) => void;
     hasPreloadedResponse(): boolean;
     shouldIssueRequest(): boolean;
     cacheSnapshot(): void;

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

@@ -4,67 +4,93 @@ import { FetchResponse } from "../../http/fetch_response";
 import { AppearanceObserver, AppearanceObserverDelegate } from "../../observers/appearance_observer";
 import { FormSubmission, FormSubmissionDelegate } from "../drive/form_submission";
 import { Snapshot } from "../snapshot";
-import { ViewDelegate } from "../view";
-import { FormInterceptor, FormInterceptorDelegate } from "./form_interceptor";
+import { ViewDelegate, ViewRenderOptions } from "../view";
+import { Locatable } from "../url";
+import { FormSubmitObserver, FormSubmitObserverDelegate } from "../../observers/form_submit_observer";
 import { FrameView } from "./frame_view";
-import { LinkInterceptor, LinkInterceptorDelegate } from "./link_interceptor";
-export declare class FrameController implements AppearanceObserverDelegate, FetchRequestDelegate, FormInterceptorDelegate, FormSubmissionDelegate, FrameElementDelegate, LinkInterceptorDelegate, ViewDelegate<Snapshot<FrameElement>> {
+import { LinkClickObserver, LinkClickObserverDelegate } from "../../observers/link_click_observer";
+import { FormLinkClickObserver, FormLinkClickObserverDelegate } from "../../observers/form_link_click_observer";
+import { VisitOptions } from "../drive/visit";
+declare type VisitFallback = (location: Response | Locatable, options: Partial<VisitOptions>) => Promise<void>;
+export declare type TurboFrameMissingEvent = CustomEvent<{
+    response: Response;
+    visit: VisitFallback;
+}>;
+export declare class FrameController implements AppearanceObserverDelegate, FetchRequestDelegate, FormSubmitObserverDelegate, FormSubmissionDelegate, FrameElementDelegate, FormLinkClickObserverDelegate, LinkClickObserverDelegate, ViewDelegate<FrameElement, Snapshot<FrameElement>> {
     readonly element: FrameElement;
     readonly view: FrameView;
     readonly appearanceObserver: AppearanceObserver;
-    readonly linkInterceptor: LinkInterceptor;
-    readonly formInterceptor: FormInterceptor;
-    currentURL?: string | null;
+    readonly formLinkClickObserver: FormLinkClickObserver;
+    readonly linkClickObserver: LinkClickObserver;
+    readonly formSubmitObserver: FormSubmitObserver;
     formSubmission?: FormSubmission;
-    fetchResponseLoaded: (fetchResponse: FetchResponse) => void;
+    fetchResponseLoaded: (_fetchResponse: FetchResponse) => void;
     private currentFetchRequest;
     private resolveVisitPromise;
     private connected;
     private hasBeenLoaded;
-    private settingSourceURL;
+    private ignoredAttributes;
+    private action;
+    private frame?;
+    readonly restorationIdentifier: string;
+    private previousFrameElement?;
+    private currentNavigationElement?;
     constructor(element: FrameElement);
     connect(): void;
     disconnect(): void;
     disabledChanged(): void;
     sourceURLChanged(): void;
+    completeChanged(): void;
     loadingStyleChanged(): void;
-    loadSourceURL(): Promise<void>;
+    private loadSourceURL;
     loadResponse(fetchResponse: FetchResponse): Promise<void>;
-    elementAppearedInViewport(element: Element): void;
-    shouldInterceptLinkClick(element: Element, url: string): boolean;
-    linkClickIntercepted(element: Element, url: string): void;
-    shouldInterceptFormSubmission(element: HTMLFormElement, submitter?: HTMLElement): boolean;
-    formSubmissionIntercepted(element: HTMLFormElement, submitter?: HTMLElement): void;
+    elementAppearedInViewport(_element: Element): void;
+    willSubmitFormLinkToLocation(link: Element): boolean;
+    submittedFormLinkToLocation(link: Element, _location: URL, form: HTMLFormElement): void;
+    willFollowLinkToLocation(element: Element): boolean;
+    followedLinkToLocation(element: Element, location: URL): void;
+    willSubmitForm(element: HTMLFormElement, submitter?: HTMLElement): boolean;
+    formSubmitted(element: HTMLFormElement, submitter?: HTMLElement): void;
     prepareHeadersForRequest(headers: FetchRequestHeaders, request: FetchRequest): void;
-    requestStarted(request: FetchRequest): void;
-    requestPreventedHandlingResponse(request: FetchRequest, response: FetchResponse): void;
+    requestStarted(_request: FetchRequest): void;
+    requestPreventedHandlingResponse(_request: FetchRequest, _response: FetchResponse): void;
     requestSucceededWithResponse(request: FetchRequest, response: FetchResponse): Promise<void>;
-    requestFailedWithResponse(request: FetchRequest, response: FetchResponse): void;
+    requestFailedWithResponse(request: FetchRequest, response: FetchResponse): Promise<void>;
     requestErrored(request: FetchRequest, error: Error): void;
-    requestFinished(request: FetchRequest): void;
+    requestFinished(_request: FetchRequest): void;
     formSubmissionStarted({ formElement }: FormSubmission): void;
     formSubmissionSucceededWithResponse(formSubmission: FormSubmission, response: FetchResponse): void;
     formSubmissionFailedWithResponse(formSubmission: FormSubmission, fetchResponse: FetchResponse): void;
     formSubmissionErrored(formSubmission: FormSubmission, error: Error): void;
     formSubmissionFinished({ formElement }: FormSubmission): void;
-    allowsImmediateRender(snapshot: Snapshot, resume: (value: any) => void): boolean;
-    viewRenderedSnapshot(snapshot: Snapshot, isPreview: boolean): void;
+    allowsImmediateRender({ element: newFrame }: Snapshot<FrameElement>, options: ViewRenderOptions<FrameElement>): boolean;
+    viewRenderedSnapshot(_snapshot: Snapshot, _isPreview: boolean): void;
+    preloadOnLoadLinksForView(element: Element): void;
     viewInvalidated(): void;
+    willRenderFrame(currentElement: FrameElement, _newElement: FrameElement): void;
+    visitCachedSnapshot: ({ element }: Snapshot) => void;
     private visit;
     private navigateFrame;
     private proposeVisitIfNavigatedWithAction;
+    changeHistory(): void;
+    private willHandleFrameMissingFromResponse;
+    private visitResponse;
     private findFrameElement;
-    extractForeignFrameElement(container: ParentNode): Promise<FrameElement>;
+    extractForeignFrameElement(container: ParentNode): Promise<FrameElement | null>;
     private formActionIsVisitable;
     private shouldInterceptNavigation;
     get id(): string;
     get enabled(): boolean;
     get sourceURL(): string | undefined;
-    get reloadable(): boolean;
-    set reloadable(value: boolean);
     set sourceURL(sourceURL: string | undefined);
     get loadingStyle(): FrameLoadingStyle;
     get isLoading(): boolean;
+    get complete(): boolean;
+    set complete(value: boolean);
     get isActive(): boolean;
     get rootLocation(): URL;
+    private isIgnoringChangesTo;
+    private ignoringChangesToAttribute;
+    private withCurrentNavigationElement;
 }
+export {};

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

@@ -1,16 +1,18 @@
-import { FormInterceptor, FormInterceptorDelegate } from "./form_interceptor";
-import { LinkInterceptor, LinkInterceptorDelegate } from "./link_interceptor";
-export declare class FrameRedirector implements LinkInterceptorDelegate, FormInterceptorDelegate {
+import { FormSubmitObserver, FormSubmitObserverDelegate } from "../../observers/form_submit_observer";
+import { LinkClickObserver, LinkClickObserverDelegate } from "../../observers/link_click_observer";
+import { Session } from "../session";
+export declare class FrameRedirector implements LinkClickObserverDelegate, FormSubmitObserverDelegate {
+    readonly session: Session;
     readonly element: Element;
-    readonly linkInterceptor: LinkInterceptor;
-    readonly formInterceptor: FormInterceptor;
-    constructor(element: Element);
+    readonly linkClickObserver: LinkClickObserver;
+    readonly formSubmitObserver: FormSubmitObserver;
+    constructor(session: Session, element: Element);
     start(): void;
     stop(): void;
-    shouldInterceptLinkClick(element: Element, url: string): boolean;
-    linkClickIntercepted(element: Element, url: string): void;
-    shouldInterceptFormSubmission(element: HTMLFormElement, submitter?: HTMLElement): boolean;
-    formSubmissionIntercepted(element: HTMLFormElement, submitter?: HTMLElement): void;
+    willFollowLinkToLocation(element: Element): boolean;
+    followedLinkToLocation(element: Element, url: URL): void;
+    willSubmitForm(element: HTMLFormElement, submitter?: HTMLElement): boolean;
+    formSubmitted(element: HTMLFormElement, submitter?: HTMLElement): void;
     private shouldSubmit;
     private shouldRedirect;
     private findFrameElement;

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

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

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

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

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

@@ -1,20 +1,28 @@
 import { Adapter } from "./native/adapter";
-import { Session } from "./session";
+import { FormMode, Session } from "./session";
+import { Cache } from "./cache";
 import { Locatable } from "./url";
 import { StreamMessage } from "./streams/stream_message";
 import { StreamSource } from "./types";
 import { VisitOptions } from "./drive/visit";
 import { PageRenderer } from "./drive/page_renderer";
 import { PageSnapshot } from "./drive/page_snapshot";
+import { FrameRenderer } from "./frames/frame_renderer";
 declare const session: Session;
+declare const cache: Cache;
 declare const navigator: import("./drive/navigator").Navigator;
-export { navigator, session, PageRenderer, PageSnapshot };
+export { navigator, session, cache, PageRenderer, PageSnapshot, FrameRenderer };
+export { TurboBeforeCacheEvent, TurboBeforeRenderEvent, TurboBeforeVisitEvent, TurboClickEvent, TurboFetchRequestErrorEvent, TurboFrameLoadEvent, TurboFrameRenderEvent, TurboLoadEvent, TurboRenderEvent, TurboVisitEvent, } from "./session";
+export { TurboSubmitStartEvent, TurboSubmitEndEvent } from "./drive/form_submission";
+export { TurboFrameMissingEvent } from "./frames/frame_controller";
+export { StreamActions, TurboStreamAction, TurboStreamActions } from "./streams/stream_actions";
 export declare function start(): void;
 export declare function registerAdapter(adapter: Adapter): void;
-export declare function visit(location: Locatable, options?: Partial<VisitOptions>): void;
+export declare function visit(location: Locatable, options?: Partial<VisitOptions>): Promise<void>;
 export declare function connectStreamSource(source: StreamSource): void;
 export declare function disconnectStreamSource(source: StreamSource): void;
 export declare function renderStreamMessage(message: StreamMessage | string): void;
 export declare function clearCache(): void;
 export declare function setProgressBarDelay(delay: number): void;
-export declare function setConfirmMethod(confirmMethod: (message: string, element: HTMLFormElement) => boolean): void;
+export declare function setConfirmMethod(confirmMethod: (message: string, element: HTMLFormElement, submitter: HTMLElement | undefined) => Promise<boolean>): void;
+export declare function setFormMode(mode: FormMode): void;

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

@@ -1,7 +1,8 @@
 import { Visit, VisitOptions } from "../drive/visit";
 import { FormSubmission } from "../drive/form_submission";
+import { ReloadReason } from "./browser_adapter";
 export interface Adapter {
-    visitProposedToLocation(location: URL, options?: Partial<VisitOptions>): void;
+    visitProposedToLocation(location: URL, options?: Partial<VisitOptions>): Promise<void>;
     visitStarted(visit: Visit): void;
     visitCompleted(visit: Visit): void;
     visitFailed(visit: Visit): void;
@@ -12,5 +13,5 @@ export interface Adapter {
     visitRendered(visit: Visit): void;
     formSubmissionStarted?(formSubmission: FormSubmission): void;
     formSubmissionFinished?(formSubmission: FormSubmission): void;
-    pageInvalidated(): void;
+    pageInvalidated(reason: ReloadReason): void;
 }

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

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

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

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