@web-atoms/core 2.1.479 → 2.2.0

package/dist/core/Bind.js

@@ -1,425 +1,333 @@
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-(function (factory) {
-    if (typeof module === "object" && typeof module.exports === "object") {
-        var v = factory(require, exports);
-        if (v !== undefined) module.exports = v;
-    }
-    else if (typeof define === "function" && define.amd) {
-        define(["require", "exports", "./ExpressionParser", "./types"], factory);
-    }
-})(function (require, exports) {
-    "use strict";
-    Object.defineProperty(exports, "__esModule", { value: true });
-    exports.bindSymbol = void 0;
-    const ExpressionParser_1 = require("./ExpressionParser");
-    const types_1 = require("./types");
-    const isEvent = /^event/i;
-    // function oneTime(name: string, b: Bind, control: IAtomComponent, e: any) {
-    //     control.runAfterInit(() => {
-    //         control.setLocalValue(e, name, b.sourcePath(control, e));
-    //     });
-    // }
-    // function event(name: string, b: Bind, control: IAtomComponent, e: any) {
-    //     control.runAfterInit(() => {
-    //         if (isEvent.test(name)) {
-    //             name = name.substr(5);
-    //             name = (name[0].toLowerCase() + name.substr(1));
-    //         }
-    //         control.bindEvent(e, name, (e1) => {
-    //             return (b.sourcePath as any)(control, e1);
-    //         });
-    //     });
-    // }
-    // function oneWay(name: string, b: Bind, control: IAtomComponent, e: any, creator: any) {
-    //     if (b.pathList) {
-    //         control.bind(e, name, b.pathList , false, () => {
-    //             // tslint:disable-next-line: ban-types
-    //             return (b.sourcePath as Function).call(creator, control, e);
-    //         });
-    //         return;
-    //     }
-    //     if (b.combined) {
-    //         const a = {
-    //             // it is `this`
-    //             t: creator,
-    //             // it is first parameter
-    //             x: control
-    //         };
-    //         control.bind(e, name, b.combined , false, () => {
-    //             // tslint:disable-next-line: ban-types
-    //             return (b.sourcePath as Function).call(creator, control, e);
-    //         }, a);
-    //         return;
-    //     }
-    //     if (b.thisPathList) {
-    //         control.bind(e, name, b.thisPathList , false, () => {
-    //             // tslint:disable-next-line: ban-types
-    //             return (b.sourcePath as Function).call(creator, control, e);
-    //         }, creator);
-    //         return;
-    //     }
-    // }
-    // function twoWays(name: string, b: Bind, control: IAtomComponent, e: any, creator: any) {
-    //     control.bind(e,
-    //         name,
-    //         b.thisPathList || b.pathList, (b.eventList as any) || true, null, b.thisPathList ? creator : undefined);
-    // }
-    function twoWaysConvert(name, b, control, e, creator) {
-        control.bind(e, name, b.thisPathList || b.pathList, b.eventList || true, null, b.thisPathList ? creator : undefined);
-    }
-    exports.bindSymbol = Symbol("Bind");
-    class Bind {
+System.register(["./ExpressionParser", "./types"], function (_export, _context) {
+  "use strict";
+
+  var parsePath, parsePathLists, CancelToken, ignoreValue, Bind, __awaiter, isEvent, bindSymbol;
+  function twoWaysConvert(name, b, control, e, creator) {
+    control.bind(e, name, b.thisPathList || b.pathList, b.eventList || true, null, b.thisPathList ? creator : undefined);
+  }
+  _export("default", void 0);
+  return {
+    setters: [function (_ExpressionParser) {
+      parsePath = _ExpressionParser.parsePath;
+      parsePathLists = _ExpressionParser.parsePathLists;
+    }, function (_types) {
+      CancelToken = _types.CancelToken;
+      ignoreValue = _types.ignoreValue;
+    }],
+    execute: function () {
+      __awaiter = void 0 && (void 0).__awaiter || function (thisArg, _arguments, P, generator) {
+        function adopt(value) {
+          return value instanceof P ? value : new P(function (resolve) {
+            resolve(value);
+          });
+        }
+        return new (P || (P = Promise))(function (resolve, reject) {
+          function fulfilled(value) {
+            try {
+              step(generator.next(value));
+            } catch (e) {
+              reject(e);
+            }
+          }
+          function rejected(value) {
+            try {
+              step(generator["throw"](value));
+            } catch (e) {
+              reject(e);
+            }
+          }
+          function step(result) {
+            result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected);
+          }
+          step((generator = generator.apply(thisArg, _arguments || [])).next());
+        });
+      };
+      isEvent = /^event/i;
+      _export("bindSymbol", bindSymbol = Symbol("Bind"));
+      _export("default", Bind = class Bind {
         static forControl() {
-            return Bind;
+          return Bind;
         }
         static forData() {
-            return Bind;
+          return Bind;
         }
         static forViewModel() {
-            return Bind;
+          return Bind;
         }
         static forLocalViewModel() {
-            return Bind;
+          return Bind;
         }
         static presenter(name) {
-            return {
-                [exports.bindSymbol](cn, control, e, creator) {
-                    if (typeof name === "function") {
-                        name(control);
-                        return;
-                    }
-                    const n = name || cn;
-                    let c = control.element;
-                    while (c) {
-                        if (c.atomControl && c.atomControl[n] !== undefined) {
-                            break;
-                        }
-                        c = c._logicalParent || c.parentElement;
-                    }
-                    ((c && c.atomControl) || control)[n] = e;
+          return {
+            [bindSymbol](cn, control, e, creator) {
+              if (typeof name === "function") {
+                name(control);
+                return;
+              }
+              const n = name || cn;
+              let c = control.element;
+              while (c) {
+                if (c.atomControl && c.atomControl[n] !== undefined) {
+                  break;
                 }
-            };
+                c = c._logicalParent || c.parentElement;
+              }
+              (c && c.atomControl || control)[n] = e;
+            }
+          };
         }
-        // tslint:disable-next-line: ban-types
         static event(sourcePath) {
-            return {
-                [exports.bindSymbol](name, control, e) {
-                    control.runAfterInit(() => {
-                        if (isEvent.test(name)) {
-                            name = name.substring(5);
-                            if (name.startsWith("-")) {
-                                name = name.substring(1).replace(/-([a-z])/g, (g) => g[1].toUpperCase());
-                            }
-                            else {
-                                name = (name[0].toLowerCase() + name.substring(1));
-                            }
-                        }
-                        control.bindEvent(e, name, (e1) => {
-                            return sourcePath(control, e1);
-                        });
-                    });
+          return {
+            [bindSymbol](name, control, e) {
+              control.runAfterInit(() => {
+                if (isEvent.test(name)) {
+                  name = name.substring(5);
+                  if (name.startsWith("-")) {
+                    name = name.substring(1).replace(/-([a-z])/g, g => g[1].toUpperCase());
+                  } else {
+                    name = name[0].toLowerCase() + name.substring(1);
+                  }
                 }
-            };
+                control.bindEvent(e, name, e1 => {
+                  return sourcePath(control, e1);
+                });
+              });
+            }
+          };
         }
-        /**
-         * Bind the expression one time
-         * @param sourcePath Lambda Expression for binding
-         * @param now Default value to set immediately
-         */
         static oneTime(sourcePath, now) {
-            return {
-                [exports.bindSymbol](name, control, e) {
-                    control.runAfterInit(() => {
-                        control.setLocalValue(e, name, sourcePath(control, e));
-                    });
-                    if (typeof now !== "undefined") {
-                        control.setLocalValue(e, name, now);
-                    }
-                }
-            };
+          return {
+            [bindSymbol](name, control, e) {
+              control.runAfterInit(() => {
+                control.setLocalValue(e, name, sourcePath(control, e));
+              });
+              if (typeof now !== "undefined") {
+                control.setLocalValue(e, name, now);
+              }
+            }
+          };
         }
-        /**
-         * Bind the expression one time
-         * @param sourcePath Lambda Expression for binding
-         * @param now Default value to set immediately
-         */
         static oneTimeAsync(sourcePath, now) {
-            return {
-                [exports.bindSymbol](name, control, e) {
-                    control.runAfterInit(() => {
-                        control.app.runAsync(() => __awaiter(this, void 0, void 0, function* () {
-                            const value = yield sourcePath(control, e, new types_1.CancelToken());
-                            control.setLocalValue(e, name, value);
-                        }));
-                    });
-                    if (typeof now !== "undefined") {
-                        control.setLocalValue(e, name, now);
-                    }
-                }
-            };
+          return {
+            [bindSymbol](name, control, e) {
+              control.runAfterInit(() => {
+                control.app.runAsync(() => __awaiter(this, void 0, void 0, function* () {
+                  const value = yield sourcePath(control, e, new CancelToken());
+                  control.setLocalValue(e, name, value);
+                }));
+              });
+              if (typeof now !== "undefined") {
+                control.setLocalValue(e, name, now);
+              }
+            }
+          };
         }
-        /**
-         * Bind the expression one way with source, you cannot reference
-         * `this` inside this context, it will not watch `this`
-         * @param source source to watch
-         * @param path Lambda Expression for binding
-         * @param now Default value to set immediately
-         */
         static source(source, path, now) {
-            const lists = (0, ExpressionParser_1.parsePath)(path, false).map((x) => ["this", ...x]);
-            return {
-                [exports.bindSymbol](name, control, e, creator) {
-                    const self = { control, source };
-                    control.bind(e, name, lists, false, () => {
-                        return path.call(self, self);
-                    }, self);
-                    if (typeof now !== "undefined") {
-                        control.setLocalValue(e, name, now);
-                    }
-                }
-            };
+          const lists = parsePath(path, false).map(x => ["this", ...x]);
+          return {
+            [bindSymbol](name, control, e, creator) {
+              const self = {
+                control,
+                source
+              };
+              control.bind(e, name, lists, false, () => {
+                return path.call(self, self);
+              }, self);
+              if (typeof now !== "undefined") {
+                control.setLocalValue(e, name, now);
+              }
+            }
+          };
         }
-        static oneWayAsync(sourcePath, { watchDelayInMS = 250, default: defaultValue } = {}) {
-            let pathList;
-            let combined;
-            let thisPathList;
-            if (Array.isArray(sourcePath)) {
-                pathList = sourcePath;
+        static oneWayAsync(sourcePath, {
+          watchDelayInMS = 250,
+          default: defaultValue
+        } = {}) {
+          let pathList;
+          let combined;
+          let thisPathList;
+          if (Array.isArray(sourcePath)) {
+            pathList = sourcePath;
+          } else {
+            const lists = parsePathLists(sourcePath);
+            if (lists.combined.length) {
+              combined = lists.combined;
             }
-            else {
-                const lists = (0, ExpressionParser_1.parsePathLists)(sourcePath);
-                if (lists.combined.length) {
-                    combined = lists.combined;
-                }
-                if (lists.pathList.length) {
-                    pathList = lists.pathList;
-                }
-                if (lists.thisPath.length) {
-                    thisPathList = lists.thisPath;
-                }
+            if (lists.pathList.length) {
+              pathList = lists.pathList;
             }
-            if (!(combined || pathList || thisPathList)) {
-                throw new Error(`Failed to setup binding for ${sourcePath}, parsing failed`);
+            if (lists.thisPath.length) {
+              thisPathList = lists.thisPath;
             }
-            return {
-                [exports.bindSymbol](name, control, e, creator) {
-                    let bindingSource;
-                    let finalPathList = pathList;
-                    if (combined) {
-                        bindingSource = {
-                            t: creator,
-                            x: control
-                        };
-                        finalPathList = combined;
-                    }
-                    else if (thisPathList) {
-                        finalPathList = thisPathList;
-                        bindingSource = creator;
-                    }
-                    const asyncState = {
-                        token: 0,
-                        cancelToken: undefined
-                    };
-                    control.bind(e, name, finalPathList, false, () => {
-                        var _a;
-                        const app = control.app;
-                        (_a = asyncState.cancelToken) === null || _a === void 0 ? void 0 : _a.cancel();
-                        asyncState.cancelToken = undefined;
-                        asyncState.token = app.setTimeoutAsync(() => __awaiter(this, void 0, void 0, function* () {
-                            var _b, _c;
-                            if ((_b = asyncState.cancelToken) === null || _b === void 0 ? void 0 : _b.cancelled) {
-                                return;
-                            }
-                            asyncState.token = undefined;
-                            (_c = asyncState.cancelToken) === null || _c === void 0 ? void 0 : _c.cancel();
-                            const ct = asyncState.cancelToken = new types_1.CancelToken();
-                            const value = yield sourcePath.call(creator, control, e, ct);
-                            if (!ct.cancelled) {
-                                control.setLocalValue(e, name, value);
-                            }
-                        }), watchDelayInMS, asyncState.token);
-                        return types_1.ignoreValue;
-                    }, bindingSource);
-                    if (typeof defaultValue !== "undefined") {
-                        control.setLocalValue(e, name, defaultValue);
-                    }
-                }
-            };
+          }
+          if (!(combined || pathList || thisPathList)) {
+            throw new Error(`Failed to setup binding for ${sourcePath}, parsing failed`);
+          }
+          return {
+            [bindSymbol](name, control, e, creator) {
+              let bindingSource;
+              let finalPathList = pathList;
+              if (combined) {
+                bindingSource = {
+                  t: creator,
+                  x: control
+                };
+                finalPathList = combined;
+              } else if (thisPathList) {
+                finalPathList = thisPathList;
+                bindingSource = creator;
+              }
+              const asyncState = {
+                token: 0,
+                cancelToken: undefined
+              };
+              control.bind(e, name, finalPathList, false, () => {
+                var _a;
+                const app = control.app;
+                (_a = asyncState.cancelToken) === null || _a === void 0 ? void 0 : _a.cancel();
+                asyncState.cancelToken = undefined;
+                asyncState.token = app.setTimeoutAsync(() => __awaiter(this, void 0, void 0, function* () {
+                  var _b, _c;
+                  if ((_b = asyncState.cancelToken) === null || _b === void 0 ? void 0 : _b.cancelled) {
+                    return;
+                  }
+                  asyncState.token = undefined;
+                  (_c = asyncState.cancelToken) === null || _c === void 0 ? void 0 : _c.cancel();
+                  const ct = asyncState.cancelToken = new CancelToken();
+                  const value = yield sourcePath.call(creator, control, e, ct);
+                  if (!ct.cancelled) {
+                    control.setLocalValue(e, name, value);
+                  }
+                }), watchDelayInMS, asyncState.token);
+                return ignoreValue;
+              }, bindingSource);
+              if (typeof defaultValue !== "undefined") {
+                control.setLocalValue(e, name, defaultValue);
+              }
+            }
+          };
         }
-        /**
-         * Bind the expression one way
-         * @param sourcePath Lambda Expression for binding
-         * @param now Default value to set immediately
-         */
         static oneWay(sourcePath, now) {
-            let pathList;
-            let combined;
-            let thisPathList;
-            if (Array.isArray(sourcePath)) {
-                pathList = sourcePath;
+          let pathList;
+          let combined;
+          let thisPathList;
+          if (Array.isArray(sourcePath)) {
+            pathList = sourcePath;
+          } else {
+            const lists = parsePathLists(sourcePath);
+            if (lists.combined.length) {
+              combined = lists.combined;
             }
-            else {
-                const lists = (0, ExpressionParser_1.parsePathLists)(sourcePath);
-                if (lists.combined.length) {
-                    combined = lists.combined;
-                }
-                if (lists.pathList.length) {
-                    pathList = lists.pathList;
-                }
-                if (lists.thisPath.length) {
-                    thisPathList = lists.thisPath;
-                }
+            if (lists.pathList.length) {
+              pathList = lists.pathList;
             }
-            if (!(combined || pathList || thisPathList)) {
-                throw new Error(`Failed to setup binding for ${sourcePath}, parsing failed`);
+            if (lists.thisPath.length) {
+              thisPathList = lists.thisPath;
             }
-            return {
-                [exports.bindSymbol](name, control, e, creator) {
-                    if (pathList) {
-                        control.bind(e, name, pathList, false, () => {
-                            return sourcePath.call(creator, control, e);
-                        });
-                        if (typeof now !== "undefined") {
-                            control.setLocalValue(e, name, now);
-                        }
-                        return;
-                    }
-                    if (combined) {
-                        const a = {
-                            t: creator,
-                            x: control
-                        };
-                        control.bind(e, name, combined, false, () => {
-                            return sourcePath.call(creator, control, e);
-                        }, a);
-                        if (typeof now !== "undefined") {
-                            control.setLocalValue(e, name, now);
-                        }
-                        return;
-                    }
-                    control.bind(e, name, thisPathList, false, () => {
-                        return sourcePath.call(creator, control, e);
-                    }, creator);
-                    if (typeof now !== "undefined") {
-                        control.setLocalValue(e, name, now);
-                    }
+          }
+          if (!(combined || pathList || thisPathList)) {
+            throw new Error(`Failed to setup binding for ${sourcePath}, parsing failed`);
+          }
+          return {
+            [bindSymbol](name, control, e, creator) {
+              if (pathList) {
+                control.bind(e, name, pathList, false, () => {
+                  return sourcePath.call(creator, control, e);
+                });
+                if (typeof now !== "undefined") {
+                  control.setLocalValue(e, name, now);
+                }
+                return;
+              }
+              if (combined) {
+                const a = {
+                  t: creator,
+                  x: control
+                };
+                control.bind(e, name, combined, false, () => {
+                  return sourcePath.call(creator, control, e);
+                }, a);
+                if (typeof now !== "undefined") {
+                  control.setLocalValue(e, name, now);
                 }
-            };
+                return;
+              }
+              control.bind(e, name, thisPathList, false, () => {
+                return sourcePath.call(creator, control, e);
+              }, creator);
+              if (typeof now !== "undefined") {
+                control.setLocalValue(e, name, now);
+              }
+            }
+          };
         }
-        /**
-         * Setup two way binding with given expression
-         * @param sourcePath Lambda Expression for binding
-         * @param events events on auto refresh
-         * @param converter IValueConverter for value conversion
-         */
         static twoWays(sourcePath, events, converter) {
-            let pathList;
-            // let combined;
-            let thisPathList;
-            if (Array.isArray(sourcePath)) {
-                pathList = sourcePath;
+          let pathList;
+          let thisPathList;
+          if (Array.isArray(sourcePath)) {
+            pathList = sourcePath;
+          } else {
+            const lists = parsePathLists(sourcePath);
+            if (lists.combined.length) {
+              throw new Error("Cannot have combined binding for two ways");
             }
-            else {
-                const lists = (0, ExpressionParser_1.parsePathLists)(sourcePath);
-                if (lists.combined.length) {
-                    // combined = lists.combined;
-                    throw new Error("Cannot have combined binding for two ways");
-                }
-                if (lists.pathList.length) {
-                    pathList = lists.pathList;
-                }
-                if (lists.thisPath.length) {
-                    thisPathList = lists.thisPath;
-                }
+            if (lists.pathList.length) {
+              pathList = lists.pathList;
             }
-            if (!(thisPathList || pathList)) {
-                throw new Error(`Failed to setup twoWay binding on ${sourcePath}`);
+            if (lists.thisPath.length) {
+              thisPathList = lists.thisPath;
             }
-            return {
-                [exports.bindSymbol](name, control, e, creator) {
-                    control.bind(e, name, thisPathList || pathList, events || true, converter, thisPathList ? creator : undefined);
-                }
-            };
+          }
+          if (!(thisPathList || pathList)) {
+            throw new Error(`Failed to setup twoWay binding on ${sourcePath}`);
+          }
+          return {
+            [bindSymbol](name, control, e, creator) {
+              control.bind(e, name, thisPathList || pathList, events || true, converter, thisPathList ? creator : undefined);
+            }
+          };
         }
-        /**
-     * Bind the expression one way with source, you cannot reference
-     * `this` inside this context, it will not watch `this`
-     * @param source source to watch
-     * @param path Lambda Expression for binding
-     * @param now Default value to set immediately
-     */
         static sourceTwoWays(source, path, events = ["input", "cut", "paste", "change"]) {
-            const lists = (0, ExpressionParser_1.parsePath)(path, false).map((x) => ["this", ...x]);
-            return {
-                [exports.bindSymbol](name, control, e, creator) {
-                    const self = { control, source };
-                    control.bind(e, name, lists, events, lists, self);
-                }
-            };
+          const lists = parsePath(path, false).map(x => ["this", ...x]);
+          return {
+            [bindSymbol](name, control, e, creator) {
+              const self = {
+                control,
+                source
+              };
+              control.bind(e, name, lists, events, lists, self);
+            }
+          };
         }
-        // public static twoWaysConvert<T extends IAtomComponent = IAtomComponent>(
-        //     sourcePath: bindingFunction<T>): Bind {
-        //     const b = new Bind(twoWays, sourcePath, null, events);
-        //     if (!(b.thisPathList  || b.pathList)) {
-        //         throw new Error(`Failed to setup twoWay binding on ${sourcePath}`);
-        //     }
-        //     return b;
-        // }
-        /**
-         * Use this for HTML only, this will fire two way binding
-         * as soon as the input/textarea box is updated
-         * @param sourcePath binding lambda expression
-         * @param converter Optional value converter
-         */
         static twoWaysImmediate(sourcePath, converter) {
-            return this.twoWays(sourcePath, ["change", "input", "paste", "cut"], converter);
-            // const b = new Bind(twoWays, sourcePath, null,
-            //     ["change", "input", "paste"]);
-            // if (!(b.thisPathList  || b.pathList)) {
-            //     throw new Error(`Failed to setup twoWay binding on ${sourcePath}`);
-            // }
-            // return b;
+          return this.twoWays(sourcePath, ["change", "input", "paste", "cut"], converter);
         }
         constructor(setupFunction, sourcePath, name, eventList) {
-            this.setupFunction = setupFunction;
-            this.name = name;
-            this.eventList = eventList;
-            this.sourcePath = sourcePath;
-            this[exports.bindSymbol] = true;
-            if (!this.sourcePath) {
-                return;
+          this.setupFunction = setupFunction;
+          this.name = name;
+          this.eventList = eventList;
+          this.sourcePath = sourcePath;
+          this[bindSymbol] = true;
+          if (!this.sourcePath) {
+            return;
+          }
+          if (Array.isArray(this.sourcePath)) {
+            this.pathList = this.sourcePath;
+          } else {
+            const lists = parsePathLists(this.sourcePath);
+            if (lists.combined.length) {
+              this.combined = lists.combined;
             }
-            if (Array.isArray(this.sourcePath)) {
-                this.pathList = this.sourcePath;
-                // this.setupFunction = null;
+            if (lists.pathList.length) {
+              this.pathList = lists.pathList;
             }
-            else {
-                const lists = (0, ExpressionParser_1.parsePathLists)(this.sourcePath);
-                if (lists.combined.length) {
-                    this.combined = lists.combined;
-                }
-                if (lists.pathList.length) {
-                    this.pathList = lists.pathList;
-                }
-                if (lists.thisPath.length) {
-                    this.thisPathList = lists.thisPath;
-                }
-                // if (setupFunction === oneWay) {
-                //     if (!(this.combined || this.pathList || this.thisPathList)) {
-                //         throw new Error(`Failed to setup binding for ${this.sourcePath}, parsing failed`);
-                //     }
-                // }
+            if (lists.thisPath.length) {
+              this.thisPathList = lists.thisPath;
             }
+          }
         }
+      });
     }
-    exports.default = Bind;
-});
-//# sourceMappingURL=Bind.js.map
+  };
+});
+//# sourceMappingURL=/home/runner/work/core/core/dist/core/Bind.js.map