@web-atoms/core 2.6.21 → 2.6.25

package/dist-esm/core/Bind.js

@@ -2,293 +2,295 @@ import { parsePath, parsePathLists } from "./ExpressionParser.js";
 import { CancelToken, ignoreValue } from "./types.js";
 const isEvent = /^event/i;
 function twoWaysConvert(name, b, control, e, creator) {
-    control.bind(e, name, b.thisPathList || b.pathList, b.eventList || true, null, b.thisPathList ? creator : undefined);
+  control.bind(e, name, b.thisPathList || b.pathList, b.eventList || true, null, b.thisPathList ? creator : undefined);
 }
 export const bindSymbol = Symbol("Bind");
 export default class Bind {
-    static forControl() {
-        return Bind;
-    }
-    static forData() {
-        return Bind;
-    }
-    static forViewModel() {
-        return Bind;
-    }
-    static forLocalViewModel() {
-        return Bind;
-    }
-    static onCreate(fx) {
-        return {
-            [bindSymbol](cn, control, e, creator) {
-                fx(control, e, creator);
-                return;
-            }
-        };
-    }
-    static presenter(name) {
-        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;
-            }
-        };
-    }
-    static event(sourcePath) {
-        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);
-                    });
-                });
-            }
-        };
-    }
-    static oneTime(sourcePath, now) {
-        return {
-            [bindSymbol](name, control, e) {
-                control.runAfterInit(() => {
-                    control.setLocalValue(e, name, sourcePath(control, e));
-                });
-                if (typeof now !== "undefined") {
-                    control.setLocalValue(e, name, now);
-                }
-            }
-        };
-    }
-    static oneTimeAsync(sourcePath, now) {
-        return {
-            [bindSymbol](name, control, e) {
-                control.runAfterInit(() => {
-                    control.app.runAsync(async () => {
-                        const value = await sourcePath(control, e, new CancelToken());
-                        control.setLocalValue(e, name, value);
-                    });
-                });
-                if (typeof now !== "undefined") {
-                    control.setLocalValue(e, name, now);
-                }
-            }
-        };
-    }
-    static source(source, path, 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 forControl() {
+    return Bind;
+  }
+  static forData() {
+    return Bind;
+  }
+  static forViewModel() {
+    return Bind;
+  }
+  static forLocalViewModel() {
+    return Bind;
+  }
+  static onCreate(fx) {
+    return {
+      [bindSymbol](cn, control, e, creator) {
+        fx(control, e, creator);
+        return;
+      }
+    };
+  }
+  static presenter(name) {
+    return {
+      [bindSymbol](cn, control, e, creator) {
+        if (typeof name === "function") {
+          name(control);
+          return;
         }
-        else {
-            const lists = parsePathLists(sourcePath);
-            if (lists.combined.length) {
-                combined = lists.combined;
-            }
-            if (lists.pathList.length) {
-                pathList = lists.pathList;
-            }
-            if (lists.thisPath.length) {
-                thisPathList = lists.thisPath;
+        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;
+      }
+    };
+  }
+  static event(sourcePath) {
+    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);
+          });
+        });
+      }
+    };
+  }
+  static oneTime(sourcePath, now) {
+    return {
+      [bindSymbol](name, control, e) {
+        control.runAfterInit(() => {
+          control.setLocalValue(e, name, sourcePath(control, e));
+        });
+        if (typeof now !== "undefined") {
+          control.setLocalValue(e, name, now);
         }
-        if (!(combined || pathList || thisPathList)) {
-            throw new Error(`Failed to setup binding for ${sourcePath}, parsing failed`);
+      }
+    };
+  }
+  static oneTimeAsync(sourcePath, now) {
+    return {
+      [bindSymbol](name, control, e) {
+        control.runAfterInit(() => {
+          control.app.runAsync(async () => {
+            const value = await sourcePath(control, e, new CancelToken());
+            control.setLocalValue(e, name, value);
+          });
+        });
+        if (typeof now !== "undefined") {
+          control.setLocalValue(e, name, now);
         }
-        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, () => {
-                    const app = control.app;
-                    asyncState.cancelToken?.cancel();
-                    asyncState.cancelToken = undefined;
-                    asyncState.token = app.setTimeoutAsync(async () => {
-                        if (asyncState.cancelToken?.cancelled) {
-                            return;
-                        }
-                        asyncState.token = undefined;
-                        asyncState.cancelToken?.cancel();
-                        const ct = asyncState.cancelToken = new CancelToken();
-                        const value = await 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);
-                }
-            }
+      }
+    };
+  }
+  static source(source, path, 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;
+    } else {
+      const lists = parsePathLists(sourcePath);
+      if (lists.combined.length) {
+        combined = lists.combined;
+      }
+      if (lists.pathList.length) {
+        pathList = lists.pathList;
+      }
+      if (lists.thisPath.length) {
+        thisPathList = lists.thisPath;
+      }
+    }
+    if (!(combined || pathList || thisPathList)) {
+      throw new Error(`Failed to setup binding for ${sourcePath}, parsing failed`);
     }
-    static oneWay(sourcePath, now) {
-        let pathList;
-        let combined;
-        let thisPathList;
-        if (Array.isArray(sourcePath)) {
-            pathList = sourcePath;
+    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;
         }
-        else {
-            const lists = parsePathLists(sourcePath);
-            if (lists.combined.length) {
-                combined = lists.combined;
-            }
-            if (lists.pathList.length) {
-                pathList = lists.pathList;
+        const asyncState = {
+          token: 0,
+          cancelToken: undefined
+        };
+        control.bind(e, name, finalPathList, false, () => {
+          const app = control.app;
+          asyncState.cancelToken?.cancel();
+          asyncState.cancelToken = undefined;
+          asyncState.token = app.setTimeoutAsync(async () => {
+            if (asyncState.cancelToken?.cancelled) {
+              return;
             }
-            if (lists.thisPath.length) {
-                thisPathList = lists.thisPath;
+            asyncState.token = undefined;
+            asyncState.cancelToken?.cancel();
+            const ct = asyncState.cancelToken = new CancelToken();
+            const value = await 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);
         }
-        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);
-                }
-            }
-        };
+      }
+    };
+  }
+  static oneWay(sourcePath, now) {
+    let pathList;
+    let combined;
+    let thisPathList;
+    if (Array.isArray(sourcePath)) {
+      pathList = sourcePath;
+    } else {
+      const lists = parsePathLists(sourcePath);
+      if (lists.combined.length) {
+        combined = lists.combined;
+      }
+      if (lists.pathList.length) {
+        pathList = lists.pathList;
+      }
+      if (lists.thisPath.length) {
+        thisPathList = lists.thisPath;
+      }
+    }
+    if (!(combined || pathList || thisPathList)) {
+      throw new Error(`Failed to setup binding for ${sourcePath}, parsing failed`);
     }
-    static twoWays(sourcePath, events, converter) {
-        let pathList;
-        let thisPathList;
-        if (Array.isArray(sourcePath)) {
-            pathList = sourcePath;
+    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;
         }
-        else {
-            const lists = parsePathLists(sourcePath);
-            if (lists.combined.length) {
-                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 (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;
         }
-        if (!(thisPathList || pathList)) {
-            throw new Error(`Failed to setup twoWay binding on ${sourcePath}`);
+        control.bind(e, name, thisPathList, false, () => {
+          return sourcePath.call(creator, control, e);
+        }, creator);
+        if (typeof now !== "undefined") {
+          control.setLocalValue(e, name, now);
         }
-        return {
-            [bindSymbol](name, control, e, creator) {
-                control.bind(e, name, thisPathList || pathList, events || true, converter, thisPathList ? creator : undefined);
-            }
-        };
+      }
+    };
+  }
+  static twoWays(sourcePath, events, converter) {
+    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");
+      }
+      if (lists.pathList.length) {
+        pathList = lists.pathList;
+      }
+      if (lists.thisPath.length) {
+        thisPathList = lists.thisPath;
+      }
     }
-    static sourceTwoWays(source, path, events = ["input", "cut", "paste", "change"]) {
-        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);
-            }
-        };
+    if (!(thisPathList || pathList)) {
+      throw new Error(`Failed to setup twoWay binding on ${sourcePath}`);
     }
