@web-atoms/core 2.6.21 → 2.6.25

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

@@ -8,275 +8,277 @@ import { BindableProperty } from "../core/BindableProperty.js";
 import { Inject } from "../di/Inject.js";
 import { registerInit } from "./baseTypes.js";
 function runDecoratorInits() {
-    const v = this.constructor.prototype;
-    if (!v) {
-        return;
-    }
-    const ris = v._$_inits;
-    if (ris) {
-        for (const ri of ris) {
-            ri.call(this, this);
-        }
+  const v = this.constructor.prototype;
+  if (!v) {
+    return;
+  }
+  const ris = v._$_inits;
+  if (ris) {
+    for (const ri of ris) {
+      ri.call(this, this);
     }
+  }
 }
 async function privateInit() {
-    try {
-        await Atom.postAsync(this.app, async () => {
-            runDecoratorInits.apply(this);
-        });
-        await Atom.postAsync(this.app, async () => {
-            await this.init();
-            this.onReady();
-        });
-        if (this.postInit) {
-            for (const i of this.postInit) {
-                i();
-            }
-            this.postInit = null;
-        }
+  try {
+    await Atom.postAsync(this.app, async () => {
+      runDecoratorInits.apply(this);
+    });
+    await Atom.postAsync(this.app, async () => {
+      await this.init();
+      this.onReady();
+    });
+    if (this.postInit) {
+      for (const i of this.postInit) {
+        i();
+      }
+      this.postInit = null;
     }
-    finally {
-        const pi = this.pendingInits;
-        this.pendingInits = null;
-        for (const iterator of pi) {
-            iterator();
-        }
+  } finally {
+    const pi = this.pendingInits;
+    this.pendingInits = null;
+    for (const iterator of pi) {
+      iterator();
     }
+  }
 }
 export async function waitForReady(vm) {
-    while (vm.pendingInits) {
-        await Atom.delay(100);
-    }
+  while (vm.pendingInits) {
+    await Atom.delay(100);
+  }
 }
 let AtomViewModel = class AtomViewModel {
-    get isReady() {
-        return this.pendingInits === null;
+  get isReady() {
+    return this.pendingInits === null;
+  }
+  get errors() {
+    const e = [];
+    if (!this.mShouldValidate) {
+      return e;
     }
-    get errors() {
-        const e = [];
-        if (!this.mShouldValidate) {
-            return e;
-        }
-        for (const v of this.validations) {
-            if (!v.initialized) {
-                return e;
-            }
-            const error = this[v.name];
-            if (error) {
-                e.push({ name: v.name, error });
-            }
-        }
+    for (const v of this.validations) {
+      if (!v.initialized) {
         return e;
+      }
+      const error = this[v.name];
+      if (error) {
+        e.push({
+          name: v.name,
+          error
+        });
+      }
     }
-    get parent() {
-        return this.mParent;
+    return e;
+  }
+  get parent() {
+    return this.mParent;
+  }
+  set parent(v) {
+    if (this.mParent && this.mParent.mChildren) {
+      this.mParent.mChildren.remove(this);
     }
-    set parent(v) {
-        if (this.mParent && this.mParent.mChildren) {
-            this.mParent.mChildren.remove(this);
-        }
-        this.mParent = v;
-        if (v) {
-            const c = v.mChildren || (v.mChildren = []);
-            c.add(this);
-            this.registerDisposable({
-                dispose: () => {
-                    c.remove(this);
-                }
-            });
-        }
-    }
-    get isValid() {
-        let valid = true;
-        const validateWasFalse = this.mShouldValidate === false;
-        this.mShouldValidate = true;
-        for (const v of this.validations) {
-            if (!v.initialized) {
-                v.watcher.init(true);
-                v.initialized = true;
-            }
-            if (this[v.name]) {
-                if (validateWasFalse) {
-                    AtomBinder.refreshValue(this, v.name);
-                }
-                valid = false;
-            }
-        }
-        if (this.mChildren) {
-            for (const child of this.mChildren) {
-                if (!child.isValid) {
-                    valid = false;
-                }
-            }
+    this.mParent = v;
+    if (v) {
+      const c = v.mChildren || (v.mChildren = []);
+      c.add(this);
+      this.registerDisposable({
+        dispose: () => {
+          c.remove(this);
         }
-        AtomBinder.refreshValue(this, "errors");
-        return valid;
+      });
     }
-    constructor(app) {
-        this.app = app;
-        this.disposables = null;
-        this.validations = [];
-        this.pendingInits = [];
-        this.mShouldValidate = false;
-        this.app.runAsync(() => privateInit.apply(this));
-    }
-    resetValidations(resetChildren = true) {
-        this.mShouldValidate = false;
-        for (const v of this.validations) {
-            this.refresh(v.name);
-        }
-        if (resetChildren && this.mChildren) {
-            for (const iterator of this.mChildren) {
-                iterator.resetValidations(resetChildren);
-            }
+  }
+  get isValid() {
+    let valid = true;
+    const validateWasFalse = this.mShouldValidate === false;
+    this.mShouldValidate = true;
+    for (const v of this.validations) {
+      if (!v.initialized) {
+        v.watcher.init(true);
+        v.initialized = true;
+      }
+      if (this[v.name]) {
+        if (validateWasFalse) {
+          AtomBinder.refreshValue(this, v.name);
         }
+        valid = false;
+      }
     }
-    runAfterInit(f) {
-        if (this.pendingInits) {
-            this.pendingInits.push(f);
-            return;
+    if (this.mChildren) {
+      for (const child of this.mChildren) {
+        if (!child.isValid) {
+          valid = false;
         }
-        f();
+      }
     }
-    refresh(name) {
-        AtomBinder.refreshValue(this, name);
+    AtomBinder.refreshValue(this, "errors");
+    return valid;
+  }
+  constructor(app) {
+    this.app = app;
+    this.disposables = null;
+    this.validations = [];
+    this.pendingInits = [];
+    this.mShouldValidate = false;
+    this.app.runAsync(() => privateInit.apply(this));
+  }
+  resetValidations(resetChildren = true) {
+    this.mShouldValidate = false;
+    for (const v of this.validations) {
+      this.refresh(v.name);
     }
-    async init() {
+    if (resetChildren && this.mChildren) {
+      for (const iterator of this.mChildren) {
+        iterator.resetValidations(resetChildren);
+      }
     }
-    dispose() {
-        if (this.disposables) {
-            this.disposables.dispose();
-        }
+  }
+  runAfterInit(f) {
+    if (this.pendingInits) {
+      this.pendingInits.push(f);
+      return;
     }
-    registerDisposable(d) {
-        this.disposables = this.disposables || new AtomDisposableList();
-        return this.disposables.add(d);
+    f();
+  }
+  refresh(name) {
+    AtomBinder.refreshValue(this, name);
+  }
+  async init() {}
+  dispose() {
+    if (this.disposables) {
+      this.disposables.dispose();
     }
-    onReady() { }
-    setupWatch(ft, proxy, forValidation, name) {
-        const d = new AtomWatcher(this, ft, proxy, this);
-        if (forValidation) {
-            this.validations = this.validations || [];
-            this.validations.push({ name, watcher: d, initialized: false });
-        }
-        else {
-            d.init();
-        }
-        return this.registerDisposable(d);
+  }
+  registerDisposable(d) {
+    this.disposables = this.disposables || new AtomDisposableList();
+    return this.disposables.add(d);
+  }
+  onReady() {}
+  setupWatch(ft, proxy, forValidation, name) {
+    const d = new AtomWatcher(this, ft, proxy, this);
+    if (forValidation) {
+      this.validations = this.validations || [];
+      this.validations.push({
+        name,
+        watcher: d,
+        initialized: false
+      });
+    } else {
+      d.init();
     }
-    onPropertyChanged(name) { }
+    return this.registerDisposable(d);
+  }
+  onPropertyChanged(name) {}
 };
-AtomViewModel = __decorate([
-    __param(0, Inject),
-    __metadata("design:paramtypes", [App])
-], AtomViewModel);
+AtomViewModel = __decorate([__param(0, Inject), __metadata("design:paramtypes", [App])], AtomViewModel);
 export { AtomViewModel };
 export function Receive(...channel) {
-    return (target, key) => {
-        registerInit(target, (vm) => {
-            const fx = vm[key];
-            const a = (ch, d) => {
-                const p = fx.call(vm, ch, d);
-                if (p && p.then && p.catch) {
-                    p.catch((e) => {
-                        console.warn(e);
-                    });
-                }
-            };
-            const ivm = vm;
-            for (const c of channel) {
-                ivm.registerDisposable(ivm.app.subscribe(c, a));
-            }
-        });
-    };
+  return (target, key) => {
+    registerInit(target, vm => {
+      const fx = vm[key];
+      const a = (ch, d) => {
+        const p = fx.call(vm, ch, d);
+        if (p && p.then && p.catch) {
+          p.catch(e => {
+            console.warn(e);
+          });
+        }
+      };
+      const ivm = vm;
+      for (const c of channel) {
+        ivm.registerDisposable(ivm.app.subscribe(c, a));
+      }
+    });
+  };
 }
 export function BindableReceive(...channel) {
-    return (target, key) => {
-        const bp = BindableProperty(target, key);
-        registerInit(target, (vm) => {
-            const fx = (cx, m) => {
-                vm[key] = m;
-            };
-            const ivm = vm;
-            for (const c of channel) {
-                ivm.registerDisposable(ivm.app.subscribe(c, fx));
-            }
-        });
-        return bp;
-    };
+  return (target, key) => {
+    const bp = BindableProperty(target, key);
+    registerInit(target, vm => {
+      const fx = (cx, m) => {
+        vm[key] = m;
+      };
+      const ivm = vm;
+      for (const c of channel) {
+        ivm.registerDisposable(ivm.app.subscribe(c, fx));
+      }
+    });
+    return bp;
+  };
 }
 export function BindableBroadcast(...channel) {
-    return (target, key) => {
-        const bp = BindableProperty(target, key);
-        registerInit(target, (vm) => {
-            const fx = (t) => {
-                const v = vm[key];
-                for (const c of channel) {
-                    vm.app.broadcast(c, v);
-                }
-            };
-            const d = new AtomWatcher(vm, [key.split(".")], fx);
-            d.init();
-            vm.registerDisposable(d);
-        });
-        return bp;
-    };
-}
-export function Watch(target, key, descriptor) {
-    registerInit(target, (vm) => {
-        const ivm = vm;
-        if (descriptor && descriptor.get) {
-            ivm.setupWatch(descriptor.get, () => {
-                vm.refresh(key.toString());
-            });
-            return;
+  return (target, key) => {
+    const bp = BindableProperty(target, key);
+    registerInit(target, vm => {
+      const fx = t => {
+        const v = vm[key];
+        for (const c of channel) {
+          vm.app.broadcast(c, v);
         }
-        ivm.setupWatch(vm[key]);
+      };
+      const d = new AtomWatcher(vm, [key.split(".")], fx);
+      d.init();
+      vm.registerDisposable(d);
     });
+    return bp;
+  };
+}
+export function Watch(target, key, descriptor) {
+  registerInit(target, vm => {
+    const ivm = vm;
+    if (descriptor && descriptor.get) {
+      ivm.setupWatch(descriptor.get, () => {
+        vm.refresh(key.toString());
+      });
+      return;
+    }
+    ivm.setupWatch(vm[key]);
+  });
 }
 export function CachedWatch(target, key, descriptor) {
-    const getMethod = descriptor.get;
-    descriptor.get = (() => null);
-    registerInit(target, (vm) => {
-        const ivm = vm;
-        const fieldName = `_${key}`;
-        Object.defineProperty(ivm, key, {
-            enumerable: true,
-            configurable: true,
-            get() {
-                const c = ivm[fieldName] || (ivm[fieldName] = {
-                    value: getMethod.apply(ivm)
-                });
-                return c.value;
-            }
-        });
-        ivm.setupWatch(getMethod, () => {
-            ivm[fieldName] = null;
-            AtomBinder.refreshValue(ivm, key);
+  const getMethod = descriptor.get;
+  descriptor.get = () => null;
+  registerInit(target, vm => {
+    const ivm = vm;
+    const fieldName = `_${key}`;
+    Object.defineProperty(ivm, key, {
+      enumerable: true,
+      configurable: true,
+      get() {
+        const c = ivm[fieldName] || (ivm[fieldName] = {
+          value: getMethod.apply(ivm)
         });
+        return c.value;
+      }
     });
+    ivm.setupWatch(getMethod, () => {
+      ivm[fieldName] = null;
+      AtomBinder.refreshValue(ivm, key);
+    });
+  });
 }
 export function Validate(target, key, descriptor) {
-    const getMethod = descriptor.get;
-    descriptor.get = () => null;
-    registerInit(target, (vm) => {
-        const initialized = { i: false };
-        const ivm = vm;
-        Object.defineProperty(ivm, key, {
-            enumerable: true,
-            configurable: true,
-            get() {
-                if (vm.mShouldValidate && initialized.i) {
-                    return getMethod.apply(this);
-                }
-                return null;
-            }
-        });
-        ivm.setupWatch(getMethod, () => {
-            initialized.i = true;
-            vm.refresh(key.toString());
-        }, true, key.toString());
-        return;
+  const getMethod = descriptor.get;
+  descriptor.get = () => null;
+  registerInit(target, vm => {
+    const initialized = {
+      i: false
+    };
+    const ivm = vm;
+    Object.defineProperty(ivm, key, {
+      enumerable: true,
+      configurable: true,
+      get() {
+        if (vm.mShouldValidate && initialized.i) {
+          return getMethod.apply(this);
+        }
+        return null;
+      }
     });
-}
-//# sourceMappingURL=AtomViewModel.js.map
+    ivm.setupWatch(getMethod, () => {
+      initialized.i = true;
+      vm.refresh(key.toString());
+    }, true, key.toString());
+    return;
+  });
+}

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

@@ -1,18 +1,17 @@
 import { NavigationService } from "../services/NavigationService.js";
 import { AtomViewModel } from "./AtomViewModel.js";
 export class AtomWindowViewModel extends AtomViewModel {
-    close(result) {
-        this.app.broadcast(`atom-window-close:${this.windowName}`, result);
+  close(result) {
+    this.app.broadcast(`atom-window-close:${this.windowName}`, result);
+  }
+  async cancel() {
+    if (this.closeWarning) {
+      const navigationService = this.app.resolve(NavigationService);
+      if (!(await navigationService.confirm(this.closeWarning, "Are you sure?"))) {
+        return false;
+      }
     }
-    async cancel() {
-        if (this.closeWarning) {
-            const navigationService = this.app.resolve(NavigationService);
-            if (!await navigationService.confirm(this.closeWarning, "Are you sure?")) {
-                return false;
-            }
-        }
-        this.app.broadcast(`atom-window-cancel:${this.windowName}`, "cancelled");
-        return true;
-    }
-}
-//# sourceMappingURL=AtomWindowViewModel.js.map
+    this.app.broadcast(`atom-window-cancel:${this.windowName}`, "cancelled");
+    return true;
+  }
+}

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

@@ -2,11 +2,10 @@ import { BindableProperty } from "../core/BindableProperty.js";
 import { registerInit } from "./baseTypes.js";
 import bindUrlParameter from "./bindUrlParameter.js";
 export default function BindableUrlParameter(name) {
-    return (target, key, descriptor) => {
-        registerInit(target, (vm) => {
-            bindUrlParameter(vm, key, name);
-        });
-        return BindableProperty(target, key);
-    };
-}
-//# sourceMappingURL=BindableUrlParameter.js.map
+  return (target, key, descriptor) => {
+    registerInit(target, vm => {
+      bindUrlParameter(vm, key, name);
+    });
+    return BindableProperty(target, key);
+  };
+}

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

@@ -1,27 +1,23 @@
 import { registerInit } from "./baseTypes.js";
 export default function Delay(delayInSeconds, repeat = false) {
-    return (target, key) => {
-        registerInit(target, (vm) => {
-            const fx = vm[key];
-            const afx = () => {
-                vm.app.runAsync(() => fx.apply(vm));
-            };
-            const dx = delayInSeconds * 1000;
-            const id = repeat
-                ? setInterval(afx, dx)
-                : setTimeout(afx, dx);
-            const d = {
-                dispose() {
-                    if (repeat) {
-                        clearInterval(id);
-                    }
-                    else {
-                        clearTimeout(id);
-                    }
-                }
-            };
-            vm.registerDisposable(d);
-        });
-    };
-}
-//# sourceMappingURL=Delay.js.map
+  return (target, key) => {
+    registerInit(target, vm => {
+      const fx = vm[key];
+      const afx = () => {
+        vm.app.runAsync(() => fx.apply(vm));
+      };
+      const dx = delayInSeconds * 1000;
+      const id = repeat ? setInterval(afx, dx) : setTimeout(afx, dx);
+      const d = {
+        dispose() {
+          if (repeat) {
+            clearInterval(id);
+          } else {
+            clearTimeout(id);
+          }
+        }
+      };
+      vm.registerDisposable(d);
+    });
+  };
+}

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

@@ -1,33 +1,32 @@
 const Disposable = (target, key) => {
-    const iVal = target[key];
-    const keyName = "_" + key;
-    const disposableKey = "_$_disposable" + key;
-    target[keyName] = iVal;
-    if (iVal) {
-        target[disposableKey] = target.registerDisposable(iVal);
+  const iVal = target[key];
+  const keyName = "_" + key;
+  const disposableKey = "_$_disposable" + key;
+  target[keyName] = iVal;
+  if (iVal) {
+    target[disposableKey] = target.registerDisposable(iVal);
+  }
+  const getter = function () {
+    return this[keyName];
+  };
+  const setter = function (newVal) {
+    const oldValue = this[keyName];
+    if (oldValue == newVal) {
+      return;
     }
-    const getter = function () {
-        return this[keyName];
-    };
-    const setter = function (newVal) {
-        const oldValue = this[keyName];
-        if (oldValue == newVal) {
-            return;
-        }
-        const oldDisposable = this[disposableKey];
-        if (oldDisposable && oldDisposable.dispose) {
-            oldDisposable.dispose();
-        }
-        this[keyName] = newVal;
-    };
-    if (delete target[key]) {
-        Object.defineProperty(target, key, {
-            get: getter,
-            set: setter,
-            enumerable: true,
-            configurable: true
-        });
+    const oldDisposable = this[disposableKey];
+    if (oldDisposable && oldDisposable.dispose) {
+      oldDisposable.dispose();
     }
+    this[keyName] = newVal;
+  };
+  if (delete target[key]) {
+    Object.defineProperty(target, key, {
+      get: getter,
+      set: setter,
+      enumerable: true,
+      configurable: true
+    });
+  }
 };
-export default Disposable;
-//# sourceMappingURL=Disposable.js.map
+export default Disposable;