@optionfactory/fml 8.0.1 → 8.0.2

package/dist/ftl.iife.js

@@ -4381,25 +4381,38 @@ var ftl = (function (exports) {
                 );
             });
         }
+        #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() {
@@ -4691,6 +4704,19 @@ var ftl = (function (exports) {
                 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) {
@@ -4706,6 +4732,9 @@ var ftl = (function (exports) {
             );
             const disabled = this.#disabledBeforeParsed ?? false;
             await this.render({ slots, observed, disabled });
+            if (disabled) {
+                this.#unclaimFormDisabled();
+            }
         }
         render(c) {}
         reflect(fn) {