@web-atoms/core 2.6.24 → 2.6.25

package/dist-esm/core/SingleInvoker.js

@@ -2,42 +2,39 @@ import { __decorate } from "tslib";
 import DITransient from "../di/DITransient.js";
 import TransientDisposable from "./TransientDisposable.js";
 let SingleInvoker = class SingleInvoker extends TransientDisposable {
-    constructor() {
-        super(...arguments);
-        this.keys = new Map();
+  constructor() {
+    super(...arguments);
+    this.keys = new Map();
+  }
+  dispose() {
+    for (const [key, index] of this.keys.entries()) {
+      clearTimeout(index);
     }
-    dispose() {
-        for (const [key, index] of this.keys.entries()) {
-            clearTimeout(index);
-        }
-        this.keys.clear();
+    this.keys.clear();
+  }
+  invoke(key, fx, delay = 100) {
+    const keys = this.keys;
+    const e = keys.get(key);
+    if (e) {
+      clearTimeout(e);
     }
-    invoke(key, fx, delay = 100) {
-        const keys = this.keys;
-        const e = keys.get(key);
-        if (e) {
-            clearTimeout(e);
-        }
-        keys.set(key, setTimeout(() => {
-            keys.delete(key);
-            fx();
-        }, delay));
-    }
-    queue(fx, delay = 1, key) {
-        key ??= fx.toString();
-        const keys = this.keys;
-        const e = keys.get(key);
-        if (e) {
-            clearTimeout(e);
-        }
-        keys.set(key, setTimeout(() => {
-            keys.delete(key);
-            fx();
-        }, delay));
+    keys.set(key, setTimeout(() => {
+      keys.delete(key);
+      fx();
+    }, delay));
+  }
+  queue(fx, delay = 1, key) {
+    key ??= fx.toString();
+    const keys = this.keys;
+    const e = keys.get(key);
+    if (e) {
+      clearTimeout(e);
     }
+    keys.set(key, setTimeout(() => {
+      keys.delete(key);
+      fx();
+    }, delay));
+  }
 };
-SingleInvoker = __decorate([
-    DITransient()
-], SingleInvoker);
-export default SingleInvoker;
-//# sourceMappingURL=SingleInvoker.js.map
+SingleInvoker = __decorate([DITransient()], SingleInvoker);
+export default SingleInvoker;

package/dist-esm/core/StringHelper.js

@@ -1,52 +1,50 @@
 export class StringHelper {
-    static escapeRegExp(text) {
-        return text.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-    }
-    static createContainsRegExp(text) {
-        return new RegExp(this.escapeRegExp(text), "i");
-    }
-    static createContainsAnyWordRegExp(text) {
-        return new RegExp(text.split(/\s+/g).map((x) => `(${this.escapeRegExp(x)})`).join("|"), "i");
-    }
-    static containsIgnoreCase(source, test) {
-        if (!source) {
-            return false;
-        }
-        if (!test) {
-            return true;
-        }
-        return this.createContainsRegExp(test).test(source);
-    }
-    static containsAnyWordIgnoreCase(source, test) {
-        if (!source) {
-            return false;
-        }
-        if (!test) {
-            return true;
-        }
-        return this.createContainsAnyWordRegExp(test).test(source);
-    }
-    static fromCamelToHyphen(input) {
-        return input.replace(/([a-z])([A-Z])/g, "$1-$2").toLowerCase();
-    }
-    static fromCamelToUnderscore(input) {
-        return input.replace(/([a-z])([A-Z])/g, "$1_$2").toLowerCase();
-    }
-    static fromCamelToPascal(input) {
-        return input[0].toUpperCase() + input.substr(1);
-    }
-    static fromHyphenToCamel(input) {
-        return input.replace(/-([a-z])/g, (g) => g[1].toUpperCase());
-    }
-    static fromUnderscoreToCamel(input) {
-        return input.replace(/\_([a-z])/g, (g) => g[1].toUpperCase());
-    }
-    static fromPascalToCamel(input) {
-        return input[0].toLowerCase() + input.substr(1);
-    }
-    static fromPascalToTitleCase(s) {
-        return s.replace(/([A-Z])/gm, (x, g, i) => i ? " " + x : x);
-    }
-    ;
-}
-//# sourceMappingURL=StringHelper.js.map
+  static escapeRegExp(text) {
+    return text.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  }
+  static createContainsRegExp(text) {
+    return new RegExp(this.escapeRegExp(text), "i");
+  }
+  static createContainsAnyWordRegExp(text) {
+    return new RegExp(text.split(/\s+/g).map(x => `(${this.escapeRegExp(x)})`).join("|"), "i");
+  }
+  static containsIgnoreCase(source, test) {
+    if (!source) {
+      return false;
+    }
+    if (!test) {
+      return true;
+    }
+    return this.createContainsRegExp(test).test(source);
+  }
+  static containsAnyWordIgnoreCase(source, test) {
+    if (!source) {
+      return false;
+    }
+    if (!test) {
+      return true;
+    }
+    return this.createContainsAnyWordRegExp(test).test(source);
+  }
+  static fromCamelToHyphen(input) {
+    return input.replace(/([a-z])([A-Z])/g, "$1-$2").toLowerCase();
+  }
+  static fromCamelToUnderscore(input) {
+    return input.replace(/([a-z])([A-Z])/g, "$1_$2").toLowerCase();
+  }
+  static fromCamelToPascal(input) {
+    return input[0].toUpperCase() + input.substr(1);
+  }
+  static fromHyphenToCamel(input) {
+    return input.replace(/-([a-z])/g, g => g[1].toUpperCase());
+  }
+  static fromUnderscoreToCamel(input) {
+    return input.replace(/\_([a-z])/g, g => g[1].toUpperCase());
+  }
+  static fromPascalToCamel(input) {
+    return input[0].toLowerCase() + input.substr(1);
+  }
+  static fromPascalToTitleCase(s) {
+    return s.replace(/([A-Z])/gm, (x, g, i) => i ? " " + x : x);
+  }
+}

package/dist-esm/core/TransientDisposable.js

@@ -1,19 +1,17 @@
 export default class TransientDisposable {
-    constructor(owner) {
-        if (owner) {
-            this.registerIn(owner);
-        }
+  constructor(owner) {
+    if (owner) {
+      this.registerIn(owner);
     }
-    registerIn(value) {
-        const v = value.disposables;
-        if (v) {
-            v.push(this);
-        }
-        else {
-            if (value.registerDisposable) {
-                value.registerDisposable(this);
-            }
-        }
+  }
+  registerIn(value) {
+    const v = value.disposables;
+    if (v) {
+      v.push(this);
+    } else {
+      if (value.registerDisposable) {
+        value.registerDisposable(this);
+      }
     }
-}
-//# sourceMappingURL=TransientDisposable.js.map
+  }
+}

package/dist-esm/core/WatchProperty.js

@@ -1,20 +1,21 @@
 import { AtomBinder } from "./AtomBinder.js";
 import { AtomWatcher } from "./AtomWatcher.js";
 export default function WatchProperty(target, key, descriptor) {
-    const { get } = descriptor;
-    const isSetup = Symbol.for(`isSetup${key}`);
-    return {
-        get: function () {
-            const watcher = new AtomWatcher(this, get, () => {
-                AtomBinder.refreshValue(this, key);
-            }, this);
-            watcher.init(false);
-            this.registerDisposable(watcher);
-            this[isSetup] = watcher;
-            Object.defineProperty(this, key, descriptor);
-            return get.apply(this);
-        },
-        configurable: true
-    };
-}
-//# sourceMappingURL=WatchProperty.js.map
+  const {
+    get
+  } = descriptor;
+  const isSetup = Symbol.for(`isSetup${key}`);
+  return {
+    get: function () {
+      const watcher = new AtomWatcher(this, get, () => {
+        AtomBinder.refreshValue(this, key);
+      }, this);
+      watcher.init(false);
+      this.registerDisposable(watcher);
+      this[isSetup] = watcher;
+      Object.defineProperty(this, key, descriptor);
+      return get.apply(this);
+    },
+    configurable: true
+  };
+}

package/dist-esm/core/WebImage.js

@@ -1,9 +1,8 @@
 export default class WebImage {
-    constructor(url) {
-        this.url = url;
-    }
-    toString() {
-        return this.url;
-    }
-}
-//# sourceMappingURL=WebImage.js.map
+  constructor(url) {
+    this.url = url;
+  }
+  toString() {
+    return this.url;
+  }
+}

package/dist-esm/core/XNode.js

@@ -1,17 +1,17 @@
 import { bindSymbol } from "./Bind.js";
 export class RootObject {
-    get vsProps() {
-        return undefined;
-    }
-    addEventListener(name, handler) {
-        return bridge.addEventHandler(this, name, handler);
-    }
-    appendChild(e) {
-        bridge.appendChild(this, e);
-    }
-    dispatchEvent(evt) {
-        bridge.dispatchEvent(evt);
-    }
+  get vsProps() {
+    return undefined;
+  }
+  addEventListener(name, handler) {
+    return bridge.addEventHandler(this, name, handler);
+  }
+  appendChild(e) {
+    bridge.appendChild(this, e);
+  }
+  dispatchEvent(evt) {
+    bridge.dispatchEvent(evt);
+  }
 }
 export const xnodeSymbol = Symbol("XNode");
 export const isControl = Symbol.for("isControl");
@@ -23,121 +23,138 @@ export const constructorNeedsArgumentsSymbol = Symbol("constructorNeedsArguments
 export const attachedProperties = {};
 let attachedId = 1;
 const attach = (name, attacher) => {
-    const key = `:${attachedId++}`;
-    const fx = (v) => {
-        return {
-            [key]: v
-        };
+  const key = `:${attachedId++}`;
+  const fx = v => {
+    return {
+      [key]: v
     };
-    attachedProperties[key] = attacher;
-    fx[attachedSymbol] = attacher;
-    fx[isFactorySymbol] = key;
-    return fx;
+  };
+  attachedProperties[key] = attacher;
+  fx[attachedSymbol] = attacher;
+  fx[isFactorySymbol] = key;
+  return fx;
 };
 export default class XNode {
-    static { this.isFactory = isFactorySymbol; }
-    static { this.elementFactory = elementFactorySymbol; }
-    static { this.bindSymbol = bindSymbol; }
-    static { this.isTemplate = isTemplateSymbol; }
-    static { this.prepareAttached = attach; }
-    static { this.constructorNeedsArguments = constructorNeedsArgumentsSymbol; }
-    static { this.classes = {}; }
-    static attach(n, tag) {
-        return {
-            factory: (attributes, ...nodes) => new XNode(n, attributes
-                ? { ...attributes, for: tag }
-                : { for: tag }, nodes)
-        };
+  static {
+    this.isFactory = isFactorySymbol;
+  }
+  static {
+    this.elementFactory = elementFactorySymbol;
+  }
+  static {
+    this.bindSymbol = bindSymbol;
+  }
+  static {
+    this.isTemplate = isTemplateSymbol;
+  }
+  static {
+    this.prepareAttached = attach;
+  }
+  static {
+    this.constructorNeedsArguments = constructorNeedsArgumentsSymbol;
+  }
+  static {
+    this.classes = {};
+  }
+  static attach(n, tag) {
+    return {
+      factory: (attributes, ...nodes) => new XNode(n, attributes ? {
+        ...attributes,
+        for: tag
+      } : {
+        for: tag
+      }, nodes)
+    };
+  }
+  static prepare(n, isProperty, isTemplate) {
+    function px(v) {
+      return {
+        [n]: v
+      };
     }
-    static prepare(n, isProperty, isTemplate) {
-        function px(v) {
-            return ({
-                [n]: v
-            });
+    px.factory = (a, ...nodes) => {
+      return new XNode(n, a, nodes, isProperty, isTemplate);
+    };
+    px.toString = () => n;
+    return px;
+  }
+  static getClass(fullTypeName, assemblyName) {
+    const n = fullTypeName + ";" + assemblyName;
+    const cx = XNode.classes[n] || (XNode.classes[n] = bridge.getClass(fullTypeName, assemblyName, RootObject, (name, isProperty, isTemplate) => (a, ...nodes) => new XNode(name, a, nodes, isProperty, isTemplate)));
+    return cx;
+  }
+  static {
+    this.factory = (name, isProperty, isTemplate) => (a, ...nodes) => {
+      return new XNode(name, a, nodes, isProperty, isTemplate);
+    };
+  }
+  static namespace(ns, assemblyName) {
+    return (type, isTemplate) => {
+      return c => {
+        for (const key in c) {
+          if (c.hasOwnProperty(key)) {
+            const element = c[key];
+            if (element) {
+              const n = ns + "." + type + ":" + key + ";" + assemblyName;
+              const af = a => {
+                const r = {
+                  [n]: a
+                };
+                Object.defineProperty(r, "toString", {
+                  value: () => n,
+                  enumerable: false,
+                  configurable: false
+                });
+                return r;
+              };
+              af.factory = (a, ...nodes) => new XNode(n, a, nodes, true, element.isTemplate);
+              af.toString = () => n;
+              c[key] = af;
+            }
+          }
         }
-        px.factory = (a, ...nodes) => {
-            return new XNode(n, a, nodes, isProperty, isTemplate);
+        const tn = ns + "." + type + ";" + assemblyName;
+        c.factory = (a, ...nodes) => {
+          return new XNode(tn, a, nodes, false, isTemplate);
         };
-        px.toString = () => n;
-        return px;
+        c.toString = () => tn;
+      };
+    };
+  }
+  static create(name, attributes, ...children) {
+    if (typeof name === "string") {
+      return new XNode(name, attributes, children);
     }
-    static getClass(fullTypeName, assemblyName) {
-        const n = fullTypeName + ";" + assemblyName;
-        const cx = XNode.classes[n] || (XNode.classes[n] =
-            bridge.getClass(fullTypeName, assemblyName, RootObject, (name, isProperty, isTemplate) => (a, ...nodes) => new XNode(name, a, nodes, isProperty, isTemplate)));
-        return cx;
+    if (name[isFactorySymbol]) {
+      return new XNode(name, attributes, children);
     }
-    static { this.factory = (name, isProperty, isTemplate) => (a, ...nodes) => {
-        return new XNode(name, a, nodes, isProperty, isTemplate);
-    }; }
-    static namespace(ns, assemblyName) {
-        return (type, isTemplate) => {
-            return (c) => {
-                for (const key in c) {
-                    if (c.hasOwnProperty(key)) {
-                        const element = c[key];
-                        if (element) {
-                            const n = ns + "." + type + ":" + key + ";" + assemblyName;
-                            const af = (a) => {
-                                const r = {
-                                    [n]: a
-                                };
-                                Object.defineProperty(r, "toString", {
-                                    value: () => n,
-                                    enumerable: false,
-                                    configurable: false
-                                });
-                                return r;
-                            };
-                            af.factory = (a, ...nodes) => new XNode(n, a, nodes, true, element.isTemplate);
-                            af.toString = () => n;
-                            c[key] = af;
-                        }
-                    }
-                }
-                const tn = ns + "." + type + ";" + assemblyName;
-                c.factory = (a, ...nodes) => {
-                    return new XNode(tn, a, nodes, false, isTemplate);
-                };
-                c.toString = () => tn;
-            };
-        };
-    }
-    static create(name, attributes, ...children) {
-        if (typeof name === "string") {
-            return new XNode(name, attributes, children);
-        }
-        if (name[isFactorySymbol]) {
-            return new XNode(name, attributes, children);
-        }
-        if (name.factory) {
-            return (name.factory)(attributes, ...children);
-        }
-        switch (typeof name) {
-            case "object":
-                name = name.toString();
-                break;
-            case "function":
-                return name(attributes || {}, ...children);
-        }
-        return new XNode(name, attributes, children);
+    if (name.factory) {
+      return name.factory(attributes, ...children);
     }
-    constructor(name, attributes, children, isProperty, isTemplate) {
-        this.name = name;
-        this.attributes = attributes;
-        this.children = children;
-        this.isProperty = isProperty;
-        this.isTemplate = isTemplate;
-        this[xnodeSymbol] = true;
+    switch (typeof name) {
+      case "object":
+        name = name.toString();
+        break;
+      case "function":
+        return name(attributes || {}, ...children);
     }
-    toString() {
-        if (typeof this.name === "string") {
-            return `name is of type string and value is ${this.name}`;
-        }
-        return `name is of type ${typeof this.name}`;
+    return new XNode(name, attributes, children);
+  }
+  constructor(name, attributes, children, isProperty, isTemplate) {
+    this.name = name;
+    this.attributes = attributes;
+    this.children = children;
+    this.isProperty = isProperty;
+    this.isTemplate = isTemplate;
+    this[xnodeSymbol] = true;
+  }
+  toString() {
+    if (typeof this.name === "string") {
+      return `name is of type string and value is ${this.name}`;
     }
+    return `name is of type ${typeof this.name}`;
+  }
 }
 if (typeof bridge !== "undefined") {
-    bridge.XNode = XNode;
-}
-//# sourceMappingURL=XNode.js.map
+  bridge.XNode = XNode;
+}

package/dist-esm/core/sleep.js

@@ -1,27 +1,24 @@
 export default function sleep(timeInMS, ct, throwOnCancel = true) {
-    let token = 0;
-    return new Promise((resolve, reject) => {
-        ct?.registerForCancel((reason) => {
-            if (token) {
-                clearTimeout(token);
-                if (throwOnCancel) {
-                    reject(reason);
-                }
-                else {
-                    resolve();
-                }
-            }
-        });
-        if (ct?.cancelled) {
-            if (throwOnCancel) {
-                reject("cancelled");
-            }
-            else {
-                resolve();
-            }
-            return;
+  let token = 0;
+  return new Promise((resolve, reject) => {
+    ct?.registerForCancel(reason => {
+      if (token) {
+        clearTimeout(token);
+        if (throwOnCancel) {
+          reject(reason);
+        } else {
+          resolve();
         }
-        token = setTimeout(resolve, timeInMS);
+      }
     });
-}
-//# sourceMappingURL=sleep.js.map
+    if (ct?.cancelled) {
+      if (throwOnCancel) {
+        reject("cancelled");
+      } else {
+        resolve();
+      }
+      return;
+    }
+    token = setTimeout(resolve, timeInMS);
+  });
+}