@optionfactory/fml 8.0.1 → 8.0.3

package/dist/ftl.d.mts

@@ -351,7 +351,30 @@ declare class ParsedElement extends HTMLElement {
     template(name?: string): any;
     connectedCallback(): void;
     attributeChangedCallback(attr: any, oldValue: any, newValue: any): void;
-    formDisabledCallback(disabled: any): void;
+    /**
+     * The disabled protocol follows the semantics of a native form control:
+     *
+     * - the `disabled` attribute on the host is the field's own claim, and nothing
+     *   but its author ever writes or removes it, in markup or through the property.
+     *   The framework never claims on the form's behalf, so there is nothing to
+     *   unclaim and nothing to lose: a field declared disabled inside a disabled
+     *   `<fieldset>` stays disabled when the fieldset comes back, exactly like a
+     *   native input keeps its attribute.
+     * - the effective state is the claim OR a disabled fieldset ancestry, which the
+     *   platform maintains on its own: `:disabled` matches both, a disabled field is
+     *   left out of the submitted values, and the inner native controls are reached
+     *   by the ancestry as descendants of the fieldset.
+     * - the `disabled` property reflects the claim only, like a native input's: a
+     *   field disabled by its ancestry reads `false` while `matches(':disabled')`
+     *   tells the effective state. Un-claiming inside a disabled fieldset cannot
+     *   enable the field.
+     * - the inner controls mirror the claim and nothing else: the ancestry state is
+     *   never written anywhere, so it can never go stale, and the browser composes
+     *   the two on its own when it disables and re-enables a fieldset's descendants.
+     *
+     * Because of this, formDisabledCallback carries nothing the framework needs to
+     * apply, and the protocol does not define it.
+     */
     upgrade(): Promise<void>;
     render(c: any): void;
     reflect(fn: any): void;

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() {
@@ -4684,14 +4697,30 @@ var ftl = (function (exports) {
             }
             this[attr] = this.unmarshal(attr, newValue);
         }
-        #disabledBeforeParsed = null;
-        formDisabledCallback(disabled) {
-            if (!this.#parsed) {
-                this.#disabledBeforeParsed = disabled;
-                return;
-            }
-            Reflect.set(this, 'disabled', disabled);
-        }
+        /**
+         * The disabled protocol follows the semantics of a native form control:
+         *
+         * - the `disabled` attribute on the host is the field's own claim, and nothing
+         *   but its author ever writes or removes it, in markup or through the property.
+         *   The framework never claims on the form's behalf, so there is nothing to
+         *   unclaim and nothing to lose: a field declared disabled inside a disabled
+         *   `<fieldset>` stays disabled when the fieldset comes back, exactly like a
+         *   native input keeps its attribute.
+         * - the effective state is the claim OR a disabled fieldset ancestry, which the
+         *   platform maintains on its own: `:disabled` matches both, a disabled field is
+         *   left out of the submitted values, and the inner native controls are reached
+         *   by the ancestry as descendants of the fieldset.
+         * - the `disabled` property reflects the claim only, like a native input's: a
+         *   field disabled by its ancestry reads `false` while `matches(':disabled')`
+         *   tells the effective state. Un-claiming inside a disabled fieldset cannot
+         *   enable the field.
+         * - the inner controls mirror the claim and nothing else: the ancestry state is
+         *   never written anywhere, so it can never go stale, and the browser composes
+         *   the two on its own when it disables and re-enables a fieldset's descendants.
+         *
+         * Because of this, formDisabledCallback carries nothing the framework needs to
+         * apply, and the protocol does not define it.
+         */
         async upgrade() {
             if (this.#parsed) {
                 return;
@@ -4704,8 +4733,9 @@ var ftl = (function (exports) {
                     this.unmarshal(attribute, this.getAttribute(attribute)),
                 ]),
             );
-            const disabled = this.#disabledBeforeParsed ?? false;
-            await this.render({ slots, observed, disabled });
+            //the declared claim is what render receives: the ancestry state is not
+            //passed around, it is already where it needs to be
+            await this.render({ slots, observed, disabled: this.hasAttribute('disabled') });
         }
         render(c) {}
         reflect(fn) {