@optionfactory/fml 8.0.1 → 8.0.2

package/dist/ftl.mjs

@@ -4378,25 +4378,38 @@ class UpgradeQueue {
             );
         });
     }
+    #finished = new Map();
     enqueue(el) {
         if (this.#q.has(el)) {
             //already upgrading, can happen when disconnecting an element
             //while it's already queued for upgrade (e.g.: ful-form)
             return;
         }
+        //settling waits on a signal that only ever resolves, so nothing here attaches a
+        //rejection handler to the upgrade itself: a component that fails is still
+        //reported the way it always was
+        const { promise: finished, resolve: markFinished } = /** @type {PromiseWithResolvers<void>} */ (
+            Promise.withResolvers()
+        );
         const promise = Nodes.waitParsed(el)
             .then(() => el.upgrade())
-            .finally(() => this.#q.delete(el));
+            .finally(() => {
+                this.#q.delete(el);
+                this.#finished.delete(el);
+                markFinished();
+            });
         this.#q.set(el, promise);
+        this.#finished.set(el, finished);
     }
     /**
-     * Waits for every queued upgrade, including the ones enqueued while waiting:
-     * a component is only queued once its parent connects it, so a single pass would
-     * miss everything nested.
+     * Waits for every queued upgrade to settle, including the ones enqueued while
+     * waiting: a component is only queued once its parent connects it, so a single pass
+     * would miss everything nested. A component that fails to upgrade does not hold the
+     * others back, readiness means the queue drained rather than that everything worked.
      */
     async settle() {
-        while (this.#q.size !== 0) {
-            await Promise.all(Array.from(this.#q.values()));
+        while (this.#finished.size !== 0) {
+            await Promise.all(Array.from(this.#finished.values()));
         }
     }
     get entries() {
@@ -4688,6 +4701,19 @@ class ParsedElement extends HTMLElement {
             return;
         }
         Reflect.set(this, 'disabled', disabled);
+        if (disabled) {
+            this.#unclaimFormDisabled();
+        }
+    }
+    //a disabled ancestor fieldset already matches the element through :disabled, and
+    //an attribute of its own would keep the element disabled once the fieldset is
+    //re-enabled, as formDisabledCallback(false) is only delivered on an actual state
+    //change. a claim of its own made while already disabled by ancestry is safe: the
+    //platform fires no callback for it, so it survives the fieldset being re-enabled
+    #unclaimFormDisabled() {
+        if (this.closest('fieldset:disabled')) {
+            this.removeAttribute('disabled');
+        }
     }
     async upgrade() {
         if (this.#parsed) {
@@ -4703,6 +4729,9 @@ class ParsedElement extends HTMLElement {
         );
         const disabled = this.#disabledBeforeParsed ?? false;
         await this.render({ slots, observed, disabled });
+        if (disabled) {
+            this.#unclaimFormDisabled();
+        }
     }
     render(c) {}
     reflect(fn) {