@web-atoms/core 2.6.21 → 2.6.25

package/dist-esm/Atom.js

@@ -1,106 +1,103 @@
 export class Atom {
-    static { this.designMode = false; }
-    static superProperty(tc, target, name) {
-        let c = tc;
-        do {
-            c = Object.getPrototypeOf(c);
-            if (!c) {
-                throw new Error("No property descriptor found for " + name);
-            }
-            const pd = Object.getOwnPropertyDescriptor(c.prototype, name);
-            if (!pd) {
-                continue;
-            }
-            return pd.get.apply(target);
-        } while (true);
-    }
-    static get(target, path) {
-        const segments = path.split(".");
-        for (const iterator of segments) {
-            if (target === undefined || target === null) {
-                return target;
-            }
-            target = target[iterator];
-        }
+  static {
+    this.designMode = false;
+  }
+  static superProperty(tc, target, name) {
+    let c = tc;
+    do {
+      c = Object.getPrototypeOf(c);
+      if (!c) {
+        throw new Error("No property descriptor found for " + name);
+      }
+      const pd = Object.getOwnPropertyDescriptor(c.prototype, name);
+      if (!pd) {
+        continue;
+      }
+      return pd.get.apply(target);
+    } while (true);
+  }
+  static get(target, path) {
+    const segments = path.split(".");
+    for (const iterator of segments) {
+      if (target === undefined || target === null) {
         return target;
+      }
+      target = target[iterator];
     }
-    static delay(n, ct) {
-        return new Promise((resolve, reject) => {
-            const h = {};
-            h.id = setTimeout(() => {
-                resolve();
-            }, n);
-            if (ct) {
-                ct.registerForCancel(() => {
-                    clearTimeout(h.id);
-                    reject(new Error("cancelled"));
-                });
-            }
+    return target;
+  }
+  static delay(n, ct) {
+    return new Promise((resolve, reject) => {
+      const h = {};
+      h.id = setTimeout(() => {
+        resolve();
+      }, n);
+      if (ct) {
+        ct.registerForCancel(() => {
+          clearTimeout(h.id);
+          reject(new Error("cancelled"));
         });
+      }
+    });
+  }
+  static encodeParameters(p) {
+    if (!p) {
+      return "";
     }
-    static encodeParameters(p) {
-        if (!p) {
-            return "";
-        }
-        let s = "";
-        for (const key in p) {
-            if (p.hasOwnProperty(key)) {
-                const element = p[key];
-                let v = element;
-                if (v === undefined || v === null) {
-                    continue;
-                }
-                if (v instanceof Date) {
-                    v = v.toISOString();
-                }
-                else if (typeof element === "object") {
-                    v = JSON.stringify(element);
-                }
-                if (s) {
-                    s += "&";
-                }
-                s += `${key}=${encodeURIComponent(v)}`;
-            }
-        }
-        return s;
-    }
-    static url(url, query, hash) {
-        if (!url) {
-            return url;
+    let s = "";
+    for (const key in p) {
+      if (p.hasOwnProperty(key)) {
+        const element = p[key];
+        let v = element;
+        if (v === undefined || v === null) {
+          continue;
         }
-        let p = this.encodeParameters(query);
-        if (p) {
-            if (url.indexOf("?") === -1) {
-                url += "?";
-            }
-            else {
-                url += "&";
-            }
-            url += p;
+        if (v instanceof Date) {
+          v = v.toISOString();
+        } else if (typeof element === "object") {
+          v = JSON.stringify(element);
         }
-        p = this.encodeParameters(hash);
-        if (p) {
-            if (url.indexOf("#") === -1) {
-                url += "#";
-            }
-            else {
-                url += "&";
-            }
-            url += p;
+        if (s) {
+          s += "&";
         }
-        return url;
+        s += `${key}=${encodeURIComponent(v)}`;
+      }
     }
-    static postAsync(app, f) {
-        return new Promise((resolve, reject) => {
-            app.callLater(async () => {
-                try {
-                    resolve(await f());
-                }
-                catch (error) {
-                    reject(error);
-                }
-            });
-        });
+    return s;
+  }
+  static url(url, query, hash) {
+    if (!url) {
+      return url;
+    }
+    let p = this.encodeParameters(query);
+    if (p) {
+      if (url.indexOf("?") === -1) {
+        url += "?";
+      } else {
+        url += "&";
+      }
+      url += p;
     }
-}
-//# sourceMappingURL=Atom.js.map
+    p = this.encodeParameters(hash);
+    if (p) {
+      if (url.indexOf("#") === -1) {
+        url += "#";
+      } else {
+        url += "&";
+      }
+      url += p;
+    }
+    return url;
+  }
+  static postAsync(app, f) {
+    return new Promise((resolve, reject) => {
+      app.callLater(async () => {
+        try {
+          resolve(await f());
+        } catch (error) {
+          reject(error);
+        }
+      });
+    });
+  }
+}

package/dist-esm/MockApp.js

@@ -2,23 +2,22 @@ import { App } from "./App.js";
 import { MockNavigationService } from "./services/MockNavigationService.js";
 import { NavigationService } from "./services/NavigationService.js";
 export class MockApp extends App {
-    constructor() {
-        super();
-        this.put(NavigationService, new MockNavigationService(this));
+  constructor() {
+    super();
+    this.put(NavigationService, new MockNavigationService(this));
+  }
+  updateDefaultStyle(textContent) {
+    if (this.styleElement) {
+      if (this.styleElement.textContent === textContent) {
+        return;
+      }
     }
-    updateDefaultStyle(textContent) {
-        if (this.styleElement) {
-            if (this.styleElement.textContent === textContent) {
-                return;
-            }
-        }
-        const ss = document.createElement("style");
-        ss.textContent = textContent;
-        if (this.styleElement) {
-            this.styleElement.remove();
-        }
-        document.head.appendChild(ss);
-        this.styleElement = ss;
+    const ss = document.createElement("style");
+    ss.textContent = textContent;
+    if (this.styleElement) {
+      this.styleElement.remove();
     }
-}
-//# sourceMappingURL=MockApp.js.map
+    document.head.appendChild(ss);
+    this.styleElement = ss;
+  }
+}

package/dist-esm/Pack.js

@@ -1,3 +1 @@
-export default function Pack(...a) {
-}
-//# sourceMappingURL=Pack.js.map
+export default function Pack(...a) {}

package/dist-esm/core/AtomBinder.js

@@ -2,199 +2,201 @@ import { ArrayHelper } from "./types.js";
 export const symbolHandlers = Symbol.for("handlers");
 export const symbolBindable = Symbol.for("bindable");
 export class AtomBinder {
-    static refreshValue(target, key) {
-        const handlers = AtomBinder.get_WatchHandler(target, key);
-        if (handlers === undefined || handlers == null) {
-            return;
-        }
-        for (const item of handlers) {
-            item(target, key);
-        }
-        if (target.onPropertyChanged) {
-            target.onPropertyChanged(key);
-        }
+  static refreshValue(target, key) {
+    const handlers = AtomBinder.get_WatchHandler(target, key);
+    if (handlers === undefined || handlers == null) {
+      return;
     }
-    static add_WatchHandler(target, key, handler) {
-        if (target == null) {
-            return;
-        }
-        const handlers = AtomBinder.get_WatchHandler(target, key);
-        handlers.push(handler);
-        if (Array.isArray(target)) {
-            return;
-        }
-        const pv = AtomBinder.getPropertyDescriptor(target, key);
-        if (pv && pv.get) {
-            return;
-        }
-        const tw = target;
-        let bindables = tw[symbolBindable];
-        if (bindables === undefined) {
-            bindables = {};
-            Object.defineProperty(tw, symbolBindable, {
-                value: bindables,
-                enumerable: false,
-                writable: true,
-                configurable: true
-            });
-        }
-        if (!bindables[key]) {
-            bindables[key] = 1;
-            const o = target[key];
-            const nk = Symbol.for(key);
-            target[nk] = o;
-            const set = function (v) {
-                const ov = this[nk];
-                if (ov === undefined ? ov === v : ov == v) {
-                    return;
-                }
-                this[nk] = v;
-                AtomBinder.refreshValue(this, key);
-            };
-            const get = function () {
-                return this[nk];
-            };
-            if (pv) {
-                delete target[key];
-                Object.defineProperty(target, key, {
-                    get,
-                    set,
-                    configurable: true,
-                    enumerable: true
-                });
-            }
-            else {
-                Object.defineProperty(target, key, {
-                    get, set, enumerable: true, configurable: true
-                });
-            }
-        }
+    for (const item of handlers) {
+      item(target, key);
     }
-    static getPropertyDescriptor(target, key) {
-        const pv = Object.getOwnPropertyDescriptor(target, key);
-        if (!pv) {
-            const pt = Object.getPrototypeOf(target);
-            if (pt) {
-                return AtomBinder.getPropertyDescriptor(pt, key);
-            }
-        }
-        return pv;
+    if (target.onPropertyChanged) {
+      target.onPropertyChanged(key);
     }
-    static get_WatchHandler(target, key) {
-        if (target == null) {
-            return null;
-        }
-        let handlers = target[symbolHandlers];
-        if (handlers === undefined) {
-            handlers = {};
-            Object.defineProperty(target, symbolHandlers, {
-                value: handlers,
-                enumerable: false,
-                writable: true,
-                configurable: true
-            });
-        }
-        let handlersForKey = handlers[key];
-        if (handlersForKey === undefined || handlersForKey == null) {
-            handlersForKey = [];
-            handlers[key] = handlersForKey;
-        }
-        return handlersForKey;
+  }
+  static add_WatchHandler(target, key, handler) {
+    if (target == null) {
+      return;
     }
-    static remove_WatchHandler(target, key, handler) {
-        if (target == null) {
-            return;
-        }
-        const handlers = target[symbolHandlers];
-        if (typeof handlers === "undefined") {
-            return;
-        }
-        const handlersForKey = target[symbolHandlers][key];
-        if (handlersForKey === undefined || handlersForKey == null) {
-            return;
-        }
-        ArrayHelper.remove(handlersForKey, (f) => f === handler);
-        if (!handlersForKey.length) {
-            handlers[key] = null;
-            delete handlers[key];
-        }
+    const handlers = AtomBinder.get_WatchHandler(target, key);
+    handlers.push(handler);
+    if (Array.isArray(target)) {
+      return;
     }
-    static invokeItemsEvent(target, mode, index, item, oldItem) {
-        const key = "_items";
-        const handlers = AtomBinder.get_WatchHandler(target, key);
-        if (!handlers) {
-            return;
-        }
-        for (const obj of handlers) {
-            obj(target, mode, index, item, oldItem);
-        }
-        AtomBinder.refreshValue(target, "length");
+    const pv = AtomBinder.getPropertyDescriptor(target, key);
+    if (pv && pv.get) {
+      return;
     }
-    static refreshItems(ary) {
-        AtomBinder.invokeItemsEvent(ary, "refresh", -1, null);
+    const tw = target;
+    let bindables = tw[symbolBindable];
+    if (bindables === undefined) {
+      bindables = {};
+      Object.defineProperty(tw, symbolBindable, {
+        value: bindables,
+        enumerable: false,
+        writable: true,
+        configurable: true
+      });
     }
-    static add_CollectionChanged(target, handler) {
-        if (target == null) {
-            throw new Error("Target Array to watch cannot be null");
-        }
-        if (handler == null) {
-            throw new Error("Target handle to watch an Array cannot be null");
-        }
-        const handlers = AtomBinder.get_WatchHandler(target, "_items");
-        handlers.push(handler);
-        return { dispose: () => {
-                AtomBinder.remove_CollectionChanged(target, handler);
-            }
-        };
-    }
-    static remove_CollectionChanged(t, handler) {
-        if (t == null) {
-            return;
-        }
-        const target = t;
-        const handlers = target[symbolHandlers];
-        if (typeof handlers === "undefined") {
-            return;
-        }
-        const key = "_items";
-        const handlersForKey = handlers[key];
-        if (handlersForKey === undefined || handlersForKey == null) {
-            return;
-        }
-        ArrayHelper.remove(handlersForKey, (f) => f === handler);
-        if (!handlersForKey.length) {
-            handlers[key] = null;
-            delete handlers[key];
-        }
+    if (!bindables[key]) {
+      bindables[key] = 1;
+      const o = target[key];
+      const nk = Symbol.for(key);
+      target[nk] = o;
+      const set = function (v) {
+        const ov = this[nk];
+        if (ov === undefined ? ov === v : ov == v) {
+          return;
+        }
+        this[nk] = v;
+        AtomBinder.refreshValue(this, key);
+      };
+      const get = function () {
+        return this[nk];
+      };
+      if (pv) {
+        delete target[key];
+        Object.defineProperty(target, key, {
+          get,
+          set,
+          configurable: true,
+          enumerable: true
+        });
+      } else {
+        Object.defineProperty(target, key, {
+          get,
+          set,
+          enumerable: true,
+          configurable: true
+        });
+      }
     }
-    static watch(item, property, f) {
-        AtomBinder.add_WatchHandler(item, property, f);
-        return {
-            dispose: () => {
-                AtomBinder.remove_WatchHandler(item, property, f);
-            }
-        };
-    }
-    static clear(a) {
-        a.length = 0;
-        this.invokeItemsEvent(a, "refresh", -1, null);
-        AtomBinder.refreshValue(a, "length");
-    }
-    static addItem(a, item) {
-        const index = a.length;
-        a.push(item);
-        this.invokeItemsEvent(a, "add", index, item);
-        AtomBinder.refreshValue(a, "length");
-    }
-    static removeItem(a, item) {
-        const i = a.findIndex((x) => x === item);
-        if (i === -1) {
-            return false;
-        }
-        a.splice(i, 1);
-        AtomBinder.invokeItemsEvent(a, "remove", i, item);
-        AtomBinder.refreshValue(a, "length");
-        return true;
+  }
+  static getPropertyDescriptor(target, key) {
+    const pv = Object.getOwnPropertyDescriptor(target, key);
+    if (!pv) {
+      const pt = Object.getPrototypeOf(target);
+      if (pt) {
+        return AtomBinder.getPropertyDescriptor(pt, key);
+      }
+    }
+    return pv;
+  }
+  static get_WatchHandler(target, key) {
+    if (target == null) {
+      return null;
+    }
+    let handlers = target[symbolHandlers];
+    if (handlers === undefined) {
+      handlers = {};
+      Object.defineProperty(target, symbolHandlers, {
+        value: handlers,
+        enumerable: false,
+        writable: true,
+        configurable: true
+      });
+    }
+    let handlersForKey = handlers[key];
+    if (handlersForKey === undefined || handlersForKey == null) {
+      handlersForKey = [];
+      handlers[key] = handlersForKey;
+    }
+    return handlersForKey;
+  }
+  static remove_WatchHandler(target, key, handler) {
+    if (target == null) {
+      return;
+    }
+    const handlers = target[symbolHandlers];
+    if (typeof handlers === "undefined") {
+      return;
+    }
+    const handlersForKey = target[symbolHandlers][key];
+    if (handlersForKey === undefined || handlersForKey == null) {
+      return;
+    }
+    ArrayHelper.remove(handlersForKey, f => f === handler);
+    if (!handlersForKey.length) {
+      handlers[key] = null;
+      delete handlers[key];
+    }
+  }
+  static invokeItemsEvent(target, mode, index, item, oldItem) {
+    const key = "_items";
+    const handlers = AtomBinder.get_WatchHandler(target, key);
+    if (!handlers) {
+      return;
+    }
+    for (const obj of handlers) {
+      obj(target, mode, index, item, oldItem);
+    }
+    AtomBinder.refreshValue(target, "length");
+  }
+  static refreshItems(ary) {
+    AtomBinder.invokeItemsEvent(ary, "refresh", -1, null);
+  }
+  static add_CollectionChanged(target, handler) {
+    if (target == null) {
+      throw new Error("Target Array to watch cannot be null");
+    }
+    if (handler == null) {
+      throw new Error("Target handle to watch an Array cannot be null");
+    }
+    const handlers = AtomBinder.get_WatchHandler(target, "_items");
+    handlers.push(handler);
+    return {
+      dispose: () => {
+        AtomBinder.remove_CollectionChanged(target, handler);
+      }
+    };
+  }
+  static remove_CollectionChanged(t, handler) {
+    if (t == null) {
+      return;
+    }
+    const target = t;
+    const handlers = target[symbolHandlers];
+    if (typeof handlers === "undefined") {
+      return;
+    }
+    const key = "_items";
+    const handlersForKey = handlers[key];
+    if (handlersForKey === undefined || handlersForKey == null) {
+      return;
+    }
+    ArrayHelper.remove(handlersForKey, f => f === handler);
+    if (!handlersForKey.length) {
+      handlers[key] = null;
+      delete handlers[key];
+    }
+  }
+  static watch(item, property, f) {
+    AtomBinder.add_WatchHandler(item, property, f);
+    return {
+      dispose: () => {
+        AtomBinder.remove_WatchHandler(item, property, f);
+      }
+    };
+  }
+  static clear(a) {
+    a.length = 0;
+    this.invokeItemsEvent(a, "refresh", -1, null);
+    AtomBinder.refreshValue(a, "length");
+  }
+  static addItem(a, item) {
+    const index = a.length;
+    a.push(item);
+    this.invokeItemsEvent(a, "add", index, item);
+    AtomBinder.refreshValue(a, "length");
+  }
+  static removeItem(a, item) {
+    const i = a.findIndex(x => x === item);
+    if (i === -1) {
+      return false;
     }
-}
-//# sourceMappingURL=AtomBinder.js.map
+    a.splice(i, 1);
+    AtomBinder.invokeItemsEvent(a, "remove", i, item);
+    AtomBinder.refreshValue(a, "length");
+    return true;
+  }
+}