phoenix_live_view 1.2.0 → 1.2.2

package/assets/js/phoenix_live_view/dom.ts

@@ -411,7 +411,9 @@ const DOM = {
             // we also clear the throttle timeout to prevent the callback
             // from being called again after the timeout fires
             clearTimeout(this.private(el, THROTTLED));
-            this.triggerCycle(el, DEBOUNCE_TRIGGER);
+            if (asyncFilter()) {
+              this.triggerCycle(el, DEBOUNCE_TRIGGER);
+            }
           });
         }
     }

package/assets/js/phoenix_live_view/dom_patch.ts

@@ -792,7 +792,7 @@ export default class DOMPatch {
   private transitionPendingRemoves() {
     const { pendingRemoves, liveSocket } = this;
     if (pendingRemoves.length > 0) {
-      liveSocket.transitionRemoves(pendingRemoves, () => {
+      liveSocket.transitionRemoves(pendingRemoves, this.view, () => {
         pendingRemoves.forEach((el) => {
           const child = DOM.firstPhxChild(el);
           if (child) {

package/assets/js/phoenix_live_view/live_socket.ts

@@ -823,12 +823,15 @@ export default class LiveSocket {
     ).filter((el) => !DOM.isChildOfAny(el, stickies));
 
     const newMainEl = DOM.cloneNode(this.outgoingMainEl, "");
-    this.main.showLoader(this.loaderTimeout);
-    this.main.destroy();
+    const oldMainView = this.main;
+    oldMainView.showLoader(this.loaderTimeout);
+    oldMainView.destroy();
 
     this.main = this.newRootView(newMainEl, flash, liveReferer);
     this.main.setRedirect(href);
-    this.transitionRemoves(removeEls);
+    // the old view is destroyed at this point; pass it explicitly so the
+    // phx-remove commands execute in the context of the outgoing view
+    this.transitionRemoves(removeEls, oldMainView);
     this.main.join((joinCount, onDone) => {
       if (joinCount === 1 && this.commitPendingLink(linkRef)) {
         this.requestDOMUpdate(() => {
@@ -845,7 +848,7 @@ export default class LiveSocket {
   }
 
   /** @internal */
-  transitionRemoves(elements, callback?) {
+  transitionRemoves(elements, view: View, callback?) {
     const removeAttr = this.binding("remove");
     const silenceEvents = (e) => {
       e.preventDefault();
@@ -857,7 +860,8 @@ export default class LiveSocket {
       for (const event of this.boundEventNames) {
         el.addEventListener(event, silenceEvents, true);
       }
-      this.execJS(el, el.getAttribute(removeAttr), "remove");
+      const e = new CustomEvent("phx:exec", { detail: { sourceElement: el } });
+      JS.exec(e, "remove", el.getAttribute(removeAttr), view, el);
     });
     // remove the silenced listeners when transitions are done in case the element is re-used
     // and call caller's callback as soon as we are done with transitions
@@ -885,12 +889,15 @@ export default class LiveSocket {
 
   /** @internal */
   owner(childEl: Element, callback?: (view: View) => any) {
-    let view: View;
+    let view: View | undefined;
     const viewEl = DOM.closestViewEl(childEl);
     if (viewEl) {
-      // it can happen that we find a view that is already destroyed;
-      // in that case we DO NOT want to fallback to the main element
-      view = this.getViewByEl(viewEl);
+      // resolve the view by element identity instead of id; during live
+      // navigation the new view is registered under the same id while the
+      // old DOM is still attached, and events from the old DOM must not be
+      // routed to the new view. A destroyed view removes its element binding,
+      // in which case we DO NOT want to fallback to the main element
+      view = DOM.private(viewEl, "view");
     } else {
       if (!childEl.isConnected) {
         // if the element is not part of the DOM any more

package/assets/js/phoenix_live_view/view.ts

@@ -408,6 +408,7 @@ export default class View {
     if (container) {
       const [tag, attrs] = container;
       this.el = DOM.replaceRootContainer(this.el, tag, attrs);
+      DOM.putPrivate(this.el, "view", this);
     }
     this.childJoins = 0;
     this.joinPending = true;
@@ -516,7 +517,10 @@ export default class View {
     if (!el) {
       throw new Error("unable to find root element for view");
     }
+    // child views are initially bound to an element inside the join HTML
+    // fragment (see onJoinComplete), so the binding must move to the real el
     this.el = el;
+    DOM.putPrivate(this.el, "view", this);
     this.el.setAttribute(PHX_ROOT_ID, this.root.id);
   }
 
@@ -746,6 +750,7 @@ export default class View {
     });
 
     // because we work with a template element, we must manually copy the attributes
+    // and bind the template root to this view,
     // otherwise the owner / target helpers don't work properly
     const rootEl = template.content.firstElementChild!;
     rootEl.id = this.id;
@@ -753,6 +758,7 @@ export default class View {
     rootEl.setAttribute(PHX_SESSION, this.getSession());
     rootEl.setAttribute(PHX_STATIC, this.getStatic() ?? "");
     this.parent && rootEl.setAttribute(PHX_PARENT_ID, this.parent.id);
+    DOM.putPrivate(rootEl, "view", this);
 
     // we go over all form elements in the new HTML for the LV
     // and look for old forms in the `formsForRecovery` object;

package/assets/js/types/assets/js/phoenix_live_view/aria.d.ts

@@ -0,0 +1,9 @@
+declare const ARIA: {
+    anyOf(instance: unknown, classes: (new (...args: any[]) => unknown)[]): boolean;
+    isFocusable(el: Element, interactiveOnly?: boolean): boolean;
+    attemptFocus(el: Element, interactiveOnly?: boolean): boolean;
+    focusFirstInteractive(el: Element): boolean;
+    focusFirst(el: Element): boolean;
+    focusLast(el: Element): boolean;
+};
+export default ARIA;

package/assets/js/types/assets/js/phoenix_live_view/browser.d.ts

@@ -0,0 +1,20 @@
+declare const Browser: {
+    canPushState(): boolean;
+    dropLocal(localStorage: any, namespace: any, subkey: any): any;
+    updateLocal(localStorage: any, namespace: any, subkey: any, initial: any, func: any): any;
+    getLocal(localStorage: any, namespace: any, subkey: any): any;
+    updateCurrentState(callback: any): void;
+    pushState(kind: "replace" | "push", meta: {
+        type: string;
+        scroll?: number;
+        id?: string;
+        position?: number;
+    }, to?: string): void;
+    setCookie(name: string, value: string | number, maxAgeSeconds?: number): void;
+    getCookie(name: string): string;
+    deleteCookie(name: string): void;
+    redirect(toURL: string, flash?: string | null, navigate?: (url: string) => void): void;
+    localKey(namespace: any, subkey: any): string;
+    getHashTargetEl(maybeHash: any): HTMLElement;
+};
+export default Browser;

package/assets/js/types/assets/js/phoenix_live_view/constants.d.ts

@@ -0,0 +1,98 @@
+export declare const CONSECUTIVE_RELOADS = "consecutive-reloads";
+export declare const MAX_RELOADS = 10;
+export declare const RELOAD_JITTER_MIN = 5000;
+export declare const RELOAD_JITTER_MAX = 10000;
+export declare const FAILSAFE_JITTER = 30000;
+export declare const PHX_EVENT_CLASSES: string[];
+export declare const PHX_DROP_TARGET_ACTIVE_CLASS = "phx-drop-target-active";
+export declare const PHX_COMPONENT = "data-phx-component";
+export declare const PHX_VIEW_REF = "data-phx-view";
+export declare const PHX_LIVE_LINK = "data-phx-link";
+export declare const PHX_TRACK_STATIC = "track-static";
+export declare const PHX_LINK_STATE = "data-phx-link-state";
+export declare const PHX_REF_LOADING = "data-phx-ref-loading";
+export declare const PHX_REF_SRC = "data-phx-ref-src";
+export declare const PHX_REF_LOCK = "data-phx-ref-lock";
+export declare const PHX_PENDING_REFS = "phx-pending-refs";
+export declare const PHX_TRACK_UPLOADS = "track-uploads";
+export declare const PHX_UPLOAD_REF = "data-phx-upload-ref";
+export declare const PHX_PREFLIGHTED_REFS = "data-phx-preflighted-refs";
+export declare const PHX_DONE_REFS = "data-phx-done-refs";
+export declare const PHX_DROP_TARGET = "drop-target";
+export declare const PHX_ACTIVE_ENTRY_REFS = "data-phx-active-refs";
+export declare const PHX_LIVE_FILE_UPDATED = "phx:live-file:updated";
+export declare const PHX_SKIP = "data-phx-skip";
+export declare const PHX_MAGIC_ID = "data-phx-id";
+export declare const PHX_PRUNE = "data-phx-prune";
+export declare const PHX_CONNECTED_CLASS = "phx-connected";
+export declare const PHX_LOADING_CLASS = "phx-loading";
+export declare const PHX_ERROR_CLASS = "phx-error";
+export declare const PHX_CLIENT_ERROR_CLASS = "phx-client-error";
+export declare const PHX_SERVER_ERROR_CLASS = "phx-server-error";
+export declare const PHX_PARENT_ID = "data-phx-parent-id";
+export declare const PHX_MAIN = "data-phx-main";
+export declare const PHX_ROOT_ID = "data-phx-root-id";
+export declare const PHX_VIEWPORT_TOP = "viewport-top";
+export declare const PHX_VIEWPORT_BOTTOM = "viewport-bottom";
+export declare const PHX_VIEWPORT_OVERRUN_TARGET = "viewport-overrun-target";
+export declare const PHX_TRIGGER_ACTION = "trigger-action";
+export declare const PHX_HAS_FOCUSED = "phx-has-focused";
+export declare const FOCUSABLE_INPUTS: string[];
+export declare const CHECKABLE_INPUTS: string[];
+export declare const PHX_HAS_SUBMITTED = "phx-has-submitted";
+export declare const PHX_SESSION = "data-phx-session";
+export declare const PHX_VIEW_SELECTOR = "[data-phx-session]";
+export declare const PHX_STICKY = "data-phx-sticky";
+export declare const PHX_STATIC = "data-phx-static";
+export declare const PHX_READONLY = "data-phx-readonly";
+export declare const PHX_DISABLED = "data-phx-disabled";
+export declare const PHX_DISABLE_WITH = "disable-with";
+export declare const PHX_DISABLE_WITH_RESTORE = "data-phx-disable-with-restore";
+export declare const PHX_HOOK = "hook";
+export declare const PHX_DEBOUNCE = "debounce";
+export declare const PHX_THROTTLE = "throttle";
+export declare const PHX_UPDATE = "update";
+export declare const PHX_STREAM = "stream";
+export declare const PHX_STREAM_REF = "data-phx-stream";
+export declare const PHX_PORTAL = "data-phx-portal";
+export declare const PHX_TELEPORTED_REF = "data-phx-teleported";
+export declare const PHX_TELEPORTED_SRC = "data-phx-teleported-src";
+export declare const PHX_RUNTIME_HOOK = "data-phx-runtime-hook";
+export declare const PHX_LV_PID = "data-phx-pid";
+export declare const PHX_KEY = "key";
+export declare const PHX_PRIVATE = "phxPrivate";
+export declare const PHX_AUTO_RECOVER = "auto-recover";
+export declare const PHX_NO_UNUSED_FIELD = "no-unused-field";
+export declare const PHX_LV_DEBUG = "phx:live-socket:debug";
+export declare const PHX_LV_PROFILE = "phx:live-socket:profiling";
+export declare const PHX_LV_LATENCY_SIM = "phx:live-socket:latency-sim";
+export declare const PHX_LV_HISTORY_POSITION = "phx:nav-history-position";
+export declare const PHX_PROGRESS = "progress";
+export declare const PHX_MOUNTED = "mounted";
+export declare const PHX_RELOAD_STATUS = "__phoenix_reload_status__";
+export declare const LOADER_TIMEOUT = 1;
+export declare const MAX_CHILD_JOIN_ATTEMPTS = 3;
+export declare const BEFORE_UNLOAD_LOADER_TIMEOUT = 200;
+export declare const DISCONNECTED_TIMEOUT = 500;
+export declare const BINDING_PREFIX = "phx-";
+export declare const PUSH_TIMEOUT = 30000;
+export declare const LINK_HEADER = "x-requested-with";
+export declare const RESPONSE_URL_HEADER = "x-response-url";
+export declare const DEBOUNCE_TRIGGER = "debounce-trigger";
+export declare const THROTTLED = "throttled";
+export declare const DEBOUNCE_PREV_KEY = "debounce-prev-key";
+export declare const DEFAULTS: {
+    debounce: number;
+    throttle: number;
+};
+export declare const PHX_PENDING_ATTRS: string[];
+export declare const STATIC = "s";
+export declare const ROOT = "r";
+export declare const COMPONENTS = "c";
+export declare const KEYED = "k";
+export declare const KEYED_COUNT = "kc";
+export declare const EVENTS = "e";
+export declare const REPLY = "r";
+export declare const TITLE = "t";
+export declare const TEMPLATES = "p";
+export declare const STREAM = "stream";

package/assets/js/types/assets/js/phoenix_live_view/dom.d.ts

@@ -0,0 +1,82 @@
+export type FormInputLike = HTMLElement & {
+    readonly form?: HTMLFormElement | null;
+    readonly type?: string;
+    readonly validity?: ValidityState;
+    readonly name?: string;
+};
+export type QueryableNode = Element | Document | DocumentFragment;
+declare const DOM: {
+    byId(id: any): void | HTMLElement;
+    elementFromTarget(target: EventTarget): Element | null;
+    removeClass(el: any, className: any): void;
+    all(node: QueryableNode | null, query: string, callback?: (el: Element) => void): Element[];
+    childNodeLength(html: any): number;
+    isUploadInput(el: any): el is HTMLInputElement;
+    isAutoUpload(inputEl: any): any;
+    findUploadInputs(node: any): HTMLInputElement[];
+    findComponent(viewId: string, cid: string | number, doc?: QueryableNode): Element | null;
+    getComponent(viewId: string, cid: number, doc?: QueryableNode): Element;
+    isPhxDestroyed(node: any): boolean;
+    wantsNewTab(e: any): any;
+    isUnloadableFormSubmit(e: any): boolean;
+    isNewPageClick(e: any, currentLocation: any): any;
+    markPhxChildDestroyed(el: any): void;
+    findPhxChildrenInFragment(html: any, parentId: any): any;
+    isIgnored(el: any, phxUpdate: any): boolean;
+    isPhxUpdate(el: any, phxUpdate: any, updateTypes: any): boolean;
+    findPhxSticky(el: any): any;
+    findPhxChildren(el: any, parentId: any): any;
+    findExistingParentCIDs(viewId: any, cids: any): Set<unknown>;
+    private(el: any, key: any): any;
+    deletePrivate(el: any, key: any): void;
+    putPrivate(el: any, key: any, value: any): void;
+    updatePrivate(el: any, key: any, defaultVal: any, updateFunc: any): void;
+    syncPendingAttrs(fromEl: any, toEl: any): void;
+    copyPrivates(target: any, source: any): void;
+    putTitle(str: any): void;
+    debounce(el: any, event: any, phxDebounce: any, defaultDebounce: any, phxThrottle: any, defaultThrottle: any, asyncFilter: any, callback: any): any;
+    triggerCycle(el: any, key: any, currentCycle?: any): void;
+    once(el: any, key: any): boolean;
+    incCycle(el: any, key: any, trigger?: () => void): any;
+    maintainPrivateHooks(fromEl: any, toEl: any, phxViewportTop: any, phxViewportBottom: any): void;
+    putCustomElHook(el: any, hook: any): void;
+    getCustomElHook(el: any): any;
+    isUsedInput(el: any): any;
+    resetForm(form: any): void;
+    isPhxChild(node: any): any;
+    isPhxSticky(node: any): boolean;
+    isChildOfAny(el: any, parents: any): boolean;
+    firstPhxChild(el: any): any;
+    isPortalTemplate(el: any): el is HTMLTemplateElement;
+    closestViewEl(el: any): any;
+    dispatchEvent(target: any, name: any, opts?: {
+        bubbles?: boolean;
+        detail?: any;
+    }): void;
+    cloneNode(node: any, html: any): any;
+    mergeAttrs(target: any, source: any, opts?: {
+        exclude?: string[];
+        isIgnored?: boolean;
+    }): void;
+    mergeFocusedInput(target: any, source: any): void;
+    hasSelectionRange(el: any): el is HTMLInputElement | HTMLTextAreaElement;
+    restoreFocus(focused: any, selectionStart: any, selectionEnd: any): void;
+    /**
+     * Returns true if the element is an input that can be focused and edited by the user,
+     * so we can skip patching it if it has focus.
+     */
+    isEditableInput(el: Element | EventTarget | null): el is FormInputLike;
+    isFormAssociated(el: Element | EventTarget | null): el is FormInputLike;
+    syncAttrsToProps(el: any): void;
+    isTextualInput(el: any): boolean;
+    isNowTriggerFormExternal(el: any, phxTriggerExternal: any): boolean;
+    cleanChildNodes(container: Element, phxUpdate: string): void;
+    replaceRootContainer(container: Element, tagName: string, attrs: Record<string, string>): Element;
+    getSticky(el: any, name: any, defaultVal: any): any;
+    deleteSticky(el: any, name: any): void;
+    putSticky(el: any, name: any, op: any): void;
+    applyStickyOperations(el: any): void;
+    isLocked(el: any): any;
+    attributeIgnored(attribute: any, ignoredAttributes: any): any;
+};
+export default DOM;

package/assets/js/types/assets/js/phoenix_live_view/dom_patch.d.ts

@@ -0,0 +1,65 @@
+import View from "./view";
+type Stream = Set<any>;
+type BeforeUpdatedCallback = (fromEl: Element, toEl: Element) => void;
+type AfterAddedCallback = (el: Node) => void;
+type AfterUpdatedCallback = (el: Element) => void;
+type AfterPhxChildAddedCallback = (el: Element) => void;
+type AfterDiscardedCallback = (el: Node) => void;
+type AfterTransitionsDiscardedCallback = (els: Element[]) => void;
+export default class DOMPatch {
+    private view;
+    private liveSocket;
+    private container;
+    private rootID;
+    private html;
+    private streams;
+    private streamInserts;
+    private streamComponentRestore;
+    private targetCID;
+    private pendingRemoves;
+    private phxRemove;
+    private targetContainer;
+    private beforeUpdatedCallbacks;
+    private afterAddedCallbacks;
+    private afterUpdatedCallbacks;
+    private afterPhxChildAddedCallbacks;
+    private afterDiscardedCallbacks;
+    private afterTransitionsDiscardedCallbacks;
+    private withChildren;
+    private undoRef;
+    constructor(view: View, container: Element, html: string | Node, streams: Set<Stream>, targetCID: number | null, opts?: {
+        withChildren?: boolean;
+        undoRef?: number;
+    });
+    beforeUpdated(callback: BeforeUpdatedCallback): void;
+    afterAdded(callback: AfterAddedCallback): void;
+    afterUpdated(callback: AfterUpdatedCallback): void;
+    afterPhxChildAdded(callback: AfterPhxChildAddedCallback): void;
+    afterDiscarded(callback: AfterDiscardedCallback): void;
+    afterTransitionsDiscarded(callback: AfterTransitionsDiscardedCallback): void;
+    markPrunableContentForRemoval(): void;
+    perform(isJoinPatch: any): boolean;
+    private trackBeforeUpdated;
+    private trackAfterAdded;
+    private trackAfterUpdated;
+    private trackAfterPhxChildAdded;
+    private trackAfterDiscarded;
+    private trackAfterTransitionsDiscarded;
+    private onNodeDiscarded;
+    private maybePendingRemove;
+    private removeStreamChildElement;
+    private getStreamInsert;
+    private setStreamRef;
+    private maybeReOrderStream;
+    private moveOrInsertBefore;
+    private maybeLimitStream;
+    private transitionPendingRemoves;
+    private isChangedSelect;
+    private skipCIDSibling;
+    private maybeCloneLockedElement;
+    private copyNestedPrivateLock;
+    private indexOf;
+    private teleport;
+    private handleRuntimeHook;
+}
+export {};

package/assets/js/types/assets/js/phoenix_live_view/dom_post_morph_restorer.d.ts

@@ -0,0 +1,8 @@
+export default class DOMPostMorphRestorer {
+    private containerId;
+    private updateType;
+    private elementsToModify;
+    private elementIdsToAdd;
+    constructor(containerBefore: Element, containerAfter: Element, updateType: "append" | "prepend");
+    perform(): void;
+}

package/assets/js/types/assets/js/phoenix_live_view/element_ref.d.ts

@@ -0,0 +1,14 @@
+export default class ElementRef {
+    static onUnlock(el: any, callback: any): any;
+    private el;
+    private loadingRef;
+    private lockRef;
+    constructor(el: Element);
+    maybeUndo(ref: any, phxEvent: any, eachCloneCallback: any): void;
+    private isWithin;
+    private undoLocks;
+    private undoLoading;
+    private isLoadingUndoneBy;
+    private isFullyResolvedBy;
+    private canUndoLoading;
+}

package/assets/js/types/assets/js/phoenix_live_view/entry_uploader.d.ts

@@ -0,0 +1,16 @@
+export default class EntryUploader {
+    constructor(entry: any, config: any, liveSocket: any);
+    liveSocket: any;
+    entry: any;
+    offset: number;
+    chunkSize: any;
+    chunkTimeout: any;
+    chunkTimer: NodeJS.Timeout;
+    errored: boolean;
+    uploadChannel: any;
+    error(reason: any): void;
+    upload(): void;
+    isDone(): boolean;
+    readNextChunk(): void;
+    pushChunk(chunk: any): void;
+}

package/assets/js/types/assets/js/phoenix_live_view/hooks.d.ts

@@ -0,0 +1,3 @@
+import type { Hook } from "./view_hook";
+declare const Hooks: Record<string, Hook<any, any>>;
+export default Hooks;

package/assets/js/types/assets/js/phoenix_live_view/index.d.ts

@@ -0,0 +1,48 @@
+import LiveSocket, { type LiveSocketOptions, isUsedInput } from "./live_socket";
+import { ViewHook } from "./view_hook";
+import type { EncodedJS } from "./js_commands";
+import type { Hook, HooksOptions, HookInterface } from "./view_hook";
+export type { LiveSocketOptions, HookInterface, HooksOptions, EncodedJS };
+/** Creates a hook instance for the given element and callbacks.
+ *
+ * @param el - The element to associate with the hook.
+ * @param callbacks - The list of hook callbacks, such as mounted,
+ *   updated, destroyed, etc.
+ *
+ * *Note*: `createHook` must be called from the `connectedCallback` lifecycle
+ * which is triggered after the element has been added to the DOM. If you try
+ * to call `createHook` from the constructor, an error will be logged.
+ *
+ * Furthermore, you can only start using the hook's APIs after the `mounted`
+ * callback of the hook has been called. If you try to call them earlier,
+ * an error will be logged.
+ *
+ * @example
+ *
+ * class MyComponent extends HTMLElement {
+ *   connectedCallback(){
+ *     let onLiveViewMounted = () => this.hook.pushEvent(...))
+ *     this.hook = createHook(this, {mounted: onLiveViewMounted})
+ *   }
+ * }
+ *
+ * @returns Returns the Hook instance for the custom element.
+ *
+ * @category JavaScript Hooks
+ */
+declare function createHook(el: HTMLElement, callbacks: Hook): ViewHook;
+/** Returns an object URL for the file matching the given upload ref,
+ * or `null` if no matching file is found.
+ *
+ * @param input - The file input element associated with the upload.
+ * @param uploadRef - The upload ref identifying the file entry.
+ *
+ * @example
+ *
+ * import { getFileURLForUpload } from "phoenix_live_view"
+ *
+ * let url = getFileURLForUpload(inputEl, uploadRef)
+ * if (url) { imgEl.src = url }
+ */
+declare function getFileURLForUpload(input: HTMLElement, uploadRef: string): string | null;
+export { LiveSocket, isUsedInput, createHook, ViewHook, Hook, getFileURLForUpload, };

package/assets/js/types/assets/js/phoenix_live_view/js.d.ts

@@ -0,0 +1,99 @@
+export default JS;
+declare namespace JS {
+    function exec(e: any, eventType: any, phxEvent: any, view: any, sourceEl: any, defaults: any): void;
+    function isVisible(el: any): boolean;
+    function isInViewport(el: any): boolean;
+    function exec_exec(e: any, eventType: any, phxEvent: any, view: any, sourceEl: any, el: any, { attr, to }: {
+        attr: any;
+        to: any;
+    }): void;
+    function exec_dispatch(e: any, eventType: any, phxEvent: any, view: any, sourceEl: any, el: any, { event, detail, bubbles, blocking }: {
+        event: any;
+        detail: any;
+        bubbles: any;
+        blocking: any;
+    }): void;
+    function exec_push(e: any, eventType: any, phxEvent: any, view: any, sourceEl: any, el: any, args: any): void;
+    function exec_navigate(e: any, eventType: any, phxEvent: any, view: any, sourceEl: any, el: any, { href, replace }: {
+        href: any;
+        replace: any;
+    }): void;
+    function exec_patch(e: any, eventType: any, phxEvent: any, view: any, sourceEl: any, el: any, { href, replace }: {
+        href: any;
+        replace: any;
+    }): void;
+    function exec_focus(e: any, eventType: any, phxEvent: any, view: any, sourceEl: any, el: any): void;
+    function exec_focus_first(e: any, eventType: any, phxEvent: any, view: any, sourceEl: any, el: any): void;
+    function exec_push_focus(e: any, eventType: any, phxEvent: any, view: any, sourceEl: any, el: any): void;
+    function exec_pop_focus(_e: any, _eventType: any, _phxEvent: any, _view: any, _sourceEl: any, _el: any): void;
+    function exec_add_class(e: any, eventType: any, phxEvent: any, view: any, sourceEl: any, el: any, { names, transition, time, blocking }: {
+        names: any;
+        transition: any;
+        time: any;
+        blocking: any;
+    }): void;
+    function exec_remove_class(e: any, eventType: any, phxEvent: any, view: any, sourceEl: any, el: any, { names, transition, time, blocking }: {
+        names: any;
+        transition: any;
+        time: any;
+        blocking: any;
+    }): void;
+    function exec_toggle_class(e: any, eventType: any, phxEvent: any, view: any, sourceEl: any, el: any, { names, transition, time, blocking }: {
+        names: any;
+        transition: any;
+        time: any;
+        blocking: any;
+    }): void;
+    function exec_toggle_attr(e: any, eventType: any, phxEvent: any, view: any, sourceEl: any, el: any, { attr: [attr, val1, val2] }: {
+        attr: [any, any, any];
+    }): void;
+    function exec_ignore_attrs(e: any, eventType: any, phxEvent: any, view: any, sourceEl: any, el: any, { attrs }: {
+        attrs: any;
+    }): void;
+    function exec_transition(e: any, eventType: any, phxEvent: any, view: any, sourceEl: any, el: any, { time, transition, blocking }: {
+        time: any;
+        transition: any;
+        blocking: any;
+    }): void;
+    function exec_toggle(e: any, eventType: any, phxEvent: any, view: any, sourceEl: any, el: any, { display, ins, outs, time, blocking }: {
+        display: any;
+        ins: any;
+        outs: any;
+        time: any;
+        blocking: any;
+    }): void;
+    function exec_show(e: any, eventType: any, phxEvent: any, view: any, sourceEl: any, el: any, { display, transition, time, blocking }: {
+        display: any;
+        transition: any;
+        time: any;
+        blocking: any;
+    }): void;
+    function exec_hide(e: any, eventType: any, phxEvent: any, view: any, sourceEl: any, el: any, { display, transition, time, blocking }: {
+        display: any;
+        transition: any;
+        time: any;
+        blocking: any;
+    }): void;
+    function exec_set_attr(e: any, eventType: any, phxEvent: any, view: any, sourceEl: any, el: any, { attr: [attr, val] }: {
+        attr: [any, any];
+    }): void;
+    function exec_remove_attr(e: any, eventType: any, phxEvent: any, view: any, sourceEl: any, el: any, { attr }: {
+        attr: any;
+    }): void;
+    function ignoreAttrs(el: any, attrs: any): void;
+    function onBeforeElUpdated(fromEl: any, toEl: any): void;
+    function show(eventType: any, view: any, el: any, display: any, transition: any, time: any, blocking: any): void;
+    function hide(eventType: any, view: any, el: any, display: any, transition: any, time: any, blocking: any): void;
+    function toggle(eventType: any, view: any, el: any, display: any, ins: any, outs: any, time: any, blocking: any): void;
+    function toggleClasses(el: any, classes: any, transition: any, time: any, view: any, blocking: any): void;
+    function toggleAttr(el: any, attr: any, val1: any, val2: any): void;
+    function addOrRemoveClasses(el: any, adds: any, removes: any, transition: any, time: any, view: any, blocking: any): void;
+    function setOrRemoveAttrs(el: any, sets: any, removes: any): void;
+    function hasAllClasses(el: any, classes: any): any;
+    function isToggledOut(el: any, outClasses: any): any;
+    function filterToEls(liveSocket: any, sourceEl: any, { to }: {
+        to: any;
+    }): any;
+    function defaultDisplay(el: any): any;
+    function transitionClasses(val: any): any[];
+}