@web-atoms/core 2.6.24 → 2.6.25

package/dist-esm/core/AtomDispatcher.js

@@ -1,54 +1,52 @@
 export class AtomDispatcher {
-    constructor() {
-        this.head = null;
-        this.tail = null;
+  constructor() {
+    this.head = null;
+    this.tail = null;
+  }
+  onTimeout() {
+    if (this.paused) {
+      return;
     }
-    onTimeout() {
-        if (this.paused) {
-            return;
-        }
-        if (!this.head) {
-            return;
-        }
-        const item = this.head;
-        this.head = item.next;
-        item.next = null;
-        if (!this.head) {
-            this.tail = null;
-        }
-        item();
-        setTimeout(() => {
-            this.onTimeout();
-        }, 1);
+    if (!this.head) {
+      return;
     }
-    pause() {
-        this.paused = true;
+    const item = this.head;
+    this.head = item.next;
+    item.next = null;
+    if (!this.head) {
+      this.tail = null;
     }
-    start() {
-        this.paused = false;
-        setTimeout(() => {
-            this.onTimeout();
-        }, 1);
+    item();
+    setTimeout(() => {
+      this.onTimeout();
+    }, 1);
+  }
+  pause() {
+    this.paused = true;
+  }
+  start() {
+    this.paused = false;
+    setTimeout(() => {
+      this.onTimeout();
+    }, 1);
+  }
+  callLater(f) {
+    if (this.tail) {
+      this.tail.next = f;
+      this.tail = f;
+    } else {
+      this.head = f;
+      this.tail = f;
     }
-    callLater(f) {
-        if (this.tail) {
-            this.tail.next = f;
-            this.tail = f;
-        }
-        else {
-            this.head = f;
-            this.tail = f;
-        }
-        if (!this.paused) {
-            this.start();
-        }
+    if (!this.paused) {
+      this.start();
     }
-    waitForAll() {
-        return new Promise((resolve, reject) => {
-            this.callLater(() => {
-                resolve();
-            });
-        });
-    }
-}
-//# sourceMappingURL=AtomDispatcher.js.map
+  }
+  waitForAll() {
+    return new Promise((resolve, reject) => {
+      this.callLater(() => {
+        resolve();
+      });
+    });
+  }
+}

package/dist-esm/core/AtomDisposableList.js

@@ -1,28 +1,27 @@
 export class AtomDisposableList {
-    constructor() {
-        this.disposables = [];
+  constructor() {
+    this.disposables = [];
+  }
+  add(d) {
+    if (typeof d === "function") {
+      const fx = d;
+      d = {
+        dispose: fx
+      };
     }
-    add(d) {
-        if (typeof d === "function") {
-            const fx = d;
-            d = {
-                dispose: fx
-            };
-        }
-        this.disposables.push(d);
-        const dx = d;
-        return {
-            dispose: () => {
-                this.disposables = this.disposables.filter((x) => x !== dx);
-                dx.dispose();
-            }
-        };
+    this.disposables.push(d);
+    const dx = d;
+    return {
+      dispose: () => {
+        this.disposables = this.disposables.filter(x => x !== dx);
+        dx.dispose();
+      }
+    };
+  }
+  dispose() {
+    for (const iterator of this.disposables) {
+      iterator.dispose();
     }
-    dispose() {
-        for (const iterator of this.disposables) {
-            iterator.dispose();
-        }
-        this.disposables.length = 0;
-    }
-}
-//# sourceMappingURL=AtomDisposableList.js.map
+    this.disposables.length = 0;
+  }
+}

package/dist-esm/core/AtomEnumerator.js

@@ -1,17 +1,16 @@
 export default class AtomEnumerator {
-    constructor(items) {
-        this.items = items;
-        this.index = -1;
-    }
-    next() {
-        this.index++;
-        return this.index < this.items.length;
-    }
-    get current() {
-        return this.items[this.index];
-    }
-    get currentIndex() {
-        return this.index;
-    }
-}
-//# sourceMappingURL=AtomEnumerator.js.map
+  constructor(items) {
+    this.items = items;
+    this.index = -1;
+  }
+  next() {
+    this.index++;
+    return this.index < this.items.length;
+  }
+  get current() {
+    return this.items[this.index];
+  }
+  get currentIndex() {
+    return this.index;
+  }
+}

package/dist-esm/core/AtomList.js

@@ -1,199 +1,200 @@
 import { AtomBinder } from "./AtomBinder.js";
 export class AtomList extends Array {
-    constructor() {
-        super();
-        this.startValue = 0;
-        this.totalValue = 0;
-        this.sizeValue = 10;
-        this["__proto__"] = AtomList.prototype;
-        this.next = () => {
-            this.start = this.start + this.size;
-        };
-        this.prev = () => {
-            if (this.start >= this.size) {
-                this.start = this.start - this.size;
-            }
-        };
-    }
-    get start() {
-        return this.startValue;
-    }
-    set start(v) {
-        if (v === this.startValue) {
-            return;
-        }
-        this.startValue = v;
-        AtomBinder.refreshValue(this, "start");
-    }
-    get total() {
-        return this.totalValue;
-    }
-    set total(v) {
-        if (v === this.totalValue) {
-            return;
-        }
-        this.totalValue = v;
-        AtomBinder.refreshValue(this, "total");
-    }
-    get size() {
-        return this.sizeValue;
-    }
-    set size(v) {
-        if (v === this.sizeValue) {
-            return;
-        }
-        this.sizeValue = v;
-        AtomBinder.refreshValue(this, "size");
-    }
-    add(item) {
-        const i = this.length;
-        const n = this.push(item);
-        AtomBinder.invokeItemsEvent(this, "add", i, item);
-        AtomBinder.refreshValue(this, "length");
-        return n;
-    }
-    addAll(items) {
-        for (const item of items) {
-            const i = this.length;
-            this.push(item);
-            AtomBinder.invokeItemsEvent(this, "add", i, item);
-            AtomBinder.refreshValue(this, "length");
-        }
-        const t = items["total"];
-        if (t) {
-            this.total = t;
-        }
-    }
-    replace(items, start, size) {
-        this.length = items.length;
-        for (let i = 0; i < items.length; i++) {
-            this[i] = items[i];
+  constructor() {
+    super();
+    this.startValue = 0;
+    this.totalValue = 0;
+    this.sizeValue = 10;
+    this["__proto__"] = AtomList.prototype;
+    this.next = () => {
+      this.start = this.start + this.size;
+    };
+    this.prev = () => {
+      if (this.start >= this.size) {
+        this.start = this.start - this.size;
+      }
+    };
+  }
+  get start() {
+    return this.startValue;
+  }
+  set start(v) {
+    if (v === this.startValue) {
+      return;
+    }
+    this.startValue = v;
+    AtomBinder.refreshValue(this, "start");
+  }
+  get total() {
+    return this.totalValue;
+  }
+  set total(v) {
+    if (v === this.totalValue) {
+      return;
+    }
+    this.totalValue = v;
+    AtomBinder.refreshValue(this, "total");
+  }
+  get size() {
+    return this.sizeValue;
+  }
+  set size(v) {
+    if (v === this.sizeValue) {
+      return;
+    }
+    this.sizeValue = v;
+    AtomBinder.refreshValue(this, "size");
+  }
+  add(item) {
+    const i = this.length;
+    const n = this.push(item);
+    AtomBinder.invokeItemsEvent(this, "add", i, item);
+    AtomBinder.refreshValue(this, "length");
+    return n;
+  }
+  addAll(items) {
+    for (const item of items) {
+      const i = this.length;
+      this.push(item);
+      AtomBinder.invokeItemsEvent(this, "add", i, item);
+      AtomBinder.refreshValue(this, "length");
+    }
+    const t = items["total"];
+    if (t) {
+      this.total = t;
+    }
+  }
+  replace(items, start, size) {
+    this.length = items.length;
+    for (let i = 0; i < items.length; i++) {
+      this[i] = items[i];
+    }
+    this.refresh();
+    const t = items["total"];
+    if (t) {
+      this.total = t;
+    }
+    if (start !== undefined) {
+      this.start = start;
+    }
+    if (size !== undefined) {
+      this.size = size;
+    }
+  }
+  insert(i, item) {
+    const n = this.splice(i, 0, item);
+    AtomBinder.invokeItemsEvent(this, "add", i, item);
+    AtomBinder.refreshValue(this, "length");
+  }
+  set(i, item) {
+    const old = this[i];
+    this[i] = item;
+    AtomBinder.invokeItemsEvent(this, "replace", i, item, old);
+    AtomBinder.refreshValue(this, "length");
+  }
+  removeAt(i) {
+    const item = this[i];
+    this.splice(i, 1);
+    AtomBinder.invokeItemsEvent(this, "remove", i, item);
+    AtomBinder.refreshValue(this, "length");
+    return item;
+  }
+  remove(item) {
+    if (item instanceof Function) {
+      let removed = false;
+      for (let index = 0; index < this.length;) {
+        const it = this[index];
+        if (item(it)) {
+          this.splice(index, 1);
+          AtomBinder.invokeItemsEvent(this, "remove", index, it);
+          AtomBinder.refreshValue(this, "length");
+          removed = true;
+          continue;
         }
-        this.refresh();
-        const t = items["total"];
-        if (t) {
-            this.total = t;
+        index++;
+      }
+      return removed;
+    }
+    const n = this.indexOf(item);
+    if (n !== -1) {
+      this.removeAt(n);
+      return true;
+    }
+    return false;
+  }
+  clear() {
+    this.length = 0;
+    this.refresh();
+  }
+  refresh() {
+    AtomBinder.invokeItemsEvent(this, "refresh", -1, null);
+    AtomBinder.refreshValue(this, "length");
+  }
+  watch(f, wrap) {
+    if (wrap) {
+      const fx = f;
+      f = function () {
+        const p = [];
+        for (let i = 0; i < arguments.length; i++) {
+          const iterator = arguments[i];
+          p.push(iterator);
         }
-        if (start !== undefined) {
-            this.start = start;
-        }
-        if (size !== undefined) {
-            this.size = size;
-        }
-    }
-    insert(i, item) {
-        const n = this.splice(i, 0, item);
-        AtomBinder.invokeItemsEvent(this, "add", i, item);
-        AtomBinder.refreshValue(this, "length");
-    }
-    set(i, item) {
-        const old = this[i];
-        this[i] = item;
-        AtomBinder.invokeItemsEvent(this, "replace", i, item, old);
-        AtomBinder.refreshValue(this, "length");
-    }
-    removeAt(i) {
-        const item = this[i];
-        this.splice(i, 1);
-        AtomBinder.invokeItemsEvent(this, "remove", i, item);
-        AtomBinder.refreshValue(this, "length");
-        return item;
-    }
-    remove(item) {
-        if (item instanceof Function) {
-            let removed = false;
-            for (let index = 0; index < this.length;) {
-                const it = this[index];
-                if (item(it)) {
-                    this.splice(index, 1);
-                    AtomBinder.invokeItemsEvent(this, "remove", index, it);
-                    AtomBinder.refreshValue(this, "length");
-                    removed = true;
-                    continue;
-                }
-                index++;
-            }
-            return removed;
-        }
-        const n = this.indexOf(item);
-        if (n !== -1) {
-            this.removeAt(n);
-            return true;
-        }
-        return false;
-    }
-    clear() {
-        this.length = 0;
-        this.refresh();
-    }
-    refresh() {
-        AtomBinder.invokeItemsEvent(this, "refresh", -1, null);
-        AtomBinder.refreshValue(this, "length");
-    }
-    watch(f, wrap) {
-        if (wrap) {
-            const fx = f;
-            f = (function () {
-                const p = [];
-                for (let i = 0; i < arguments.length; i++) {
-                    const iterator = arguments[i];
-                    p.push(iterator);
-                }
-                return fx.call(this, p);
-            });
-        }
-        return AtomBinder.add_CollectionChanged(this, f);
-    }
-    count(f) {
-        let total = 0;
-        for (const iterator of this) {
-            if (f(iterator)) {
-                total++;
-            }
-        }
-        return total;
-    }
-    avg(f) {
-        if (!this.length) {
-            return 0;
-        }
-        let sum = 0;
-        for (const iterator of this) {
-            sum += f(iterator);
-        }
-        return sum / this.length;
-    }
-    includes(item) {
-        return this.indexOf(item) !== -1;
-    }
+        return fx.call(this, p);
+      };
+    }
+    return AtomBinder.add_CollectionChanged(this, f);
+  }
+  count(f) {
+    let total = 0;
+    for (const iterator of this) {
+      if (f(iterator)) {
+        total++;
+      }
+    }
+    return total;
+  }
+  avg(f) {
+    if (!this.length) {
+      return 0;
+    }
+    let sum = 0;
+    for (const iterator of this) {
+      sum += f(iterator);
+    }
+    return sum / this.length;
+  }
+  includes(item) {
+    return this.indexOf(item) !== -1;
+  }
 }
 const ap = Array.prototype;
 for (const key of Object.getOwnPropertyNames(AtomList.prototype)) {
-    const { value } = Object.getOwnPropertyDescriptor(AtomList.prototype, key);
-    switch (key) {
-        case "add":
-        case "addAll":
-        case "clear":
-        case "refresh":
-        case "set":
-        case "remove":
-        case "removeAt":
-        case "watch":
-        case "replace":
-        case "insert":
-        case "count":
-        case "avg":
-        case "includes":
-            if (key in ap) {
-                continue;
-            }
-            Object.defineProperty(ap, key, {
-                enumerable: false,
-                value,
-                configurable: true,
-                writable: true
-            });
-            continue;
-    }
-}
-//# sourceMappingURL=AtomList.js.map
+  const {
+    value
+  } = Object.getOwnPropertyDescriptor(AtomList.prototype, key);
+  switch (key) {
+    case "add":
+    case "addAll":
+    case "clear":
+    case "refresh":
+    case "set":
+    case "remove":
+    case "removeAt":
+    case "watch":
+    case "replace":
+    case "insert":
+    case "count":
+    case "avg":
+    case "includes":
+      if (key in ap) {
+        continue;
+      }
+      Object.defineProperty(ap, key, {
+        enumerable: false,
+        value,
+        configurable: true,
+        writable: true
+      });
+      continue;
+  }
+}