-    static twoWaysImmediate(sourcePath, converter) {
-        return this.twoWays(sourcePath, ["change", "input", "paste", "cut"], converter);
+    return {
+      [bindSymbol](name, control, e, creator) {
+        control.bind(e, name, thisPathList || pathList, events || true, converter, thisPathList ? creator : undefined);
+      }
+    };
+  }
+  static sourceTwoWays(source, path, events = ["input", "cut", "paste", "change"]) {
+    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);
+      }
+    };
+  }
+  static twoWaysImmediate(sourcePath, converter) {
+    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[bindSymbol] = true;
+    if (!this.sourcePath) {
+      return;
     }
-    constructor(setupFunction, sourcePath, name, eventList) {
-        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 (lists.pathList.length) {
-                this.pathList = lists.pathList;
-            }
-            if (lists.thisPath.length) {
-                this.thisPathList = lists.thisPath;
-            }
-        }
+    if (Array.isArray(this.sourcePath)) {
+      this.pathList = this.sourcePath;
+    } else {
+      const lists = 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;
+      }
     }
-}
-//# sourceMappingURL=Bind.js.map
+  }
+}

package/dist-esm/core/BindableProperty.js

@@ -1,30 +1,29 @@
 import { AtomBinder } from "./AtomBinder.js";
 export function BindableProperty(target, key) {
-    const iVal = target[key];
-    const keyName = "_" + key;
-    target[keyName] = iVal;
-    const getter = function () {
-        return this[keyName];
-    };
-    const setter = function (newVal) {
-        const oldValue = this[keyName];
-        if (oldValue === undefined ? oldValue === newVal : oldValue == newVal) {
-            return;
-        }
-        const ce = this;
-        if (ce.onPropertyChanging) {
-            ce.onPropertyChanging(key, oldValue, newVal);
-        }
-        this[keyName] = newVal;
-        AtomBinder.refreshValue(this, key);
-    };
-    if (delete target[key]) {
-        Object.defineProperty(target, key, {
-            get: getter,
-            set: setter,
-            enumerable: true,
-            configurable: true
-        });
+  const iVal = target[key];
+  const keyName = "_" + key;
+  target[keyName] = iVal;
+  const getter = function () {
+    return this[keyName];
+  };
+  const setter = function (newVal) {
+    const oldValue = this[keyName];
+    if (oldValue === undefined ? oldValue === newVal : oldValue == newVal) {
+      return;
     }
-}
-//# sourceMappingURL=BindableProperty.js.map
+    const ce = this;
+    if (ce.onPropertyChanging) {
+      ce.onPropertyChanging(key, oldValue, newVal);
+    }
+    this[keyName] = newVal;
+    AtomBinder.refreshValue(this, key);
+  };
+  if (delete target[key]) {
+    Object.defineProperty(target, key, {
+      get: getter,
+      set: setter,
+      enumerable: true,
+      configurable: true
+    });
+  }
+}

