[Live] Add data-error attribute + fix loading behaviour on error

src/LiveComponent/assets/dist/Component/plugins/ErrorPlugin.d.ts

@@ -0,0 +1,27 @@
+import type { Component } from '../../live_controller';
+import type { PluginInterface } from './PluginInterface';
+export default class ErrorPlugin implements PluginInterface {
+    static errorAttribute: string;
+    static isErrorAttribute: string;
+    static supportedActions: {
+        show: string;
+        hide: string;
+        addClass: string;
+        removeClass: string;
+        addAttribute: string;
+        removeAttribute: string;
+    };
+    attachToComponent(component: Component): void;
+    showErrors(component: Component): void;
+    hideErrors(component: Component): void;
+    private handleErrorToggle;
+    private handleErrorDirective;
+    private getErrorDirectives;
+    private parseErrorAction;
+    private showElement;
+    private hideElement;
+    private addClass;
+    private removeClass;
+    private addAttributes;
+    private removeAttributes;
+}

src/LiveComponent/assets/dist/Component/plugins/LoadingPlugin.d.ts

@@ -1,23 +1,18 @@
-import { Directive } from '../../Directive/directives_parser';
+import { ElementDirectives } from '../../Directive/directives_parser';
 import BackendRequest from '../../Backend/BackendRequest';
 import Component from '../../Component';
 import { PluginInterface } from './PluginInterface';
-interface ElementLoadingDirectives {
-    element: HTMLElement | SVGElement;
-    directives: Directive[];
-}
 export default class implements PluginInterface {
     attachToComponent(component: Component): void;
     startLoading(component: Component, targetElement: HTMLElement | SVGElement, backendRequest: BackendRequest): void;
     finishLoading(component: Component, targetElement: HTMLElement | SVGElement): void;
     private handleLoadingToggle;
     private handleLoadingDirective;
-    getLoadingDirectives(component: Component, element: HTMLElement | SVGElement): ElementLoadingDirectives[];
+    getLoadingDirectives(component: Component, element: HTMLElement | SVGElement): ElementDirectives[];
     private showElement;
     private hideElement;
     private addClass;
     private removeClass;
     private addAttributes;
     private removeAttributes;
 }
-export {};

src/LiveComponent/assets/dist/Directive/directives_parser.d.ts

@@ -10,4 +10,8 @@ export interface Directive {
         (): string;
     };
 }
+export interface ElementDirectives {
+    element: HTMLElement | SVGElement;
+    directives: Directive[];
+}
 export declare function parseDirectives(content: string | null): Directive[];

src/LiveComponent/assets/dist/live_controller.js

@@ -2059,12 +2059,17 @@ class Component {
             if (!((_a = headers.get('Content-Type')) === null || _a === void 0 ? void 0 : _a.includes('application/vnd.live-component+html')) && !headers.get('X-Live-Redirect')) {
                 const controls = { displayError: true };
                 this.valueStore.pushPendingPropsBackToDirty();
+                this.hooks.triggerHook('loading.state:finished', this.element);
                 this.hooks.triggerHook('response:error', backendResponse, controls);
                 if (controls.displayError) {
                     this.renderError(html);
                 }
                 this.backendRequest = null;
                 thisPromiseResolve(backendResponse);
+                if (this.isRequestPending) {
+                    this.isRequestPending = false;
+                    this.performRequest();
+                }
                 return response;
             }
             this.processRerender(html, backendResponse);
@@ -2949,6 +2954,139 @@ class LazyPlugin {
     }
 }
 
