@social-mail/social-mail-hosted-web 1.0.2

package/node_modules/@web-atoms/core/dist/core/AtomComponent.d.ts

@@ -0,0 +1,103 @@
+import { App } from "../App";
+import { IAnyInstanceType, IAtomElement, IDisposable, INotifyPropertyChanged, PathList } from "../core/types";
+import { AtomDisposableList } from "./AtomDisposableList";
+import { ObjectProperty } from "./AtomWatcher";
+import { IValueConverter } from "./IValueConverter";
+import XNode, { IElementAttributes, isControl, isFactorySymbol } from "./XNode";
+export interface IAtomComponent<T> {
+    element: T;
+    data: any;
+    viewModel: any;
+    localViewModel: any;
+    app: App;
+    setLocalValue(e: T, name: string, value: any): void;
+    hasProperty(name: string): any;
+    runAfterInit(f: () => void): void;
+}
+export declare abstract class AtomComponent<T extends IAtomElement, TC extends IAtomComponent<T>> implements IAtomComponent<IAtomElement>, INotifyPropertyChanged {
+    readonly app: App;
+    static readonly [isControl] = true;
+    static readonly [isFactorySymbol] = true;
+    readonly disposables: AtomDisposableList;
+    readonly element: T;
+    data: any;
+    viewModel: any;
+    localViewModel: any;
+    protected pendingInits: Array<() => void>;
+    private mInvalidated;
+    private mPendingPromises;
+    abstract get parent(): TC;
+    /** Do not ever use, only available as intellisense feature for
+     * vs code editor.
+     */
+    get vsProps(): {
+        [k in keyof this]?: this[k];
+    } | IElementAttributes;
+    private readonly eventHandlers;
+    private readonly bindings;
+    constructor(app: App, element?: T);
+    abstract atomParent(e: T): TC;
+    bind(element: T, name: string, path: PathList[], twoWays?: boolean | string[], valueFunc?: (...v: any[]) => any, source?: any): IDisposable;
+    /**
+     * Remove all bindings associated with given element and optional name
+     * @param element T
+     * @param name string
+     */
+    unbind(element: T, name?: string): void;
+    bindEvent(element: T, name?: string, method?: EventListenerOrEventListenerObject, key?: string, capture?: boolean | AddEventListenerOptions): IDisposable;
+    unbindEvent(element: T, name?: string, method?: EventListenerOrEventListenerObject, key?: string): void;
+    /**
+     * Control checks if property is declared on the control or not.
+     * Since TypeScript no longer creates enumerable properties, we have
+     * to inspect name and PropertyMap which is generated by `@BindableProperty`
+     * or the value is not set to undefined.
+     * @param name name of Property
+     */
+    hasProperty(name: string): boolean;
+    /**
+     * Use this method if you want to set attribute on HTMLElement immediately but
+     * defer atom control property
+     * @param element HTMLElement
+     * @param name string
+     * @param value any
+     */
+    setPrimitiveValue(element: T, name: string, value: any): void;
+    setLocalValue(element: T, name: string, value: any): void;
+    dispose(e?: T): void;
+    abstract append(element: T | TC): TC;
+    onPropertyChanged(name: string): void;
+    beginEdit(): IDisposable;
+    invalidate(): void;
+    onUpdateUI(): void;
+    runAfterInit(f: () => void): void;
+    registerDisposable(d: IDisposable): IDisposable;
+    protected render(node: XNode, e?: any, creator?: any): void;
+    protected extractControlProperties(x: XNode, name?: string | Function): {};
+    protected create(): void;
+    protected preCreate(): void;
+    protected setElementValue(element: T, name: string, value: any): void;
+    protected resolve<TService>(c: TService, selfName?: string | (() => any)): IAnyInstanceType<TService>;
+    protected abstract createNode(app: any, e: any, iterator: any, creator: any): any;
+    protected abstract toTemplate(app: any, iterator: any, creator: any): any;
+    protected abstract get factory(): any;
+}
+export declare class PropertyBinding<T extends IAtomElement> implements IDisposable {
+    private target;
+    readonly element: T;
+    readonly name: string;
+    private twoWays;
+    private source;
+    path: ObjectProperty[][];
+    private watcher;
+    private twoWaysDisposable;
+    private isTwoWaySetup;
+    private isRunning;
+    private fromSourceToTarget;
+    private fromTargetToSource;
+    private disposed;
+    constructor(target: IAtomComponent<T> | any, element: T, name: string, path: PathList[], twoWays: boolean | string[], valueFunc: ((...v: any[]) => any) | IValueConverter, source: any);
+    setupTwoWayBinding(): void;
+    setInverseValue(value: any): void;
+    dispose(): void;
+}
+//# sourceMappingURL=AtomComponent.d.ts.map

