@types/hotwired__turbo 8.0.5 → 8.0.7

hotwired__turbo/README.md

@@ -8,7 +8,7 @@ This package contains type definitions for @hotwired/turbo (https://turbo.hotwir
 Files were exported from https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/hotwired__turbo.
 
 ### Additional Details
- * Last updated: Thu, 01 Jan 2026 04:28:37 GMT
+ * Last updated: Sun, 01 Mar 2026 23:38:06 GMT
  * Dependencies: none
 
 # Credits

hotwired__turbo/index.d.ts

@@ -13,10 +13,13 @@ export class FrameElement extends HTMLElement {
 }
 
 export class StreamElement extends HTMLElement {
+    static renderElement(newElement: StreamElement): Promise<void>;
+
     connectedCallback(): Promise<void>;
     render(): Promise<void>;
     disconnect(): void;
     removeDuplicateTargetChildren(): void;
+    removeDuplicateTargetSiblings(): void;
 
     /**
      * The current action.
@@ -38,13 +41,52 @@ export class StreamElement extends HTMLElement {
      * Reads the request-id attribute
      */
     readonly requestId: string;
+
+    /**
+     * Gets the main `<template>` element used for rendering.
+     */
+    readonly templateElement: HTMLTemplateElement;
+
+    /**
+     * Gets a cloned copy of the template's content.
+     */
+    readonly templateContent: DocumentFragment;
+}
+
+export class StreamSourceElement extends HTMLElement {
+    streamSource: WebSocket | EventSource | null;
+    readonly src: string;
+}
+
+export interface StreamSource {
+    addEventListener(
+        type: "message",
+        listener: (event: MessageEvent) => void,
+        options?: boolean | AddEventListenerOptions,
+    ): void;
+    removeEventListener(
+        type: "message",
+        listener: (event: MessageEvent) => void,
+        options?: boolean | EventListenerOptions,
+    ): void;
+}
+
+export class StreamMessage {
+    static readonly contentType: "text/vnd.turbo-stream.html";
+    readonly fragment: DocumentFragment;
+    static wrap(message: StreamMessage | string): StreamMessage;
+    constructor(fragment: DocumentFragment);
+}
+
+export interface FetchRequestHeaders {
+    [header: string]: string | undefined;
 }
 
 export class FetchRequest {
     body: FormData | URLSearchParams;
     enctype: "application/x-www-form-urlencoded" | "multipart/form-data" | "text/plain";
     fetchOptions: RequestInit;
-    headers: Headers | { [k: string]: any };
+    headers: FetchRequestHeaders;
     method: "get" | "post" | "put" | "patch" | "delete";
     params: URLSearchParams;
     target: HTMLFormElement | HTMLAnchorElement | FrameElement | null;
@@ -67,19 +109,114 @@ export class FetchResponse {
     succeeded: boolean;
 }
 
+/**
+ * Interface for accessing the browser adapter.
+ * The adapter handles form submission lifecycle events.
+ */
+export interface BrowserAdapter {
+    formSubmissionStarted(formSubmission?: FormSubmission): void;
+    formSubmissionFinished(formSubmission?: FormSubmission): void;
+}
+
+/**
+ * Interface for the Turbo navigator.
+ * Provides methods for programmatic navigation and form submission.
+ */
+export interface Navigator {
+    /**
+     * Submits a form programmatically through Turbo Drive.
+     *
+     * @param form The form element to submit
+     * @param submitter Optional submitter element (button or input)
+     */
+    submitForm(form: HTMLFormElement, submitter?: HTMLElement): void;
+}
+
+/**
+ * Interface for the Turbo page cache.
+ * Provides methods for managing the page cache.
+ */
+export interface Cache {
+    /**
+     * Removes all entries from the Turbo Drive page cache.
+     * Call this when state has changed on the server that may affect cached pages.
+     */
+    clear(): void;
+
+    /**
+     * Resets the cache control meta tag to allow normal caching.
+     */
+    resetCacheControl(): void;
+
+    /**
+     * Sets the cache control meta tag to "no-cache", preventing the page from being cached.
+     */
+    exemptPageFromCache(): void;
+
+    /**
+     * Sets the cache control meta tag to "no-preview", preventing the page from being used as a preview.
+     */
+    exemptPageFromPreview(): void;
+}
+
+/**
+ * Configuration for Turbo Drive.
+ */
+export interface DriveConfig {
+    /** Whether Turbo Drive is enabled. Defaults to true. */
+    enabled: boolean;
+    /** Delay in milliseconds before showing the progress bar. Defaults to 500. */
+    progressBarDelay: number;
+    /** Set of file extensions that should not be handled by Turbo Drive. */
+    unvisitableExtensions: Set<string>;
+}
+
+/**
+ * Submitter configuration callbacks for form submission.
+ */
+export interface SubmitterConfig {
+    /** Called before form submission to disable the submitter. */
+    beforeSubmit(submitter: HTMLElement): void;
+    /** Called after form submission to re-enable the submitter. */
+    afterSubmit(submitter: HTMLElement): void;
+}
+
+/**
+ * Configuration for Turbo form handling.
+ */
+export interface FormsConfig {
+    /** Form handling mode: "on" (default), "off", or "optin". */
+    mode: "on" | "off" | "optin";
+    /** Custom confirmation method. Falls back to window.confirm if not defined. */
+    confirm?: (message: string, element: HTMLFormElement, submitter: HTMLElement | null) => Promise<boolean>;
+    /**
+     * Controls how submitters are disabled during form submission.
+     * Can be "disabled" (default), "aria-disabled", or a custom SubmitterConfig.
+     */
+    submitter: "disabled" | "aria-disabled" | SubmitterConfig;
+}
+
+/**
+ * The Turbo configuration object.
+ */
+export interface TurboConfig {
+    drive: DriveConfig;
+    forms: FormsConfig;
+}
+
 /**
  * Connects a stream source to the main session.
  *
  * @param source Stream source to connect
  */
-export function connectStreamSource(source: unknown): void;
+export function connectStreamSource(source: StreamSource): void;
 
 /**
  * Disconnects a stream source from the main session.
  *
  * @param source Stream source to disconnect
  */
-export function disconnectStreamSource(source: unknown): void;
+export function disconnectStreamSource(source: StreamSource): void;
 
 /**
  * Renders a stream message to the main session by appending it to the
@@ -87,13 +224,14 @@ export function disconnectStreamSource(source: unknown): void;
  *
  * @param message Message to render
  */
-export function renderStreamMessage(message: unknown): void;
+export function renderStreamMessage(message: StreamMessage | string): void;
 
 export interface TurboSession {
-    connectStreamSource(source: unknown): void;
-    disconnectStreamSource(source: unknown): void;
-    renderStreamMessage(message: unknown): void;
+    connectStreamSource(source: StreamSource): void;
+    disconnectStreamSource(source: StreamSource): void;
+    renderStreamMessage(message: StreamMessage | string): void;
     drive: boolean;
+    adapter: BrowserAdapter;
 }
 
 export const StreamActions: {
@@ -107,6 +245,93 @@ export interface VisitOptions {
 }
 export function visit(location: string, options?: VisitOptions): void;
 
+/**
+ * Starts the main Turbo session.
+ * This initializes observers to monitor link interactions.
+ */
+export function start(): void;
+
+/**
+ * Registers an adapter for the main session.
+ *
+ * @param adapter Adapter to register
+ */
+export function registerAdapter(adapter: unknown): void;
+
+/**
+ * Sets the form mode for Turbo Drive.
+ *
+ * @param mode Form handling mode
+ * @deprecated Use `Turbo.config.forms.mode = mode` instead.
+ */
+export function setFormMode(mode: "on" | "off" | "optin"): void;
+
+/**
+ * Options for morphing elements.
+ */
+export interface MorphOptions {
+    callbacks?: {
+        beforeNodeMorphed?: (currentElement: Element, newElement: Element) => boolean;
+    };
+    morphStyle?: "innerHTML" | "outerHTML";
+}
+
+/**
+ * Morph the state of the currentElement based on the attributes and contents of
+ * the newElement. Morphing may dispatch turbo:before-morph-element,
+ * turbo:before-morph-attribute, and turbo:morph-element events.
+ *
+ * @param currentElement Element destination of morphing changes
+ * @param newElement Element source of morphing changes
+ * @param options Optional morphing options
+ */
+export function morphElements(currentElement: Element, newElement: Element | ChildNode[], options?: MorphOptions): void;
+
+/**
+ * Morph the child elements of the currentElement based on the child elements of
+ * the newElement. Morphing children may dispatch turbo:before-morph-element,
+ * turbo:before-morph-attribute, and turbo:morph-element events.
+ *
+ * @param currentElement Element destination of morphing children changes
+ * @param newElement Element source of morphing children changes
+ * @param options Optional morphing options
+ */
+export function morphChildren(currentElement: Element, newElement: Element, options?: MorphOptions): void;
+
+/**
+ * Morph the state of the currentBody based on the attributes and contents of
+ * the newBody. Morphing body elements may dispatch turbo:morph,
+ * turbo:before-morph-element, turbo:before-morph-attribute, and
+ * turbo:morph-element events.
+ *
+ * @param currentBody HTMLBodyElement destination of morphing changes
+ * @param newBody HTMLBodyElement source of morphing changes
+ */
+export function morphBodyElements(currentBody: HTMLBodyElement, newBody: HTMLBodyElement): void;
+
+/**
+ * Morph the child elements of the currentFrame based on the child elements of
+ * the newFrame. Morphing turbo-frame elements may dispatch turbo:before-frame-morph,
+ * turbo:before-morph-element, turbo:before-morph-attribute, and
+ * turbo:morph-element events.
+ *
+ * @param currentFrame FrameElement destination of morphing children changes
+ * @param newFrame FrameElement source of morphing children changes
+ */
+export function morphTurboFrameElements(currentFrame: FrameElement, newFrame: FrameElement): void;
+
+/** The Turbo session navigator */
+export const navigator: Navigator;
+
+/** The Turbo page cache */
+export const cache: Cache;
+
+/** The Turbo configuration object */
+export const config: TurboConfig;
+
+/** The Turbo session */
+export const session: TurboSession;
+
 export interface TurboGlobal {
     /**
      * Sets the delay after which the {@link https://turbo.hotwired.dev/handbook/drive#displaying-progress progress bar} will appear during navigation, in milliseconds.
@@ -115,23 +340,61 @@ export interface TurboGlobal {
      * Note that this method has no effect when used with the iOS or Android adapters.
      *
      * @param delayInMilliseconds
+     * @deprecated Use `Turbo.config.drive.progressBarDelay = delayInMilliseconds` instead.
      */
     setProgressBarDelay(delayInMilliseconds: number): void;
 
     /**
      * Sets the method that is called by links decorated with {@link https://turbo.hotwired.dev/handbook/drive#requiring-confirmation-for-a-visit data-turbo-confirm}.
      **
-     * The default is the browser’s built in confirm.
+     * The default is the browser's built in confirm.
      *
      * The method should return true if the visit can proceed.
      *
      * @param confirmMethod
+     * @deprecated Use `Turbo.config.forms.confirm = confirmMethod` instead.
      */
     setConfirmMethod(confirmMethod: () => boolean): void;
 
+    /**
+     * Sets the form mode for Turbo Drive.
+     *
+     * @param mode Form handling mode
+     * @deprecated Use `Turbo.config.forms.mode = mode` instead.
+     */
+    setFormMode(mode: "on" | "off" | "optin"): void;
+
+    /**
+     * Registers an adapter for the main session.
+     *
+     * @param adapter Adapter to register
+     */
+    registerAdapter(adapter: unknown): void;
+
     visit(location: string, options?: { action?: Action; frame?: string }): void;
 
+    /**
+     * Starts the main Turbo session.
+     * This initializes observers to monitor link interactions.
+     */
+    start(): void;
+
+    connectStreamSource(source: StreamSource): void;
+    disconnectStreamSource(source: StreamSource): void;
+    renderStreamMessage(message: StreamMessage | string): void;
+
+    morphElements(currentElement: Element, newElement: Element | ChildNode[], options?: MorphOptions): void;
+    morphChildren(currentElement: Element, newElement: Element, options?: MorphOptions): void;
+    morphBodyElements(currentBody: HTMLBodyElement, newBody: HTMLBodyElement): void;
+    morphTurboFrameElements(currentFrame: FrameElement, newFrame: FrameElement): void;
+
     session: TurboSession;
+    navigator: Navigator;
+    cache: Cache;
+    config: TurboConfig;
+    StreamActions: {
+        [action: string]: (this: StreamElement) => void;
+    };
 }
 
 declare global {
@@ -175,6 +438,31 @@ export type TurboBeforeStreamRenderEvent = CustomEvent<{
     render: Render;
 }>;
 
+export type TurboMorphEvent = CustomEvent<{
+    currentElement: Element;
+    newElement: Element;
+}>;
+
+export type TurboBeforeMorphElementEvent = CustomEvent<{
+    currentElement: Element;
+    newElement: Element;
+}>;
+
+export type TurboMorphElementEvent = CustomEvent<{
+    currentElement: Element;
+    newElement: Element;
+}>;
+
+export type TurboBeforeMorphAttributeEvent = CustomEvent<{
+    attributeName: string;
+    mutationType: "updated" | "removed";
+}>;
+
+export type TurboBeforeFrameMorphEvent = CustomEvent<{
+    currentElement: FrameElement;
+    newElement: FrameElement;
+}>;
+
 export interface FormSubmission {
     action: string;
     body: FormData | URLSearchParams;
@@ -205,9 +493,9 @@ export type TurboFrameMissingEvent = CustomEvent<{
 }>;
 
 export type TurboBeforeFetchRequestEvent = CustomEvent<{
-    fetchOptions: RequestInit;
+    fetchOptions: Omit<RequestInit, "headers"> & { headers: FetchRequestHeaders };
     url: URL;
-    resume: (value: any) => void;
+    resume: (value?: unknown) => void;
 }>;
 
 export type TurboBeforeFetchResponseEvent = CustomEvent<{
@@ -222,6 +510,7 @@ export type TurboFetchRequestErrorEvent = CustomEvent<{
 export interface TurboElementTagNameMap {
     "turbo-frame": FrameElement;
     "turbo-stream": StreamElement;
+    "turbo-stream-source": StreamSourceElement;
 }
 
 export interface TurboElementEventMap {
@@ -247,6 +536,11 @@ export interface TurboGlobalEventHandlersEventMap extends TurboElementEventMap {
     "turbo:render": TurboRenderEvent;
     "turbo:reload": TurboReloadEvent;
     "turbo:visit": TurboVisitEvent;
+    "turbo:morph": TurboMorphEvent;
+    "turbo:before-morph-element": TurboBeforeMorphElementEvent;
+    "turbo:morph-element": TurboMorphElementEvent;
+    "turbo:before-morph-attribute": TurboBeforeMorphAttributeEvent;
+    "turbo:before-frame-morph": TurboBeforeFrameMorphEvent;
 }
 
 declare global {

hotwired__turbo/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@types/hotwired__turbo",
-    "version": "8.0.5",
+    "version": "8.0.7",
     "description": "TypeScript definitions for @hotwired/turbo",
     "homepage": "https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/hotwired__turbo",
     "license": "MIT",
@@ -31,6 +31,6 @@
     "scripts": {},
     "dependencies": {},
     "peerDependencies": {},
-    "typesPublisherContentHash": "7cefcb735be30522b374d78df45635bb5079e0cd2123523fc36ed0c740b534d2",
+    "typesPublisherContentHash": "096a2fd4ffe6909711dc1bf4550cdbc775cdf71010cb71feb54a37794e1478c9",
     "typeScriptVersion": "5.2"
 }