+class ErrorPlugin {
+    attachToComponent(component) {
+        component.on('response:error', () => {
+            this.showErrors(component);
+        });
+        component.on('request:started', () => {
+            this.hideErrors(component);
+        });
+        this.hideErrors(component);
+    }
+    showErrors(component) {
+        this.handleErrorToggle(component, true, component.element);
+    }
+    hideErrors(component) {
+        this.handleErrorToggle(component, false, component.element);
+    }
+    handleErrorToggle(component, isError, targetElement) {
+        this.getErrorDirectives(component, targetElement).forEach(({ element, directives }) => {
+            if (isError) {
+                this.addAttributes(element, [ErrorPlugin.isErrorAttribute]);
+            }
+            else {
+                this.removeAttributes(element, [ErrorPlugin.isErrorAttribute]);
+            }
+            directives.forEach((directive) => {
+                this.handleErrorDirective(element, isError, directive);
+            });
+        });
+    }
+    handleErrorDirective(element, isError, directive) {
+        const finalAction = this.parseErrorAction(directive.action, isError);
+        switch (finalAction) {
+            case ErrorPlugin.supportedActions.show:
+                this.showElement(element);
+                break;
+            case ErrorPlugin.supportedActions.hide:
+                this.hideElement(element);
+                break;
+            case ErrorPlugin.supportedActions.addClass:
+                this.addClass(element, directive.args);
+                break;
+            case ErrorPlugin.supportedActions.removeClass:
+                this.removeClass(element, directive.args);
+                break;
+            case ErrorPlugin.supportedActions.addAttribute:
+                this.addAttributes(element, directive.args);
+                break;
+            case ErrorPlugin.supportedActions.removeAttribute:
+                this.removeAttributes(element, directive.args);
+                break;
+            default:
+                throw new Error(`Unknown ${ErrorPlugin.errorAttribute} action "${finalAction}". Supported actions are: ${Object.values(`"${ErrorPlugin.supportedActions}"`).join(', ')}.`);
+        }
+    }
+    getErrorDirectives(component, element) {
+        const errorDirectives = [];
+        let matchingElements = [...Array.from(element.querySelectorAll(`[${ErrorPlugin.errorAttribute}]`))];
+        matchingElements = matchingElements.filter((elt) => elementBelongsToThisComponent(elt, component));
+        if (element.hasAttribute(ErrorPlugin.errorAttribute)) {
+            matchingElements = [element, ...matchingElements];
+        }
+        matchingElements.forEach((element => {
+            if (!(element instanceof HTMLElement) && !(element instanceof SVGElement)) {
+                throw new Error(`Element "${element.nodeName}" is not supported for ${ErrorPlugin.errorAttribute} directives. Only HTMLElement and SVGElement are supported.`);
+            }
+            const directives = parseDirectives(element.getAttribute(ErrorPlugin.errorAttribute) || 'show');
+            directives.forEach((directive) => {
+                if (directive.modifiers.length > 0) {
+                    throw new Error(`Modifiers are not supported for ${ErrorPlugin.errorAttribute} directives, but the following were found: "{${directive.modifiers.map((modifier) => `${modifier.name}: ${modifier.value}}`).join(', ')}" for element with tag "${element.nodeName}".`);
+                }
+            });
+            errorDirectives.push({
+                element,
+                directives,
+            });
+        }));
+        return errorDirectives;
+    }
+    parseErrorAction(action, isError) {
+        switch (action) {
+            case ErrorPlugin.supportedActions.show:
+                return isError ? 'show' : 'hide';
+            case ErrorPlugin.supportedActions.hide:
+                return isError ? 'hide' : 'show';
+            case ErrorPlugin.supportedActions.addClass:
+                return isError ? 'addClass' : 'removeClass';
+            case ErrorPlugin.supportedActions.removeClass:
+                return isError ? 'removeClass' : 'addClass';
+            case ErrorPlugin.supportedActions.addAttribute:
+                return isError ? 'addAttribute' : 'removeAttribute';
+            case ErrorPlugin.supportedActions.removeAttribute:
+                return isError ? 'removeAttribute' : 'addAttribute';
+            default:
+                throw new Error(`Unknown ${ErrorPlugin.errorAttribute} action "${action}". Supported actions are: ${Object.values(`"${ErrorPlugin.supportedActions}"`).join(', ')}.`);
+        }
+    }
+    showElement(element) {
+        element.style.display = 'revert';
+    }
+    hideElement(element) {
+        element.style.display = 'none';
+    }
+    addClass(element, classes) {
+        element.classList.add(...combineSpacedArray(classes));
+    }
+    removeClass(element, classes) {
+        element.classList.remove(...combineSpacedArray(classes));
+        if (element.classList.length === 0) {
+            element.removeAttribute('class');
+        }
+    }
+    addAttributes(element, attributes) {
+        attributes.forEach((attribute) => {
+            element.setAttribute(attribute, '');
+        });
+    }
+    removeAttributes(element, attributes) {
+        attributes.forEach((attribute) => {
+            element.removeAttribute(attribute);
+        });
+    }
+}
+ErrorPlugin.errorAttribute = 'data-live-error';
+ErrorPlugin.isErrorAttribute = 'data-live-is-error';
+ErrorPlugin.supportedActions = {
+    show: 'show',
+    hide: 'hide',
+    addClass: 'addClass',
+    removeClass: 'removeClass',
+    addAttribute: 'addAttribute',
+    removeAttribute: 'removeAttribute',
+};
+
 class LiveControllerDefault extends Controller {
     constructor() {
         super(...arguments);
@@ -3098,6 +3236,7 @@ class LiveControllerDefault extends Controller {
         }
         const plugins = [
             new LoadingPlugin(),
+            new ErrorPlugin(),
             new LazyPlugin(),
             new ValidatedFieldsPlugin(),
             new PageUnloadingPlugin(),

src/LiveComponent/assets/src/Component/index.ts

@@ -299,6 +299,7 @@ export default class Component {
             if (!headers.get('Content-Type')?.includes('application/vnd.live-component+html') && !headers.get('X-Live-Redirect')) {
                 const controls = { displayError: true };
                 this.valueStore.pushPendingPropsBackToDirty();
+                this.hooks.triggerHook('loading.state:finished', this.element);
                 this.hooks.triggerHook('response:error', backendResponse, controls);
 
                 if (controls.displayError) {
@@ -308,6 +309,13 @@ export default class Component {
                 this.backendRequest = null;
                 thisPromiseResolve(backendResponse);
 
+                // If there's another request pending, perform it now
+                // This will also ensure that the error state is cleared
+                if (this.isRequestPending) {
+                  this.isRequestPending = false;
+                  this.performRequest();
+                }
+
                 return response;
             }