@web-atoms/core 2.6.21 → 2.6.25

package/dist-esm/view-model/Load.js

@@ -2,77 +2,76 @@ import { parsePath } from "../core/ExpressionParser.js";
 import { CancelToken } from "../core/types.js";
 import { NavigationService } from "../services/NavigationService.js";
 import { registerInit } from "./baseTypes.js";
-export default function Load({ init, showErrorOnInit, watch, watchDelayMS = 100 }) {
-    return function (target, key) {
-        registerInit(target, (vm) => {
-            const oldMethod = vm[key];
-            const app = vm.app;
-            let showError = init ? (showErrorOnInit ? true : false) : true;
-            let ct;
-            const ns = app.resolve(NavigationService);
-            const m = async (ctx) => {
-                try {
-                    const pe = oldMethod.call(vm, ctx);
-                    if (pe?.then) {
-                        return await pe;
-                    }
-                }
-                catch (e) {
-                    if (CancelToken.isCancelled(e)) {
-                        return;
-                    }
-                    if (!showError) {
-                        console.error(e);
-                        return;
-                    }
-                    await ns.alert(e, "Error");
-                }
-                finally {
-                    ct = null;
-                    showError = true;
-                }
-            };
-            if (watch) {
-                let timeout;
-                const fx = (c1) => {
-                    if (ct && !ct.cancelled) {
-                        ct.cancel();
-                    }
-                    if (timeout) {
-                        clearTimeout(timeout);
-                    }
-                    timeout = setTimeout(() => {
-                        timeout = undefined;
-                        ct = c1 ??= new CancelToken();
-                        m(c1).catch((e) => console.error(e));
-                    }, watchDelayMS);
-                };
-                const pathList = parsePath(oldMethod.toString(), true);
-                if (pathList.length === 0) {
-                    throw new Error("Nothing to watch !!");
-                }
-                vm[key] = fx;
-                const watchedFunction = () => fx();
-                if (init) {
-                    app.runAsync(async () => {
-                        try {
-                            await m(new CancelToken());
-                        }
-                        catch (error) {
-                        }
-                        finally {
-                            vm.setupWatch(pathList, watchedFunction);
-                        }
-                    });
-                    return;
-                }
-                vm.setupWatch(pathList, watchedFunction);
-                return;
+export default function Load({
+  init,
+  showErrorOnInit,
+  watch,
+  watchDelayMS = 100
+}) {
+  return function (target, key) {
+    registerInit(target, vm => {
+      const oldMethod = vm[key];
+      const app = vm.app;
+      let showError = init ? showErrorOnInit ? true : false : true;
+      let ct;
+      const ns = app.resolve(NavigationService);
+      const m = async ctx => {
+        try {
+          const pe = oldMethod.call(vm, ctx);
+          if (pe?.then) {
+            return await pe;
+          }
+        } catch (e) {
+          if (CancelToken.isCancelled(e)) {
+            return;
+          }
+          if (!showError) {
+            console.error(e);
+            return;
+          }
+          await ns.alert(e, "Error");
+        } finally {
+          ct = null;
+          showError = true;
+        }
+      };
+      if (watch) {
+        let timeout;
+        const fx = c1 => {
+          if (ct && !ct.cancelled) {
+            ct.cancel();
+          }
+          if (timeout) {
+            clearTimeout(timeout);
+          }
+          timeout = setTimeout(() => {
+            timeout = undefined;
+            ct = c1 ??= new CancelToken();
+            m(c1).catch(e => console.error(e));
+          }, watchDelayMS);
+        };
+        const pathList = parsePath(oldMethod.toString(), true);
+        if (pathList.length === 0) {
+          throw new Error("Nothing to watch !!");
+        }
+        vm[key] = fx;
+        const watchedFunction = () => fx();
+        if (init) {
+          app.runAsync(async () => {
+            try {
+              await m(new CancelToken());
+            } catch (error) {} finally {
+              vm.setupWatch(pathList, watchedFunction);
             }
-            if (init) {
-                app.runAsync(() => m(new CancelToken()));
-            }
-        });
-    };
-}
-//# sourceMappingURL=Load.js.map
+          });
+          return;
+        }
+        vm.setupWatch(pathList, watchedFunction);
+        return;
+      }
+      if (init) {
+        app.runAsync(() => m(new CancelToken()));
+      }
+    });
+  };
+}

package/dist-esm/view-model/Once.js

@@ -1,40 +1,38 @@
 import { registerInit } from "./baseTypes.js";
 const timerSymbol = Symbol();
 const Once = (timeInMS = 100) => (target, key) => {
-    registerInit(target, (vm) => {
-        const oldMethod = vm[key];
-        let keyTimer = vm[timerSymbol];
-        if (typeof keyTimer === "undefined") {
-            keyTimer = {};
-            vm[timerSymbol] = keyTimer;
+  registerInit(target, vm => {
+    const oldMethod = vm[key];
+    let keyTimer = vm[timerSymbol];
+    if (typeof keyTimer === "undefined") {
+      keyTimer = {};
+      vm[timerSymbol] = keyTimer;
+    }
+    let running = false;
+    vm[key] = (...a) => {
+      if (running) {
+        return;
+      }
+      const pending = keyTimer[key];
+      if (pending) {
+        clearTimeout(pending);
+      }
+      keyTimer[key] = setTimeout((...b) => {
+        running = true;
+        delete keyTimer[key];
+        const r = oldMethod.apply(vm, b);
+        if (r && r.then) {
+          r.then(() => {
+            running = false;
+          }, e => {
+            running = false;
+            console.warn(e);
+          });
+        } else {
+          running = false;
         }
-        let running = false;
-        vm[key] = (...a) => {
-            if (running) {
-                return;
-            }
-            const pending = keyTimer[key];
-            if (pending) {
-                clearTimeout(pending);
-            }
-            keyTimer[key] = setTimeout((...b) => {
-                running = true;
-                delete keyTimer[key];
-                const r = oldMethod.apply(vm, b);
-                if (r && r.then) {
-                    r.then(() => {
-                        running = false;
-                    }, (e) => {
-                        running = false;
-                        console.warn(e);
-                    });
-                }
-                else {
-                    running = false;
-                }
-            }, timeInMS, ...a);
-        };
-    });
+      }, timeInMS, ...a);
+    };
+  });
 };
-export default Once;
-//# sourceMappingURL=Once.js.map
+export default Once;

package/dist-esm/view-model/baseTypes.js

@@ -1,6 +1,5 @@
 export function registerInit(target, fx) {
-    const t = target;
-    const inits = t._$_inits = t._$_inits || [];
-    inits.push(fx);
-}
-//# sourceMappingURL=baseTypes.js.map
+  const t = target;
+  const inits = t._$_inits = t._$_inits || [];
+  inits.push(fx);
+}

package/dist-esm/view-model/bindPromise.js

@@ -1,31 +1,28 @@
 import { AtomBinder } from "../core/AtomBinder.js";
 import { NavigationService, NotifyType } from "../services/NavigationService.js";
 export default function bindPromise(vm, p, value, displayError = true) {
-    p.then((v) => {
-        if (Array.isArray(v)) {
-            const a = value;
-            a.replace(v);
+  p.then(v => {
+    if (Array.isArray(v)) {
+      const a = value;
+      a.replace(v);
+    } else {
+      for (const key in v) {
+        if (v.hasOwnProperty(key)) {
+          const element = v[key];
+          value[key] = element;
+          AtomBinder.refreshValue(value, key);
         }
-        else {
-            for (const key in v) {
-                if (v.hasOwnProperty(key)) {
-                    const element = v[key];
-                    value[key] = element;
-                    AtomBinder.refreshValue(value, key);
-                }
-            }
-        }
-    }).catch((e) => {
-        if (displayError) {
-            if (typeof displayError === "function") {
-                displayError(e);
-            }
-            else {
-                const n = vm.app.resolve(NavigationService);
-                n.notify(e, "Error", NotifyType.Error);
-            }
-        }
-    });
-    return value;
-}
-//# sourceMappingURL=bindPromise.js.map
+      }
+    }
+  }).catch(e => {
+    if (displayError) {
+      if (typeof displayError === "function") {
+        displayError(e);
+      } else {
+        const n = vm.app.resolve(NavigationService);
+        n.notify(e, "Error", NotifyType.Error);
+      }
+    }
+  });
+  return value;
+}

package/dist-esm/view-model/bindProperty.js

@@ -1,6 +1,5 @@
 import { PropertyBinding } from "../core/PropertyBinding.js";
 export default function bindProperty(vm, target, propertyName, source, path, twoWays) {
-    const pb = new PropertyBinding(target, null, propertyName, path, (twoWays && typeof twoWays !== "function") ? true : false, twoWays, source);
-    return vm.registerDisposable(pb);
-}
-//# sourceMappingURL=bindProperty.js.map
+  const pb = new PropertyBinding(target, null, propertyName, path, twoWays && typeof twoWays !== "function" ? true : false, twoWays, source);
+  return vm.registerDisposable(pb);
+}

