@web-atoms/core 2.6.21 → 2.6.25

package/dist-esm/core/AtomWatcher.js

@@ -1,125 +1,119 @@
 import { AtomBinder } from "./AtomBinder.js";
 import { parsePath } from "./ExpressionParser.js";
 export class ObjectProperty {
-    constructor(name) {
-        this.name = name;
-    }
-    toString() {
-        return this.name;
-    }
+  constructor(name) {
+    this.name = name;
+  }
+  toString() {
+    return this.name;
+  }
 }
 export class AtomWatcher {
-    constructor(target, path, onChanged, source) {
-        this.source = source;
-        this.isExecuting = false;
-        this.target = target;
-        this.forValidation = true;
-        if (path instanceof Function) {
-            const f = path;
-            path = parsePath(path);
-            this.func = onChanged || f;
-            this.funcText = f.toString();
-        }
-        else {
-            this.func = onChanged;
-        }
-        this.runEvaluate = () => {
-            this.evaluate();
-        };
-        this.runEvaluate.watcher = this;
-        this.path = path.map((x) => x.map((y) => new ObjectProperty(y)));
-        if (!this.path.length) {
-            debugger;
-            console.warn("There is nothing to watch, do not use one way binding without any binding expression");
-        }
+  constructor(target, path, onChanged, source) {
+    this.source = source;
+    this.isExecuting = false;
+    this.target = target;
+    this.forValidation = true;
+    if (path instanceof Function) {
+      const f = path;
+      path = parsePath(path);
+      this.func = onChanged || f;
+      this.funcText = f.toString();
+    } else {
+      this.func = onChanged;
     }
-    toString() {
-        return this.func.toString();
+    this.runEvaluate = () => {
+      this.evaluate();
+    };
+    this.runEvaluate.watcher = this;
+    this.path = path.map(x => x.map(y => new ObjectProperty(y)));
+    if (!this.path.length) {
+      debugger;
+      console.warn("There is nothing to watch, do not use one way binding without any binding expression");
     }
-    dispose() {
-        if (!this.path) {
-            return;
-        }
-        for (const p of this.path) {
-            for (const op of p) {
-                if (op.watcher) {
-                    op.watcher.dispose();
-                    op.watcher = null;
-                    op.target = null;
-                }
-            }
-        }
-        this.func = null;
-        this.path = null;
-        this.source = null;
+  }
+  toString() {
+    return this.func.toString();
+  }
+  dispose() {
+    if (!this.path) {
+      return;
     }
-    init(evaluate) {
-        if (evaluate) {
-            this.evaluate(true);
-        }
-        else {
-            for (const iterator of this.path) {
-                this.evaluatePath(this.target, iterator);
-            }
+    for (const p of this.path) {
+      for (const op of p) {
+        if (op.watcher) {
+          op.watcher.dispose();
+          op.watcher = null;
+          op.target = null;
         }
+      }
     }
-    evaluatePath(target, path) {
-        let newTarget = null;
-        for (const p of path) {
-            if (this.source && p.name === "this") {
-                target = this.source;
-                continue;
-            }
-            newTarget = target[p.name];
-            if (!p.target) {
-                if (p.watcher) {
-                    p.watcher.dispose();
-                }
-                p.watcher = AtomBinder.watch(target, p.name, this.runEvaluate);
-            }
-            else if (p.target !== target) {
-                if (p.watcher) {
-                    p.watcher.dispose();
-                }
-                p.watcher = AtomBinder.watch(target, p.name, this.runEvaluate);
-            }
-            p.target = target;
-            target = newTarget;
-            if (newTarget === undefined || newTarget === null) {
-                break;
-            }
-        }
-        return newTarget;
+    this.func = null;
+    this.path = null;
+    this.source = null;
+  }
+  init(evaluate) {
+    if (evaluate) {
+      this.evaluate(true);
+    } else {
+      for (const iterator of this.path) {
+        this.evaluatePath(this.target, iterator);
+      }
     }
-    evaluate(force) {
-        if (!this.path) {
-            console.warn(`Watcher is not disposed properly, please watch for any memory leak`);
-            return;
-        }
-        if (this.isExecuting) {
-            return;
+  }
+  evaluatePath(target, path) {
+    let newTarget = null;
+    for (const p of path) {
+      if (this.source && p.name === "this") {
+        target = this.source;
+        continue;
+      }
+      newTarget = target[p.name];
+      if (!p.target) {
+        if (p.watcher) {
+          p.watcher.dispose();
         }
-        const disposeWatchers = [];
-        this.isExecuting = true;
-        try {
-            const values = [];
-            const logs = [];
-            for (const p of this.path) {
-                values.push(this.evaluatePath(this.target, p));
-            }
-            try {
-                this.func.apply(this.target, values);
-            }
-            catch (e) {
-                console.warn(e);
-            }
-        }
-        finally {
-            this.isExecuting = false;
-            for (const d of disposeWatchers) {
-                d.dispose();
-            }
+        p.watcher = AtomBinder.watch(target, p.name, this.runEvaluate);
+      } else if (p.target !== target) {
+        if (p.watcher) {
+          p.watcher.dispose();
         }
+        p.watcher = AtomBinder.watch(target, p.name, this.runEvaluate);
+      }
+      p.target = target;
+      target = newTarget;
+      if (newTarget === undefined || newTarget === null) {
+        break;
+      }
     }
-}
-//# sourceMappingURL=AtomWatcher.js.map
+    return newTarget;
+  }
+  evaluate(force) {
+    if (!this.path) {
+      console.warn(`Watcher is not disposed properly, please watch for any memory leak`);
+      return;
+    }
+    if (this.isExecuting) {
+      return;
+    }
+    const disposeWatchers = [];
+    this.isExecuting = true;
+    try {
+      const values = [];
+      const logs = [];
+      for (const p of this.path) {
+        values.push(this.evaluatePath(this.target, p));
+      }
+      try {
+        this.func.apply(this.target, values);
+      } catch (e) {
+        console.warn(e);
+      }
+    } finally {
+      this.isExecuting = false;
+      for (const d of disposeWatchers) {
+        d.dispose();
+      }
+    }
+  }
+}