@mintjamsinc/ichigojs 0.1.87 → 0.1.88

package/dist/ichigo.esm.js

@@ -8843,6 +8843,7 @@ class VBindings {
      */
     clearChanges() {
         this.#changes.clear();
+        this.#changeLog.length = 0;
         if (this.#dirtyScopes) {
             for (const scope of this.#dirtyScopes) {
                 scope.#changes.clear();
@@ -8856,14 +8857,39 @@ class VBindings {
      */
     #addChange(key) {
         this.#changes.add(key);
-        if (!this.#parent) {
-            return;
+        let root = this;
+        while (root.#parent) {
+            root = root.#parent;
         }
+        root.#changeLog.push(key);
+        if (root !== this) {
+            (root.#dirtyScopes ??= new Set()).add(this);
+        }
+    }
+    /**
+     * Every change recorded since the last clearChanges(), in order and with repeats, on the
+     * root; the change set itself cannot tell a write made during an update cycle from the one
+     * the cycle was scheduled for when both touch the same identifier.
+     */
+    #changeLog = [];
+    /**
+     * A marker for {@link changesSince}: the number of changes recorded so far.
+     */
+    get changeLogLength() {
+        return this.#root.#changeLog.length;
+    }
+    /**
+     * The distinct identifiers recorded after the marker was taken.
+     */
+    changesSince(marker) {
+        return Array.from(new Set(this.#root.#changeLog.slice(marker)));
+    }
+    get #root() {
         let root = this;
         while (root.#parent) {
             root = root.#parent;
         }
-        (root.#dirtyScopes ??= new Set()).add(this);
+        return root;
     }
     /**
      * Sets a binding value.
@@ -15446,6 +15472,14 @@ class VApplication {
      * Flag to indicate if an update is already scheduled.
      */
     #updateScheduled = false;
+    /**
+     * How many update cycles in a row ended with changes made during the cycle (by a watcher
+     * or a lifecycle hook), each of which runs another cycle. Reset when a cycle ends clean;
+     * past MAX_CASCADED_UPDATES the late changes are dropped, so a watcher that writes on every
+     * cycle cannot keep the application updating forever.
+     */
+    #cascadedUpdates = 0;
+    static #MAX_CASCADED_UPDATES = 100;
     /**
      * The custom element hosting this application when it powers a component
      * defined via defineComponent(). Set by IchigoElement before mounting.
@@ -15889,8 +15923,10 @@ class VApplication {
         }
         this.#updateScheduled = true;
         queueMicrotask(() => {
-            this.#update();
+            // Cleared before the update runs, not after: a change made during the update (by a
+            // watcher or a lifecycle hook) then schedules the next cycle instead of being dropped.
             this.#updateScheduled = false;
+            this.#update();
         });
     }
     /**
@@ -15904,14 +15940,46 @@ class VApplication {
         // This converts paths like "model.elements[0].executionListeners"
         // to "selectedElement.executionListeners" when selectedElement points to model.elements[0]
         this.#applyComputedPathMappings();
+        // The changes this cycle was scheduled for. Whatever is recorded after this point was
+        // written during the cycle itself (see below); the marker tells the two apart even when
+        // a watcher writes the very identifier it watches.
+        const scheduledChanges = this.#bindings ? this.#bindings.changes : [];
+        const lateMarker = this.#bindings ? this.#bindings.changeLogLength : 0;
         // Notify watchers before DOM update
         if (this.#bindings) {
-            this.#watcher.notify(this.#bindings.changes, (p) => this.#getValueByPath(p), this.#bindings.raw);
+            this.#watcher.notify(scheduledChanges, (p) => this.#getValueByPath(p), this.#bindings.raw);
+            // A watcher may have written data. The computed properties that depend on it were
+            // only marked dirty, which the DOM diff below does not see; resolve them now, so this
+            // render already shows what the watcher did, and so the computed names are in the
+            // change set when the diff runs.
+            this.#flushDirtyComputeds();
+            this.#applyComputedPathMappings();
         }
         // Update the DOM
         this.#vNode?.update();
-        // Clear the set of changed identifiers after the update
-        this.#bindings?.clearChanges();
+        // Clear the set of changed identifiers after the update. Changes recorded during the
+        // cycle (by watchers or lifecycle hooks) are carried into the next cycle instead: the DOM
+        // diff above has seen them, but watchers that depend on them have not, since watcher
+        // notification ran before they were written.
+        if (this.#bindings) {
+            const late = this.#bindings.changesSince(lateMarker);
+            this.#bindings.clearChanges();
+            if (late.length > 0) {
+                this.#cascadedUpdates++;
+                if (this.#cascadedUpdates > VApplication.#MAX_CASCADED_UPDATES) {
+                    this.#logger.warn(`Update cycle did not settle after ${VApplication.#MAX_CASCADED_UPDATES} cascaded updates; dropping changes: ${late.join(', ')}`);
+                    this.#cascadedUpdates = 0;
+                    return;
+                }
+                for (const change of late) {
+                    this.#bindings.markChanged(change);
+                }
+                this.#scheduleUpdate();
+            }
+            else {
+                this.#cascadedUpdates = 0;
+            }
+        }
     }
     /**
      * Applies computed source path mappings to the current changes.