package/dist-esm/view-model/bindUrlParameter.js

@@ -2,48 +2,44 @@ import { AtomDisposableList } from "../core/AtomDisposableList.js";
 import { AtomOnce } from "../core/AtomOnce.js";
 import { AtomUri } from "../core/AtomUri.js";
 export default function bindUrlParameter(vm, name, urlParameter) {
-    if (!name) {
-        return;
-    }
-    if (!urlParameter) {
-        return;
-    }
-    const a = vm;
-    const paramDisposables = (a.mUrlParameters || (a.mUrlParameters = {}));
-    const old = paramDisposables[name];
-    if (old) {
-        old.dispose();
-        paramDisposables[name] = null;
-    }
-    const disposables = new AtomDisposableList();
-    const updater = new AtomOnce();
-    disposables.add(a.setupWatch([
-        ["app", "url", "hash", urlParameter],
-        ["app", "url", "query", urlParameter]
-    ], (hash, query) => {
-        updater.run(() => {
-            const value = hash || query;
-            if (value) {
-                if (value != vm[name]) {
-                    vm[name] = value;
-                }
-            }
-        });
-    }));
-    disposables.add(a.setupWatch([[name]], (value) => {
-        updater.run(() => {
-            const url = vm.app.url || (vm.app.url = new AtomUri(""));
-            url.hash[urlParameter] = value;
-            vm.app.syncUrl();
-        });
-    }));
-    paramDisposables[name] = disposables;
-    if (vm.app.url) {
-        const v = vm.app.url.hash[urlParameter] || vm.app.url.query[urlParameter];
-        if (v) {
-            vm[name] = v;
+  if (!name) {
+    return;
+  }
+  if (!urlParameter) {
+    return;
+  }
+  const a = vm;
+  const paramDisposables = a.mUrlParameters || (a.mUrlParameters = {});
+  const old = paramDisposables[name];
+  if (old) {
+    old.dispose();
+    paramDisposables[name] = null;
+  }
+  const disposables = new AtomDisposableList();
+  const updater = new AtomOnce();
+  disposables.add(a.setupWatch([["app", "url", "hash", urlParameter], ["app", "url", "query", urlParameter]], (hash, query) => {
+    updater.run(() => {
+      const value = hash || query;
+      if (value) {
+        if (value != vm[name]) {
+          vm[name] = value;
         }
+      }
+    });
+  }));
+  disposables.add(a.setupWatch([[name]], value => {
+    updater.run(() => {
+      const url = vm.app.url || (vm.app.url = new AtomUri(""));
+      url.hash[urlParameter] = value;
+      vm.app.syncUrl();
+    });
+  }));
+  paramDisposables[name] = disposables;
+  if (vm.app.url) {
+    const v = vm.app.url.hash[urlParameter] || vm.app.url.query[urlParameter];
+    if (v) {
+      vm[name] = v;
     }
-    return vm.registerDisposable(disposables);
-}
-//# sourceMappingURL=bindUrlParameter.js.map
+  }
+  return vm.registerDisposable(disposables);
+}

package/dist-esm/web/controls/AtomComboBox.js

@@ -4,73 +4,66 @@ import { Inject } from "../../di/Inject.js";
 import { AtomControl } from "./AtomControl.js";
 import { AtomItemsControl } from "./AtomItemsControl.js";
 let AtomComboBox = class AtomComboBox extends AtomItemsControl {
-    constructor(app, e) {
-        super(app, e || document.createElement("select"));
-        this.allowMultipleSelection = false;
+  constructor(app, e) {
+    super(app, e || document.createElement("select"));
+    this.allowMultipleSelection = false;
+  }
+  onCollectionChanged(key, index, item) {
+    super.onCollectionChanged(key, index, item);
+    try {
+      this.isChanging = true;
+      const se = this.element;
+      se.selectedIndex = this.selectedIndex;
+    } finally {
+      this.isChanging = false;
     }
-    onCollectionChanged(key, index, item) {
-        super.onCollectionChanged(key, index, item);
-        try {
-            this.isChanging = true;
-            const se = this.element;
-            se.selectedIndex = this.selectedIndex;
-        }
-        finally {
-            this.isChanging = false;
-        }
+  }
+  updateSelectionBindings() {
+    super.updateSelectionBindings();
+    try {
+      if (this.isChanging) {
+        return;
+      }
+      this.isChanging = true;
+      const se = this.element;
+      se.selectedIndex = this.selectedIndex;
+    } finally {
+      this.isChanging = false;
     }
-    updateSelectionBindings() {
-        super.updateSelectionBindings();
-        try {
-            if (this.isChanging) {
-                return;
-            }
-            this.isChanging = true;
-            const se = this.element;
-            se.selectedIndex = this.selectedIndex;
+  }
+  preCreate() {
+    super.preCreate();
+    this.itemTemplate = AtomComboBoxItemTemplate;
+    this.runAfterInit(() => {
+      this.bindEvent(this.element, "change", s => {
+        if (this.isChanging) {
+          return;
         }
-        finally {
-            this.isChanging = false;
+        try {
+          this.isChanging = true;
+          const index = this.element.selectedIndex;
+          if (index === -1) {
+            this.selectedItems.clear();
+            return;
+          }
+          this.selectedItem = this.items[index];
+        } finally {
+          this.isChanging = false;
         }
-    }
-    preCreate() {
-        super.preCreate();
-        this.itemTemplate = AtomComboBoxItemTemplate;
-        this.runAfterInit(() => {
-            this.bindEvent(this.element, "change", (s) => {
-                if (this.isChanging) {
-                    return;
-                }
-                try {
-                    this.isChanging = true;
-                    const index = this.element.selectedIndex;
-                    if (index === -1) {
-                        this.selectedItems.clear();
-                        return;
-                    }
-                    this.selectedItem = this.items[index];
-                }
-                finally {
-                    this.isChanging = false;
-                }
-            });
-        });
-    }
+      });
+    });
+  }
 };
-AtomComboBox = __decorate([
-    __param(0, Inject),
-    __metadata("design:paramtypes", [App, HTMLElement])
-], AtomComboBox);
+AtomComboBox = __decorate([__param(0, Inject), __metadata("design:paramtypes", [App, HTMLElement])], AtomComboBox);
 export { AtomComboBox };
 class AtomComboBoxItemTemplate extends AtomControl {
-    constructor(app, e) {
-        super(app, e || document.createElement("option"));
-    }
-    create() {
-        this.bind(this.element, "text", [["data"]], false, (v) => {
-            const ip = this.element._templateParent;
-            return v[ip.labelPath];
-        });
-    }
-}
-//# sourceMappingURL=AtomComboBox.js.map
+  constructor(app, e) {
+    super(app, e || document.createElement("option"));
+  }
+  create() {
+    this.bind(this.element, "text", [["data"]], false, v => {
+      const ip = this.element._templateParent;
+      return v[ip.labelPath];
+    });
+  }
+}