package/dist-esm/core/CancelTokenFactory.js

@@ -3,30 +3,27 @@ import DITransient from "../di/DITransient.js";
 import TransientDisposable from "./TransientDisposable.js";
 import { CancelToken } from "./types.js";
 let CancelTokenFactory = class CancelTokenFactory extends TransientDisposable {
-    constructor() {
-        super(...arguments);
-        this.mToken = {};
+  constructor() {
+    super(...arguments);
+    this.mToken = {};
+  }
+  newToken(key, timeout = -1) {
+    key = key || "__old";
+    const old = this.mToken[key];
+    if (old) {
+      old.cancel();
     }
-    newToken(key, timeout = -1) {
-        key = key || "__old";
-        const old = this.mToken[key];
-        if (old) {
-            old.cancel();
-        }
-        const n = this.mToken[key] = new CancelToken(timeout);
-        return n;
-    }
-    dispose() {
-        for (const key in this.mToken) {
-            if (this.mToken.hasOwnProperty(key)) {
-                const element = this.mToken[key];
-                element.dispose();
-            }
-        }
+    const n = this.mToken[key] = new CancelToken(timeout);
+    return n;
+  }
+  dispose() {
+    for (const key in this.mToken) {
+      if (this.mToken.hasOwnProperty(key)) {
+        const element = this.mToken[key];
+        element.dispose();
+      }
     }
+  }
 };
-CancelTokenFactory = __decorate([
-    DITransient()
-], CancelTokenFactory);
-export default CancelTokenFactory;
-//# sourceMappingURL=CancelTokenFactory.js.map
+CancelTokenFactory = __decorate([DITransient()], CancelTokenFactory);
+export default CancelTokenFactory;

package/dist-esm/core/Color.js

@@ -1,2 +1 @@
-export {};
-//# sourceMappingURL=Color.js.map
+export {};