package/node_modules/@web-atoms/core/dist/core/AtomComponent.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AtomComponent.d.ts","sourceRoot":"","sources":["../../src/core/AtomComponent.ts"],"names":[],"mappings":"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"}

package/node_modules/@web-atoms/core/dist/core/AtomComponent.js

@@ -0,0 +1,562 @@
+System.register(["tslib", "../App", "../core/AtomBridge", "../core/types", "../di/Inject", "./AtomDisposableList", "./AtomWatcher", "./Bind", "./InheritedProperty", "./PropertyMap", "./XNode"], function (_export, _context) {
+  "use strict";
+
+  var __decorate, __metadata, __param, App, AtomBridge, ArrayHelper, CancelToken, ignoreValue, Inject, AtomDisposableList, AtomWatcher, bindSymbol, InheritedProperty, PropertyMap, attachedSymbol, constructorNeedsArgumentsSymbol, elementFactorySymbol, isControl, isFactorySymbol, xnodeSymbol, PropertyBinding, _a, _b, objectHasOwnProperty, localBindSymbol, localXNodeSymbol, elementFactory, isFactory, isAtomControl, localBridge, renderFirst, attached, constructorNeedsArguments, AtomComponent;
+  _export("PropertyBinding", void 0);
+  return {
+    setters: [function (_tslib) {
+      __decorate = _tslib.__decorate;
+      __metadata = _tslib.__metadata;
+      __param = _tslib.__param;
+    }, function (_App) {
+      App = _App.App;
+    }, function (_coreAtomBridge) {
+      AtomBridge = _coreAtomBridge.AtomBridge;
+    }, function (_coreTypes) {
+      ArrayHelper = _coreTypes.ArrayHelper;
+      CancelToken = _coreTypes.CancelToken;
+      ignoreValue = _coreTypes.ignoreValue;
+    }, function (_diInject) {
+      Inject = _diInject.Inject;
+    }, function (_AtomDisposableList) {
+      AtomDisposableList = _AtomDisposableList.AtomDisposableList;
+    }, function (_AtomWatcher) {
+      AtomWatcher = _AtomWatcher.AtomWatcher;
+    }, function (_Bind) {
+      bindSymbol = _Bind.bindSymbol;
+    }, function (_InheritedProperty) {
+      InheritedProperty = _InheritedProperty.InheritedProperty;
+    }, function (_PropertyMap) {
+      PropertyMap = _PropertyMap.PropertyMap;
+    }, function (_XNode) {
+      attachedSymbol = _XNode.attachedSymbol;
+      constructorNeedsArgumentsSymbol = _XNode.constructorNeedsArgumentsSymbol;
+      elementFactorySymbol = _XNode.elementFactorySymbol;
+      isControl = _XNode.isControl;
+      isFactorySymbol = _XNode.isFactorySymbol;
+      xnodeSymbol = _XNode.xnodeSymbol;
+    }],
+    execute: function () {
+      objectHasOwnProperty = Object.prototype.hasOwnProperty;
+      localBindSymbol = bindSymbol;
+      localXNodeSymbol = xnodeSymbol;
+      elementFactory = elementFactorySymbol;
+      isFactory = isFactorySymbol;
+      isAtomControl = isControl;
+      localBridge = AtomBridge;
+      renderFirst = AtomBridge.platform === "xf";
+      attached = attachedSymbol;
+      constructorNeedsArguments = constructorNeedsArgumentsSymbol;
+      _export("AtomComponent", AtomComponent = class AtomComponent {
+        get vsProps() {
+          return undefined;
+        }
+        constructor(app, element = null) {
+          this.app = app;
+          this.mInvalidated = 0;
+          this.mPendingPromises = {};
+          this.disposables = new AtomDisposableList();
+          this.bindings = [];
+          this.eventHandlers = [];
+          this.element = element;
+          this.element.atomControl = this;
+          const a = this.beginEdit();
+          this.preCreate();
+          this.create();
+          app.callLater(() => a.dispose());
+        }
+        bind(element, name, path, twoWays, valueFunc, source) {
+          const binding = new PropertyBinding(this, element, name, path, twoWays, valueFunc, source);
+          this.bindings.push(binding);
+          return {
+            dispose: () => {
+              binding.dispose();
+              ArrayHelper.remove(this.bindings, x => x === binding);
+            }
+          };
+        }
+        unbind(element, name) {
+          const toDelete = this.bindings.filter(x => x.element === element && (!name || x.name === name));
+          for (const iterator of toDelete) {
+            iterator.dispose();
+            ArrayHelper.remove(this.bindings, x => x === iterator);
+          }
+        }
+        bindEvent(element, name, method, key, capture) {
+          if (!element) {
+            return;
+          }
+          if (!method) {
+            return;
+          }
+          const be = {
+            element,
+            name,
+            handler: method
+          };
+          if (key) {
+            be.key = key;
+          }
+          const handler = e => {
+            var _c;
+            try {
+              let r = method(e);
+              e.executed = true;
+              if (r) {
+                const originalReturn = r;
+                r = r.then ? r : Promise.resolve(r);
+                e.promise = e.promise ? e.promise.then(() => r) : r;
+                if (originalReturn.catch) {
+                  return originalReturn.catch(c => {
+                    var _c;
+                    if (CancelToken.isCancelled(c !== null && c !== void 0 ? c : "Unknown error")) {
+                      return;
+                    }
+                    alert((_c = c.stack) !== null && _c !== void 0 ? _c : c);
+                  });
+                }
+                return r;
+              }
+            } catch (error) {
+              if (CancelToken.isCancelled(error)) {
+                return;
+              }
+              alert((_c = error.stack) !== null && _c !== void 0 ? _c : error);
+            }
+          };
+          element.addEventListener(name, handler, capture);
+          be.disposable = {
+            dispose: () => {
+              element.removeEventListener(name, handler, capture);
+              be.disposable.dispose = () => undefined;
+            }
+          };
+          this.eventHandlers.push(be);
+          return {
+            dispose: () => {
+              be.disposable.dispose();
+              ArrayHelper.remove(this.eventHandlers, e => e.disposable === be.disposable);
+            }
+          };
+        }
+        unbindEvent(element, name, method, key) {
+          const deleted = [];
+          for (const be of this.eventHandlers) {
+            if (element && be.element !== element) {
+              return;
+            }
+            if (key && be.key !== key) {
+              return;
+            }
+            if (name && be.name !== name) {
+              return;
+            }
+            if (method && be.handler !== method) {
+              return;
+            }
+            be.disposable.dispose();
+            be.handler = null;
+            be.element = null;
+            be.name = null;
+            be.key = null;
+            deleted.push(() => this.eventHandlers.remove(be));
+          }
+          for (const iterator of deleted) {
+            iterator();
+          }
+        }
+        hasProperty(name) {
+          if (/^(data|viewModel|localViewModel|element)$/.test(name)) {
+            return true;
+          }
+          const map = PropertyMap.from(this);
+          if (map.map[name]) {
+            return true;
+          }
+          if (this[name] !== undefined) {
+            return true;
+          }
+          return false;
+        }
+        setPrimitiveValue(element, name, value) {
+          const p = value;
+          if (p && p.then && p.catch) {
+            console.warn(`Do not bind promises, instead use Bind.oneWayAsync`);
+            this.mPendingPromises[name] = p;
+            p.then(r => {
+              if (this.mPendingPromises[name] !== p) {
+                return;
+              }
+              this.mPendingPromises[name] = null;
+              this.setPrimitiveValue(element, name, r);
+            }).catch(e => {
+              if (this.mPendingPromises[name] !== p) {
+                return;
+              }
+              this.mPendingPromises[name] = null;
+              console.error(e);
+            });
+            return;
+          }
+          if (/^(viewModel|localViewModel)$/.test(name)) {
+            this[name] = value;
+            return;
+          }
+          if ((!element || element === this.element) && this.hasProperty(name)) {
+            this.runAfterInit(() => {
+              this[name] = value;
+            });
+          } else {
+            this.setElementValue(element, name, value);
+          }
+        }
+        setLocalValue(element, name, value) {
+          const p = value;
+          if (p && p.then && p.catch) {
+            console.warn(`Do not bind promises, instead use Bind.oneWayAsync`);
+            this.mPendingPromises[name] = p;
+            p.then(r => {
+              if (this.mPendingPromises[name] !== p) {
+                return;
+              }
+              this.mPendingPromises[name] = null;
+              this.setLocalValue(element, name, r);
+            }).catch(e => {
+              if (this.mPendingPromises[name] !== p) {
+                return;
+              }
+              this.mPendingPromises[name] = null;
+              console.error(e);
+            });
+            return;
+          }
+          if ((!element || element === this.element) && Reflect.has(this, name)) {
+            this[name] = value;
+          } else {
+            this.setElementValue(element, name, value);
+          }
+        }
+        dispose(e) {
+          if (this.mInvalidated) {
+            clearTimeout(this.mInvalidated);
+            this.mInvalidated = 0;
+          }
+          AtomBridge.instance.visitDescendents(e || this.element, (ex, ac) => {
+            if (ac) {
+              ac.dispose();
+              return false;
+            }
+            return true;
+          });
+          if (!e) {
+            this.unbindEvent(null, null, null);
+            for (const binding of this.bindings) {
+              binding.dispose();
+            }
+            this.bindings.length = 0;
+            this.bindings = null;
+            const e1 = this.element;
+            if (typeof e1.dispose === "function") {
+              e1.dispose();
+            }
+            this.element = null;
+            const lvm = this.localViewModel;
+            if (lvm && lvm.dispose) {
+              lvm.dispose();
+              this.localViewModel = null;
+            }
+            const vm = this.viewModel;
+            if (vm && vm.dispose) {
+              vm.dispose();
+              this.viewModel = null;
+            }
+            this.disposables.dispose();
+            this.pendingInits = null;
+          }
+        }
+        onPropertyChanged(name) {}
+        beginEdit() {
+          this.pendingInits = [];
+          const a = this.pendingInits;
+          return {
+            dispose: () => {
+              if (this.pendingInits == null) {
+                return;
+              }
+              this.pendingInits = null;
+              if (a) {
+                for (const iterator of a) {
+                  iterator();
+                }
+              }
+              this.invalidate();
+            }
+          };
+        }
+        invalidate() {
+          if (this.mInvalidated) {
+            clearTimeout(this.mInvalidated);
+          }
+          this.mInvalidated = setTimeout(() => {
+            this.mInvalidated = 0;
+            this.app.callLater(() => {
+              this.onUpdateUI();
+            });
+          }, 5);
+        }
+        onUpdateUI() {}
+        runAfterInit(f) {
+          if (this.pendingInits) {
+            this.pendingInits.push(f);
+          } else {
+            f();
+          }
+        }
+        registerDisposable(d) {
+          return this.disposables.add(d);
+        }
+        render(node, e = this.element, creator = this) {
+          const app = this.app;
+          const attr = node.attributes;
+          if (attr) {
+            for (const key in attr) {
+              if (attr.hasOwnProperty(key)) {
+                const item = attr[key];
+                const isObject = typeof item === "object";
+                if (isObject && item !== null) {
+                  const localSymbol = item[localBindSymbol];
+                  if (localSymbol) {
+                    localSymbol(key, this, e, creator);
+                    continue;
+                  }
+                  const localXNode = item[localXNodeSymbol];
+                  if (localXNode) {
+                    if (item.isTemplate) {
+                      this.setLocalValue(e, key, this.toTemplate(app, item, creator));
+                      continue;
+                    }
+                    this.setLocalValue(e, key, this.createNode(app, null, item, creator));
+                    continue;
+                  }
+                }
+                this.setLocalValue(e, key, item);
+              }
+            }
+          }
+          const children = node.children;
+          if (children === void 0) {
+            return;
+          }
+          for (const iterator of children) {
+            if (!iterator) {
+              continue;
+            }
+            if (!iterator[localXNodeSymbol]) {
+              e.appendChild(document.createTextNode(iterator.toString()));
+              continue;
+            }
+            if (iterator.isProperty) {
+              if (iterator.isTemplate) {
+                this.setLocalValue(e, iterator.name, this.toTemplate(app, iterator.children[0], creator));
+                continue;
+              }
+              this.createNode(app, e, iterator, creator);
+              continue;
+            }
+            const t = iterator.attributes && iterator.attributes.template;
+            if (t) {
+              console.warn(`This path is deprecated, check who is calling it.`);
+              this.setLocalValue(e, t, this.toTemplate(app, iterator, creator));
+              continue;
+            }
+            this.createNode(app, e, iterator, creator);
+          }
+        }
+        extractControlProperties(x, name = "div") {
+          const a = x.attributes;
+          const extracted = {};
+          if (typeof x.name === "function" && this instanceof x.name) {
+            x.name = name;
+          }
+          if (a) {
+            for (const key in a) {
+              if (Object.prototype.hasOwnProperty.call(a, key)) {
+                if (Reflect.has(this, key)) {
+                  const element = a[key];
+                  extracted[key] = element;
+                  delete a[key];
+                }
+              }
+            }
+          }
+          return extracted;
+        }
+        create() {}
+        preCreate() {}
+        setElementValue(element, name, value) {
+          AtomBridge.instance.setValue(element, name, value);
+        }
+        resolve(c, selfName) {
+          const result = this.app.resolve(c, true);
+          if (selfName) {
+            if (typeof selfName === "function") {
+              this.runAfterInit(() => {
+                const v = selfName();
+                if (v) {
+                  for (const key in v) {
+                    if (v.hasOwnProperty(key)) {
+                      const element = v[key];
+                      result[key] = element;
+                    }
+                  }
+                }
+              });
+            } else {
+              result[selfName] = this;
+            }
+          }
+          return result;
+        }
+      });
+      _a = isControl, _b = isFactorySymbol;
+      AtomComponent[_a] = true;
+      AtomComponent[_b] = true;
+      __decorate([InheritedProperty, __metadata("design:type", Object)], AtomComponent.prototype, "data", void 0);
+      __decorate([InheritedProperty, __metadata("design:type", Object)], AtomComponent.prototype, "viewModel", void 0);
+      __decorate([InheritedProperty, __metadata("design:type", Object)], AtomComponent.prototype, "localViewModel", void 0);
+      _export("AtomComponent", AtomComponent = __decorate([__param(0, Inject), __metadata("design:paramtypes", [App, Object])], AtomComponent));
+      _export("PropertyBinding", PropertyBinding = class PropertyBinding {
+        constructor(target, element, name, path, twoWays, valueFunc, source) {
+          this.target = target;
+          this.element = element;
+          this.name = name;
+          this.twoWays = twoWays;
+          this.source = source;
+          this.isTwoWaySetup = false;
+          this.name = name;
+          this.twoWays = twoWays;
+          this.target = target;
+          this.element = element;
+          this.isRunning = false;
+          if (valueFunc) {
+            if (typeof valueFunc !== "function") {
+              this.fromSourceToTarget = valueFunc.fromSource;
+              this.fromTargetToSource = valueFunc.fromTarget;
+            } else {
+              this.fromSourceToTarget = valueFunc;
+            }
+          }
+          this.watcher = new AtomWatcher(target, path, (...v) => {
+            if (this.isRunning) {
+              return;
+            }
+            if (this.disposed) {
+              return;
+            }
+            for (const iterator of v) {
+              if (iterator === undefined) {
+                return;
+              }
+            }
+            const cv = this.fromSourceToTarget ? this.fromSourceToTarget.apply(this, v) : v[0];
+            if (cv === ignoreValue) {
+              return;
+            }
+            this.isRunning = true;
+            try {
+              if (this.target instanceof AtomComponent) {
+                this.target.setLocalValue(this.element, this.name, cv);
+              } else {
+                this.target[name] = cv;
+              }
+            } finally {
+              this.isRunning = false;
+            }
+          }, source);
+          this.path = this.watcher.path;
+          if (this.target instanceof AtomComponent) {
+            this.target.runAfterInit(() => {
+              if (!this.watcher) {
+                return;
+              }
+              this.watcher.init(true);
+              if (twoWays) {
+                this.setupTwoWayBinding();
+              }
+            });
+          } else {
+            this.watcher.init(true);
+            if (twoWays) {
+              this.setupTwoWayBinding();
+            }
+          }
+        }
+        setupTwoWayBinding() {
+          if (this.target instanceof AtomComponent) {
+            if (this.element && (this.element !== this.target.element || !this.target.hasProperty(this.name))) {
+              let events = [];
+              if (typeof this.twoWays !== "boolean") {
+                events = this.twoWays;
+              }
+              this.twoWaysDisposable = AtomBridge.instance.watchProperty(this.element, this.name, events, v => {
+                this.setInverseValue(v);
+              });
+              return;
+            }
+          }
+          const watcher = new AtomWatcher(this.target, [[this.name]], (...values) => {
+            if (this.isTwoWaySetup) {
+              this.setInverseValue(values[0]);
+            }
+          });
+          watcher.init(true);
+          this.isTwoWaySetup = true;
+          this.twoWaysDisposable = watcher;
+        }
+        setInverseValue(value) {
+          if (!this.twoWays) {
+            throw new Error("This Binding is not two ways.");
+          }
+          if (this.disposed) {
+            return;
+          }
+          if (this.isRunning) {
+            return;
+          }
+          this.isRunning = true;
+          try {
+            const first = this.path[0];
+            const length = first.length;
+            let v = this.target;
+            let i = 0;
+            let name;
+            for (i = 0; i < length - 1; i++) {
+              name = first[i].name;
+              if (name === "this") {
+                v = this.source || this.target;
+              } else {
+                v = v[name];
+              }
+              if (!v) {
+                return;
+              }
+            }
+            name = first[i].name;
+            v[name] = this.fromTargetToSource ? this.fromTargetToSource.call(this, value) : value;
+          } finally {
+            this.isRunning = false;
+          }
+        }
+        dispose() {
+          var _c;
+          (_c = this.twoWaysDisposable) === null || _c === void 0 ? void 0 : _c.dispose();
+          this.twoWaysDisposable = undefined;
+          this.watcher.dispose();
+          this.disposed = true;
+          this.watcher = null;
+        }
+      });
+    }
+  };
+});
+//# sourceMappingURL=AtomComponent.js.map