@hotwired/turbo 7.0.0-beta.3 → 7.0.0-beta.4

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

@@ -1,13 +1,9 @@
-import { RenderCallback, RenderDelegate, Renderer } from "./renderer";
-export declare class ErrorRenderer extends Renderer {
-    readonly delegate: RenderDelegate;
-    readonly htmlElement: HTMLHtmlElement;
-    readonly newHead: HTMLHeadElement;
-    readonly newBody: HTMLBodyElement;
-    static render(delegate: RenderDelegate, callback: RenderCallback, html: string): void;
-    constructor(delegate: RenderDelegate, html: string);
-    render(callback: RenderCallback): void;
+import { PageSnapshot } from "./page_snapshot";
+import { Renderer } from "../renderer";
+export declare class ErrorRenderer extends Renderer<HTMLBodyElement, PageSnapshot> {
+    render(): Promise<void>;
     replaceHeadAndBody(): void;
-    activateBodyScriptElements(): void;
-    getScriptElements(): HTMLScriptElement[];
+    activateScriptElements(): void;
+    get newHead(): HTMLHeadElement;
+    get scriptElements(): HTMLScriptElement[];
 }

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

@@ -1,6 +1,5 @@
 import { FetchRequest, FetchMethod, FetchRequestHeaders } from "../../http/fetch_request";
 import { FetchResponse } from "../../http/fetch_response";
-import { Location } from "../location";
 export interface FormSubmissionDelegate {
     formSubmissionStarted(formSubmission: FormSubmission): void;
     formSubmissionSucceededWithResponse(formSubmission: FormSubmission, fetchResponse: FetchResponse): void;
@@ -23,6 +22,11 @@ export declare enum FormSubmissionState {
     stopping = 4,
     stopped = 5
 }
+declare enum FormEnctype {
+    urlEncoded = "application/x-www-form-urlencoded",
+    multipart = "multipart/form-data",
+    plain = "text/plain"
+}
 export declare class FormSubmission {
     readonly delegate: FormSubmissionDelegate;
     readonly formElement: HTMLFormElement;
@@ -35,10 +39,13 @@ export declare class FormSubmission {
     constructor(delegate: FormSubmissionDelegate, formElement: HTMLFormElement, submitter?: HTMLElement, mustRedirect?: boolean);
     get method(): FetchMethod;
     get action(): string;
-    get location(): Location;
+    get location(): URL;
+    get body(): FormData;
+    get enctype(): FormEnctype;
+    get stringFormData(): [string, string][];
     start(): Promise<FetchResponse | undefined>;
     stop(): true | undefined;
-    additionalHeadersForRequest(request: FetchRequest): FetchRequestHeaders;
+    prepareHeadersForRequest(headers: FetchRequestHeaders, request: FetchRequest): void;
     requestStarted(request: FetchRequest): void;
     requestPreventedHandlingResponse(request: FetchRequest, response: FetchResponse): void;
     requestSucceededWithResponse(request: FetchRequest, response: FetchResponse): void;
@@ -47,3 +54,4 @@ export declare class FormSubmission {
     requestFinished(request: FetchRequest): void;
     requestMustRedirect(request: FetchRequest): boolean;
 }
+export {};

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

@@ -0,0 +1,21 @@
+import { Snapshot } from "../snapshot";
+declare type ElementDetailMap = {
+    [outerHTML: string]: ElementDetails;
+};
+declare type ElementDetails = {
+    type?: ElementType;
+    tracked: boolean;
+    elements: Element[];
+};
+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[];
+    get provisionalElements(): Element[];
+    getMetaValue(name: string): string | null;
+    findMetaElementByName(name: string): Element | undefined;
+}
+export {};

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

@@ -1,7 +1,6 @@
-import { Location } from "../location";
 import { Position } from "../types";
 export interface HistoryDelegate {
-    historyPoppedToLocationWithRestorationIdentifier(location: Location, restorationIdentifier: string): void;
+    historyPoppedToLocationWithRestorationIdentifier(location: URL, restorationIdentifier: string): void;
 }
 declare type HistoryMethod = (this: typeof history, state: any, title: string, url?: string | null | undefined) => void;
 export declare type RestorationData = {
@@ -12,7 +11,7 @@ export declare type RestorationDataMap = {
 };
 export declare class History {
     readonly delegate: HistoryDelegate;
-    location: Location;
+    location: URL;
     restorationIdentifier: string;
     restorationData: RestorationDataMap;
     started: boolean;
@@ -21,9 +20,9 @@ export declare class History {
     constructor(delegate: HistoryDelegate);
     start(): void;
     stop(): void;
-    push(location: Location, restorationIdentifier?: string): void;
-    replace(location: Location, restorationIdentifier?: string): void;
-    update(method: HistoryMethod, location: Location, restorationIdentifier?: string): void;
+    push(location: URL, restorationIdentifier?: string): void;
+    replace(location: URL, restorationIdentifier?: string): void;
+    update(method: HistoryMethod, location: URL, restorationIdentifier?: string): void;
     getRestorationDataForIdentifier(restorationIdentifier: string): RestorationData;
     updateRestorationData(additionalData: Partial<RestorationData>): void;
     assumeControlOfScrollRestoration(): void;

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

@@ -1,22 +1,22 @@
 import { FetchResponse } from "../../http/fetch_response";
 import { FormSubmission } from "./form_submission";
-import { Locatable, Location } from "../location";
+import { Locatable } from "../url";
 import { Visit, VisitDelegate, VisitOptions } from "./visit";
 export declare type NavigatorDelegate = VisitDelegate & {
-    allowsVisitingLocation(location: Location): boolean;
-    visitProposedToLocation(location: Location, options: Partial<VisitOptions>): void;
+    allowsVisitingLocation(location: URL): boolean;
+    visitProposedToLocation(location: URL, options: Partial<VisitOptions>): void;
 };
 export declare class Navigator {
     readonly delegate: NavigatorDelegate;
     formSubmission?: FormSubmission;
     currentVisit?: Visit;
     constructor(delegate: NavigatorDelegate);
-    proposeVisit(location: Location, options?: Partial<VisitOptions>): void;
-    startVisit(location: Locatable, restorationIdentifier: string, options?: Partial<VisitOptions>): void;
+    proposeVisit(location: URL, options?: Partial<VisitOptions>): void;
+    startVisit(locatable: Locatable, restorationIdentifier: string, options?: Partial<VisitOptions>): void;
     submitForm(form: HTMLFormElement, submitter?: HTMLElement): void;
     stop(): void;
     get adapter(): import("../native/adapter").Adapter;
-    get view(): import("./view").View;
+    get view(): import("./page_view").PageView;
     get history(): import("./history").History;
     formSubmissionStarted(formSubmission: FormSubmission): void;
     formSubmissionSucceededWithResponse(formSubmission: FormSubmission, fetchResponse: FetchResponse): Promise<void>;
@@ -25,6 +25,6 @@ export declare class Navigator {
     formSubmissionFinished(formSubmission: FormSubmission): void;
     visitStarted(visit: Visit): void;
     visitCompleted(visit: Visit): void;
-    get location(): Location;
+    get location(): URL;
     get restorationIdentifier(): string;
 }

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

@@ -0,0 +1,26 @@
+import { Renderer } from "../renderer";
+import { PageSnapshot } from "./page_snapshot";
+export declare class PageRenderer extends Renderer<HTMLBodyElement, PageSnapshot> {
+    get shouldRender(): boolean;
+    prepareToRender(): void;
+    render(): Promise<void>;
+    finishRendering(): void;
+    get currentHeadSnapshot(): import("./head_snapshot").HeadSnapshot;
+    get newHeadSnapshot(): import("./head_snapshot").HeadSnapshot;
+    get newElement(): HTMLBodyElement;
+    mergeHead(): void;
+    replaceBody(): void;
+    get trackedElementsAreIdentical(): boolean;
+    copyNewHeadStylesheetElements(): void;
+    copyNewHeadScriptElements(): void;
+    removeCurrentHeadProvisionalElements(): void;
+    copyNewHeadProvisionalElements(): void;
+    activateNewBody(): void;
+    activateNewBodyScriptElements(): void;
+    assignNewBody(): void;
+    get newHeadStylesheetElements(): Element[];
+    get newHeadScriptElements(): Element[];
+    get currentHeadProvisionalElements(): Element[];
+    get newHeadProvisionalElements(): Element[];
+    get newBodyScriptElements(): HTMLScriptElement[];
+}

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

@@ -0,0 +1,17 @@
+import { Snapshot } from "../snapshot";
+import { HeadSnapshot } from "./head_snapshot";
+export declare class PageSnapshot extends Snapshot<HTMLBodyElement> {
+    static fromHTMLString(html?: string): PageSnapshot;
+    static fromElement(element: Element): PageSnapshot;
+    static fromDocument({ head, body }: Document): PageSnapshot;
+    readonly headSnapshot: HeadSnapshot;
+    constructor(element: HTMLBodyElement, headSnapshot: HeadSnapshot);
+    clone(): PageSnapshot;
+    get headElement(): HTMLHeadElement;
+    get rootLocation(): URL;
+    get cacheControlValue(): string | null;
+    get isPreviewable(): boolean;
+    get isCacheable(): boolean;
+    get isVisitable(): boolean;
+    getSetting(name: string): string | null;
+}

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

@@ -0,0 +1,21 @@
+import { View, ViewDelegate } 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> {
+    viewWillCacheSnapshot(): void;
+}
+declare type PageViewRenderer = PageRenderer | ErrorRenderer;
+export declare class PageView extends View<Element, PageSnapshot, PageViewRenderer, PageViewDelegate> {
+    readonly snapshotCache: SnapshotCache;
+    lastRenderedLocation: URL;
+    renderPage(snapshot: PageSnapshot, isPreview?: boolean): Promise<void>;
+    renderError(snapshot: PageSnapshot): void;
+    clearSnapshotCache(): void;
+    cacheSnapshot(): Promise<void>;
+    getCachedSnapshotForLocation(location: URL): PageSnapshot | undefined;
+    get snapshot(): PageSnapshot;
+    get shouldCacheSnapshot(): boolean;
+}
+export {};

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

@@ -1,18 +1,17 @@
-import { Location } from "../location";
-import { Snapshot } from "./snapshot";
+import { PageSnapshot } from "./page_snapshot";
 export declare class SnapshotCache {
     readonly keys: string[];
     readonly size: number;
     snapshots: {
-        [url: string]: Snapshot;
+        [url: string]: PageSnapshot;
     };
     constructor(size: number);
-    has(location: Location): boolean;
-    get(location: Location): Snapshot | undefined;
-    put(location: Location, snapshot: Snapshot): Snapshot;
+    has(location: URL): boolean;
+    get(location: URL): PageSnapshot | undefined;
+    put(location: URL, snapshot: PageSnapshot): PageSnapshot;
     clear(): void;
-    read(location: Location): Snapshot;
-    write(location: Location, snapshot: Snapshot): void;
-    touch(location: Location): void;
+    read(location: URL): PageSnapshot;
+    write(location: URL, snapshot: PageSnapshot): void;
+    touch(location: URL): void;
     trim(): void;
 }

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

@@ -2,15 +2,13 @@ import { Adapter } from "../native/adapter";
 import { FetchRequest, FetchRequestDelegate } from "../../http/fetch_request";
 import { FetchResponse } from "../../http/fetch_response";
 import { History } from "./history";
-import { Location } from "../location";
-import { RenderCallback } from "./renderer";
-import { Snapshot } from "./snapshot";
+import { PageSnapshot } from "./page_snapshot";
 import { Action } from "../types";
-import { View } from "./view";
+import { PageView } from "./page_view";
 export interface VisitDelegate {
     readonly adapter: Adapter;
-    readonly view: View;
     readonly history: History;
+    readonly view: PageView;
     visitStarted(visit: Visit): void;
     visitCompleted(visit: Visit): void;
 }
@@ -33,7 +31,7 @@ export declare enum VisitState {
 export declare type VisitOptions = {
     action: Action;
     historyChanged: boolean;
-    referrer?: Location;
+    referrer?: URL;
     snapshotHTML?: string;
     response?: VisitResponse;
 };
@@ -51,22 +49,22 @@ export declare class Visit implements FetchRequestDelegate {
     readonly identifier: string;
     readonly restorationIdentifier: string;
     readonly action: Action;
-    readonly referrer?: Location;
+    readonly referrer?: URL;
     readonly timingMetrics: TimingMetrics;
     followedRedirect: boolean;
     frame?: number;
     historyChanged: boolean;
-    location: Location;
-    redirectedToLocation?: Location;
+    location: URL;
+    redirectedToLocation?: URL;
     request?: FetchRequest;
     response?: VisitResponse;
     scrolled: boolean;
     snapshotHTML?: string;
     snapshotCached: boolean;
     state: VisitState;
-    constructor(delegate: VisitDelegate, location: Location, restorationIdentifier: string | undefined, options?: Partial<VisitOptions>);
+    constructor(delegate: VisitDelegate, location: URL, restorationIdentifier: string | undefined, options?: Partial<VisitOptions>);
     get adapter(): Adapter;
-    get view(): View;
+    get view(): PageView;
     get history(): History;
     get restorationData(): import("./history").RestorationData;
     start(): void;
@@ -80,8 +78,8 @@ export declare class Visit implements FetchRequestDelegate {
     recordResponse(response?: VisitResponse | undefined): void;
     finishRequest(): void;
     loadResponse(): void;
-    getCachedSnapshot(): Snapshot | undefined;
-    getPreloadedSnapshot(): Snapshot | undefined;
+    getCachedSnapshot(): PageSnapshot | undefined;
+    getPreloadedSnapshot(): PageSnapshot | undefined;
     hasCachedSnapshot(): boolean;
     loadCachedSnapshot(): void;
     followRedirect(): void;
@@ -91,7 +89,7 @@ export declare class Visit implements FetchRequestDelegate {
     requestFailedWithResponse(request: FetchRequest, response: FetchResponse): Promise<void>;
     requestErrored(request: FetchRequest, error: Error): void;
     requestFinished(): void;
-    performScroll: () => void;
+    performScroll(): void;
     scrollToRestoredPosition(): true | undefined;
     scrollToAnchor(): true | undefined;
     scrollToTop(): void;
@@ -101,6 +99,6 @@ export declare class Visit implements FetchRequestDelegate {
     hasPreloadedResponse(): boolean;
     shouldIssueRequest(): boolean;
     cacheSnapshot(): void;
-    render(callback: RenderCallback): void;
+    render(callback: () => Promise<void>): Promise<void>;
     cancelRender(): void;
 }

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

@@ -1,12 +1,16 @@
 import { FrameElement, FrameElementDelegate, FrameLoadingStyle } from "../../elements/frame_element";
-import { FetchRequest, FetchRequestDelegate } from "../../http/fetch_request";
+import { FetchRequest, FetchRequestDelegate, FetchRequestHeaders } from "../../http/fetch_request";
 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 { FrameView } from "./frame_view";
 import { LinkInterceptor, LinkInterceptorDelegate } from "./link_interceptor";
-export declare class FrameController implements AppearanceObserverDelegate, FetchRequestDelegate, FormInterceptorDelegate, FormSubmissionDelegate, FrameElementDelegate, LinkInterceptorDelegate {
+export declare class FrameController implements AppearanceObserverDelegate, FetchRequestDelegate, FormInterceptorDelegate, FormSubmissionDelegate, FrameElementDelegate, LinkInterceptorDelegate, ViewDelegate<Snapshot<FrameElement>> {
     readonly element: FrameElement;
+    readonly view: FrameView;
     readonly appearanceObserver: AppearanceObserver;
     readonly linkInterceptor: LinkInterceptor;
     readonly formInterceptor: FormInterceptor;
@@ -25,9 +29,7 @@ export declare class FrameController implements AppearanceObserverDelegate, Fetc
     linkClickIntercepted(element: Element, url: string): void;
     shouldInterceptFormSubmission(element: HTMLFormElement): boolean;
     formSubmissionIntercepted(element: HTMLFormElement, submitter?: HTMLElement): void;
-    additionalHeadersForRequest(request: FetchRequest): {
-        "Turbo-Frame": string;
-    };
+    prepareHeadersForRequest(headers: FetchRequestHeaders, request: FetchRequest): void;
     requestStarted(request: FetchRequest): void;
     requestPreventedHandlingResponse(request: FetchRequest, response: FetchResponse): void;
     requestSucceededWithResponse(request: FetchRequest, response: FetchResponse): Promise<void>;
@@ -39,15 +41,14 @@ export declare class FrameController implements AppearanceObserverDelegate, Fetc
     formSubmissionFailedWithResponse(formSubmission: FormSubmission, fetchResponse: FetchResponse): void;
     formSubmissionErrored(formSubmission: FormSubmission, error: Error): void;
     formSubmissionFinished(formSubmission: FormSubmission): void;
+    viewWillRenderSnapshot(snapshot: Snapshot, isPreview: boolean): void;
+    viewRenderedSnapshot(snapshot: Snapshot, isPreview: boolean): void;
+    viewInvalidated(): void;
     private visit;
     private navigateFrame;
     private findFrameElement;
-    private extractForeignFrameElement;
-    private loadFrameElement;
-    private focusFirstAutofocusableElement;
-    private scrollFrameIntoView;
+    extractForeignFrameElement(container: ParentNode): Promise<FrameElement>;
     private shouldInterceptNavigation;
-    get firstAutofocusableElement(): HTMLElement | null;
     get id(): string;
     get enabled(): boolean;
     get sourceURL(): string | null;

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

@@ -0,0 +1,8 @@
+import { FrameElement } from "../../elements/frame_element";
+import { Renderer } from "../renderer";
+export declare class FrameRenderer extends Renderer<FrameElement> {
+    get shouldRender(): boolean;
+    render(): Promise<void>;
+    loadFrameElement(): void;
+    scrollFrameIntoView(): boolean;
+}

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

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

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

@@ -1,5 +1,5 @@
 import { Adapter } from "./native/adapter";
-import { Locatable } from "./location";
+import { Locatable } from "./url";
 import { StreamMessage } from "./streams/stream_message";
 import { StreamSource } from "./types";
 import { VisitOptions } from "./drive/visit";

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

@@ -1,7 +1,6 @@
-import { Locatable } from "../location";
 import { Visit, VisitOptions } from "../drive/visit";
 export interface Adapter {
-    visitProposedToLocation(location: Locatable, options?: Partial<VisitOptions>): void;
+    visitProposedToLocation(location: URL, options?: Partial<VisitOptions>): void;
     visitStarted(visit: Visit): void;
     visitCompleted(visit: Visit): void;
     visitFailed(visit: Visit): void;

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

@@ -1,5 +1,4 @@
 import { Adapter } from "./adapter";
-import { Locatable } from "../location";
 import { ProgressBar } from "../drive/progress_bar";
 import { Visit, VisitOptions } from "../drive/visit";
 import { Session } from "../session";
@@ -8,7 +7,7 @@ export declare class BrowserAdapter implements Adapter {
     readonly progressBar: ProgressBar;
     progressBarTimeout?: number;
     constructor(session: Session);
-    visitProposedToLocation(location: Locatable, options?: Partial<VisitOptions>): void;
+    visitProposedToLocation(location: URL, options?: Partial<VisitOptions>): void;
     visitStarted(visit: Visit): void;
     visitRequestStarted(visit: Visit): void;
     visitRequestCompleted(visit: Visit): void;

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

@@ -0,0 +1,26 @@
+import { Snapshot } from "./snapshot";
+export declare type PermanentElement = Element & {
+    id: string;
+};
+export declare type Placeholder = {
+    element: Element;
+    permanentElement: PermanentElement;
+};
+export declare abstract class Renderer<E extends Element, S extends Snapshot<E> = Snapshot<E>> {
+    readonly currentSnapshot: S;
+    readonly newSnapshot: S;
+    readonly isPreview: boolean;
+    readonly promise: Promise<void>;
+    private resolvingFunctions?;
+    constructor(currentSnapshot: S, newSnapshot: S, isPreview: boolean);
+    get shouldRender(): boolean;
+    prepareToRender(): void;
+    abstract render(): Promise<void>;
+    finishRendering(): void;
+    createScriptElement(element: Element): Element;
+    preservingPermanentElements(callback: () => void): void;
+    focusFirstAutofocusableElement(): void;
+    get currentElement(): E;
+    get newElement(): E;
+}
+export declare function replaceElementWithElement(fromElement: Element, toElement: Element): Element | undefined;

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

@@ -1,22 +1,23 @@
 import { Adapter } from "./native/adapter";
 import { FormSubmitObserver } from "../observers/form_submit_observer";
 import { FrameRedirector } from "./frames/frame_redirector";
-import { History } from "./drive/history";
-import { LinkClickObserver } from "../observers/link_click_observer";
-import { Location, Locatable } from "./location";
+import { History, HistoryDelegate } from "./drive/history";
+import { LinkClickObserver, LinkClickObserverDelegate } from "../observers/link_click_observer";
+import { Locatable } from "./url";
 import { Navigator, NavigatorDelegate } from "./drive/navigator";
 import { PageObserver, PageObserverDelegate } from "../observers/page_observer";
 import { ScrollObserver } from "../observers/scroll_observer";
 import { StreamMessage } from "./streams/stream_message";
 import { StreamObserver } from "../observers/stream_observer";
 import { Action, Position, StreamSource } from "./types";
-import { View } from "./drive/view";
+import { PageView, PageViewDelegate } from "./drive/page_view";
 import { Visit, VisitOptions } from "./drive/visit";
+import { PageSnapshot } from "./drive/page_snapshot";
 export declare type TimingData = {};
-export declare class Session implements NavigatorDelegate, PageObserverDelegate {
+export declare class Session implements HistoryDelegate, LinkClickObserverDelegate, NavigatorDelegate, PageObserverDelegate, PageViewDelegate {
     readonly navigator: Navigator;
     readonly history: History;
-    readonly view: View;
+    readonly view: PageView;
     adapter: Adapter;
     readonly pageObserver: PageObserver;
     readonly linkClickObserver: LinkClickObserver;
@@ -37,14 +38,14 @@ export declare class Session implements NavigatorDelegate, PageObserverDelegate
     renderStreamMessage(message: StreamMessage | string): void;
     clearCache(): void;
     setProgressBarDelay(delay: number): void;
-    get location(): Location;
+    get location(): URL;
     get restorationIdentifier(): string;
-    historyPoppedToLocationWithRestorationIdentifier(location: Location): void;
+    historyPoppedToLocationWithRestorationIdentifier(location: URL): void;
     scrollPositionChanged(position: Position): void;
-    willFollowLinkToLocation(link: Element, location: Location): boolean;
-    followedLinkToLocation(link: Element, location: Location): void;
-    allowsVisitingLocation(location: Location): boolean;
-    visitProposedToLocation(location: Location, options: Partial<VisitOptions>): void;
+    willFollowLinkToLocation(link: Element, location: URL): boolean;
+    followedLinkToLocation(link: Element, location: URL): void;
+    allowsVisitingLocation(location: URL): boolean;
+    visitProposedToLocation(location: URL, options: Partial<VisitOptions>): void;
     visitStarted(visit: Visit): void;
     visitCompleted(visit: Visit): void;
     willSubmitForm(form: HTMLFormElement, submitter?: HTMLElement): boolean;
@@ -53,20 +54,21 @@ export declare class Session implements NavigatorDelegate, PageObserverDelegate
     pageLoaded(): void;
     pageWillUnload(): void;
     receivedMessageFromStream(message: StreamMessage): void;
-    viewWillRender(newBody: HTMLBodyElement): void;
-    viewRendered(): void;
-    viewInvalidated(): void;
     viewWillCacheSnapshot(): void;
-    applicationAllowsFollowingLinkToLocation(link: Element, location: Location): boolean;
-    applicationAllowsVisitingLocation(location: Location): boolean;
-    notifyApplicationAfterClickingLinkToLocation(link: Element, location: Location): CustomEvent<any>;
-    notifyApplicationBeforeVisitingLocation(location: Location): CustomEvent<any>;
-    notifyApplicationAfterVisitingLocation(location: Location): CustomEvent<any>;
+    viewWillRenderSnapshot({ element }: PageSnapshot, isPreview: boolean): void;
+    viewRenderedSnapshot(snapshot: PageSnapshot, isPreview: boolean): void;
+    viewInvalidated(): void;
+    applicationAllowsFollowingLinkToLocation(link: Element, location: URL): boolean;
+    applicationAllowsVisitingLocation(location: URL): boolean;
+    notifyApplicationAfterClickingLinkToLocation(link: Element, location: URL): CustomEvent<any>;
+    notifyApplicationBeforeVisitingLocation(location: URL): CustomEvent<any>;
+    notifyApplicationAfterVisitingLocation(location: URL): CustomEvent<any>;
     notifyApplicationBeforeCachingSnapshot(): CustomEvent<any>;
     notifyApplicationBeforeRender(newBody: HTMLBodyElement): CustomEvent<any>;
     notifyApplicationAfterRender(): CustomEvent<any>;
     notifyApplicationAfterPageLoad(timing?: TimingData): CustomEvent<any>;
     getActionForLink(link: Element): Action;
     elementIsNavigable(element?: Element): boolean;
-    locationIsVisitable(location: Location): boolean;
+    locationIsVisitable(location: URL): boolean;
+    get snapshot(): PageSnapshot;
 }

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

@@ -0,0 +1,11 @@
+export declare class Snapshot<E extends Element = Element> {
+    readonly element: E;
+    constructor(element: E);
+    get children(): Element[];
+    hasAnchor(anchor: string): boolean;
+    getElementForAnchor(anchor: string): Element | null;
+    get firstAutofocusableElement(): Element | null;
+    get permanentElements(): Element[];
+    getPermanentElementById(id: string): Element | null;
+    getPermanentElementsPresentInSnapshot(snapshot: Snapshot): Element[];
+}

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

@@ -1,5 +1,6 @@
 import { StreamElement } from "../../elements/stream_element";
 export declare class StreamMessage {
+    static readonly contentType = "text/vnd.turbo-stream.html";
     readonly templateElement: HTMLTemplateElement;
     static wrap(message: StreamMessage | string): StreamMessage;
     constructor(html: string);

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

@@ -0,0 +1,7 @@
+export declare type Locatable = URL | string;
+export declare function expandURL(locatable: Locatable): URL;
+export declare function getAnchor(url: URL): string;
+export declare function getExtension(url: URL): string;
+export declare function isHTML(url: URL): boolean;
+export declare function isPrefixedBy(baseURL: URL, url: URL): boolean;
+export declare function toCacheKey(url: URL): string;

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

@@ -0,0 +1,27 @@
+import { Renderer } from "./renderer";
+import { Snapshot } from "./snapshot";
+import { Position } from "./types";
+export interface ViewDelegate<S extends Snapshot> {
+    viewWillRenderSnapshot(snapshot: S, isPreview: boolean): void;
+    viewRenderedSnapshot(snapshot: S, isPreview: boolean): void;
+    viewInvalidated(): 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>> {
+    readonly delegate: D;
+    readonly element: E;
+    renderer?: R;
+    abstract readonly snapshot: S;
+    constructor(delegate: D, element: E);
+    scrollToAnchor(anchor: string): void;
+    scrollToElement(element: Element): void;
+    scrollToPosition({ x, y }: Position): void;
+    get scrollRoot(): {
+        scrollTo(x: number, y: number): void;
+    };
+    render(renderer: R): Promise<void>;
+    invalidate(): void;
+    prepareToRenderSnapshot(renderer: R): void;
+    markAsPreview(isPreview: boolean): void;
+    renderSnapshot(renderer: R): Promise<void>;
+    finishRenderingSnapshot(renderer: R): void;
+}