@web-atoms/core 2.6.24 → 2.6.25

package/dist-esm/core/InheritedProperty.js

@@ -1,75 +1,73 @@
 import { AtomBinder } from "./AtomBinder.js";
 const cache = {};
 function getSymbolKey(name) {
-    return cache[name] ??= Symbol(name);
+  return cache[name] ??= Symbol(name);
 }
 function refreshInherited(ac, key, storageKey) {
-    const e = ac.element;
-    if (!e) {
-        return;
-    }
-    AtomBinder.refreshValue(ac, key);
-    let start = e.firstElementChild;
-    if (!start) {
-        return;
-    }
-    const stack = [start];
-    while (stack.length) {
-        start = stack.pop();
-        while (start) {
-            let firstChild = start.firstElementChild;
-            const childControl = start.atomControl;
-            if (childControl) {
-                if (childControl[storageKey] === undefined) {
-                    AtomBinder.refreshValue(childControl, key);
-                }
-                else {
-                    firstChild = void 0;
-                }
-            }
-            if (firstChild) {
-                stack.push(firstChild);
-            }
-            start = start.nextElementSibling;
+  const e = ac.element;
+  if (!e) {
+    return;
+  }
+  AtomBinder.refreshValue(ac, key);
+  let start = e.firstElementChild;
+  if (!start) {
+    return;
+  }
+  const stack = [start];
+  while (stack.length) {
+    start = stack.pop();
+    while (start) {
+      let firstChild = start.firstElementChild;
+      const childControl = start.atomControl;
+      if (childControl) {
+        if (childControl[storageKey] === undefined) {
+          AtomBinder.refreshValue(childControl, key);
+        } else {
+          firstChild = void 0;
         }
+      }
+      if (firstChild) {
+        stack.push(firstChild);
+      }
+      start = start.nextElementSibling;
     }
+  }
 }
 export function getOwnInheritedProperty(target, key) {
-    return target[getSymbolKey(key)];
+  return target[getSymbolKey(key)];
 }
 export function InheritedProperty(target, key) {
-    const iVal = target[key];
-    const keyName = getSymbolKey(key);
-    target[keyName] = iVal;
-    const getter = function () {
-        let start = this;
-        do {
-            const p = start[keyName];
-            if (typeof p !== "undefined") {
-                return p;
-            }
-            if (!start.element) {
-                break;
-            }
-            start = start.parent;
-        } while (start);
-        return undefined;
-    };
-    const setter = function (newVal) {
-        const oldValue = this[keyName];
-        if (oldValue && oldValue.dispose) {
-            oldValue.dispose();
-        }
-        this[keyName] = newVal;
-        refreshInherited(this, key, keyName);
-    };
-    if (delete target[key]) {
-        Object.defineProperty(target, key, {
-            get: getter,
-            set: setter,
-            enumerable: true,
-            configurable: true
-        });
+  const iVal = target[key];
+  const keyName = getSymbolKey(key);
+  target[keyName] = iVal;
+  const getter = function () {
+    let start = this;
+    do {
+      const p = start[keyName];
+      if (typeof p !== "undefined") {
+        return p;
+      }
+      if (!start.element) {
+        break;
+      }
+      start = start.parent;
+    } while (start);
+    return undefined;
+  };
+  const setter = function (newVal) {
+    const oldValue = this[keyName];
+    if (oldValue && oldValue.dispose) {
+      oldValue.dispose();
     }
-}
-//# sourceMappingURL=InheritedProperty.js.map
+    this[keyName] = newVal;
+    refreshInherited(this, key, keyName);
+  };
+  if (delete target[key]) {
+    Object.defineProperty(target, key, {
+      get: getter,
+      set: setter,
+      enumerable: true,
+      configurable: true
+    });
+  }
+}

package/dist-esm/core/InjectProperty.js

@@ -1,14 +1,13 @@
 export default function InjectProperty(target, key) {
-    Object.defineProperty(target, key, {
-        get: function () {
-            const plist = Reflect.getMetadata("design:type", target, key);
-            const result = this.app.resolve(plist);
-            Object.defineProperty(this, key, {
-                get: () => result
-            });
-            return result;
-        },
-        configurable: true
-    });
-}
-//# sourceMappingURL=InjectProperty.js.map
+  Object.defineProperty(target, key, {
+    get: function () {
+      const plist = Reflect.getMetadata("design:type", target, key);
+      const result = this.app.resolve(plist);
+      Object.defineProperty(this, key, {
+        get: () => result
+      });
+      return result;
+    },
+    configurable: true
+  });
+}

package/dist-esm/core/KeyValuePairs.js

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

package/dist-esm/core/Markdown.js

@@ -1,20 +1,17 @@
 import MarkdownService from "../web/services/MarkdownService.js";
 import FormattedString from "./FormattedString.js";
 export default class Markdown extends FormattedString {
-    static from(text) {
-        return new Markdown(text);
-    }
-    applyTo(app, element) {
-        element.innerHTML = this.toHtmlString(app);
-    }
-    toString() {
-        return this.text;
-    }
-    toHtmlString(app) {
-        const ms = app
-            ? app.resolve(MarkdownService)
-            : MarkdownService.instance;
-        return ms.toHtml(this.text);
-    }
-}
-//# sourceMappingURL=Markdown.js.map
+  static from(text) {
+    return new Markdown(text);
+  }
+  applyTo(app, element) {
+    element.innerHTML = this.toHtmlString(app);
+  }
+  toString() {
+    return this.text;
+  }
+  toHtmlString(app) {
+    const ms = app ? app.resolve(MarkdownService) : MarkdownService.instance;
+    return ms.toHtml(this.text);
+  }
+}

package/dist-esm/core/MarkdownError.js

@@ -1,10 +1,9 @@
 import FormattedError from "./FormattedError.js";
 import Markdown from "./Markdown.js";
 export default class MarkdownError extends FormattedError {
-    constructor(text) {
-        const a = super(Markdown.from(text));
-        a.__proto__ = MarkdownError.prototype;
-        return a;
-    }
-}
-//# sourceMappingURL=MarkdownError.js.map
+  constructor(text) {
+    const a = super(Markdown.from(text));
+    a.__proto__ = MarkdownError.prototype;
+    return a;
+  }
+}

package/dist-esm/core/PropertyBinding.js

@@ -1,2 +1 @@
-export { PropertyBinding } from "./AtomComponent.js";
-//# sourceMappingURL=PropertyBinding.js.map
+export { PropertyBinding } from "./AtomComponent.js";

package/dist-esm/core/PropertyMap.js

@@ -1,31 +1,32 @@
 import { TypeKey } from "../di/TypeKey.js";
 export class PropertyMap {
-    static from(o) {
-        const c = Object.getPrototypeOf(o);
-        const key = TypeKey.get(c);
-        const map = PropertyMap.map;
-        const m = map[key] || (map[key] = PropertyMap.createMap(o));
-        return m;
-    }
-    static { this.map = {}; }
-    static createMap(c) {
-        const map = {};
-        const nameList = [];
-        while (c) {
-            const names = Object.getOwnPropertyNames(c);
-            for (const name of names) {
-                if (/hasOwnProperty|constructor|toString|isValid|errors/i.test(name)) {
-                    continue;
-                }
-                map[name] = true;
-                nameList.push(name);
-            }
-            c = Object.getPrototypeOf(c);
+  static from(o) {
+    const c = Object.getPrototypeOf(o);
+    const key = TypeKey.get(c);
+    const map = PropertyMap.map;
+    const m = map[key] || (map[key] = PropertyMap.createMap(o));
+    return m;
+  }
+  static {
+    this.map = {};
+  }
+  static createMap(c) {
+    const map = {};
+    const nameList = [];
+    while (c) {
+      const names = Object.getOwnPropertyNames(c);
+      for (const name of names) {
+        if (/hasOwnProperty|constructor|toString|isValid|errors/i.test(name)) {
+          continue;
         }
-        const m = new PropertyMap();
-        m.map = map;
-        m.names = nameList;
-        return m;
+        map[name] = true;
+        nameList.push(name);
+      }
+      c = Object.getPrototypeOf(c);
     }
-}
-//# sourceMappingURL=PropertyMap.js.map
+    const m = new PropertyMap();
+    m.map = map;
+    m.names = nameList;
+    return m;
+  }
+}

package/dist-esm/core/Route.js

@@ -1,165 +1,166 @@
 import { StringHelper } from "./StringHelper.js";
 export class Variable {
-    get regex() {
-        if (this.catchAll) {
-            return `(/(?<${this.variable}>.+)?)?`;
-        }
-        let r = "[^\\/]{1,500}";
-        if (this.parseAsNumber) {
-            r = "[0-9]{1,500}";
-        }
-        if (this.optional) {
-            return `(/(?<${this.variable}>${r}))?`;
-        }
-        return `/${StringHelper.escapeRegExp(this.prefix)}(?<${this.variable}>${r})${StringHelper.escapeRegExp(this.suffix)}`;
+  get regex() {
+    if (this.catchAll) {
+      return `(/(?<${this.variable}>.+)?)?`;
     }
-    constructor(variable, name) {
-        this.variable = variable;
-        this.name = name;
-        this.prefix = "";
-        this.suffix = "";
-        this.convert = (v) => v;
-        if (variable.startsWith("*")) {
-            this.catchAll = true;
-            variable = variable.substring(1);
-        }
-        if (variable.endsWith("?")) {
-            this.optional = true;
-            variable = variable.substring(0, variable.length - 1);
-        }
-        const index = variable.indexOf(":");
-        if (index !== -1) {
-            const parseAs = variable.substring(index + 1);
-            variable = variable.substring(0, index);
-            switch (parseAs) {
-                case "number":
-                    this.parseAsNumber = true;
-                    this.convert = (v) => {
-                        const r = parseFloat(v);
-                        if (Number.isNaN(r)) {
-                            return void 0;
-                        }
-                        return r;
-                    };
-                    break;
-                case "boolean":
-                    this.convert = (v) => {
-                        if (v === "true") {
-                            return true;
-                        }
-                        if (v === "false") {
-                            return false;
-                        }
-                    };
-                    break;
+    let r = "[^\\/]{1,500}";
+    if (this.parseAsNumber) {
+      r = "[0-9]{1,500}";
+    }
+    if (this.optional) {
+      return `(/(?<${this.variable}>${r}))?`;
+    }
+    return `/${StringHelper.escapeRegExp(this.prefix)}(?<${this.variable}>${r})${StringHelper.escapeRegExp(this.suffix)}`;
+  }
+  constructor(variable, name) {
+    this.variable = variable;
+    this.name = name;
+    this.prefix = "";
+    this.suffix = "";
+    this.convert = v => v;
+    if (variable.startsWith("*")) {
+      this.catchAll = true;
+      variable = variable.substring(1);
+    }
+    if (variable.endsWith("?")) {
+      this.optional = true;
+      variable = variable.substring(0, variable.length - 1);
+    }
+    const index = variable.indexOf(":");
+    if (index !== -1) {
+      const parseAs = variable.substring(index + 1);
+      variable = variable.substring(0, index);
+      switch (parseAs) {
+        case "number":
+          this.parseAsNumber = true;
+          this.convert = v => {
+            const r = parseFloat(v);
+            if (Number.isNaN(r)) {
+              return void 0;
             }
-        }
-        this.variable = variable;
-        this.name ??= variable;
+            return r;
+          };
+          break;
+        case "boolean":
+          this.convert = v => {
+            if (v === "true") {
+              return true;
+            }
+            if (v === "false") {
+              return false;
+            }
+          };
+          break;
+      }
     }
+    this.variable = variable;
+    this.name ??= variable;
+  }
 }
 export default class Route {
-    static encodeUrl(url) {
-        return url;
+  static encodeUrl(url) {
+    return url;
+  }
+  static create(route, queries, order = 0) {
+    if (!route.startsWith("/")) {
+      throw new Error("String Route must start with /");
     }
-    static create(route, queries, order = 0) {
-        if (!route.startsWith("/")) {
-            throw new Error("String Route must start with /");
+    return new Route(route, queries, order);
+  }
+  constructor(route, queries, order = 0) {
+    this.route = route;
+    this.order = order;
+    this.queries = new Map();
+    this.variables = [];
+    this.substitutions = [];
+    if (queries) {
+      for (const iterator of queries) {
+        let [name, variable = name] = iterator.split("=");
+        if (variable.startsWith("{")) {
+          variable = variable.substring(1, variable.length - 1);
         }
-        return new Route(route, queries, order);
+        this.queries.set(name, variable);
+      }
     }
-    constructor(route, queries, order = 0) {
-        this.route = route;
-        this.order = order;
-        this.queries = new Map();
-        this.variables = [];
-        this.substitutions = [];
-        if (queries) {
-            for (const iterator of queries) {
-                let [name, variable = name] = iterator.split("=");
-                if (variable.startsWith("{")) {
-                    variable = variable.substring(1, variable.length - 1);
-                }
-                this.queries.set(name, variable);
-            }
-        }
-        const tokens = route.substring(1).split(/\//g);
-        let regex = "^";
+    const tokens = route.substring(1).split(/\//g);
+    let regex = "^";
+    this.substitutions.push("/");
+    let catchAll = false;
+    for (const iterator of tokens) {
+      if (regex.length > 2) {
         this.substitutions.push("/");
-        let catchAll = false;
-        for (const iterator of tokens) {
-            if (regex.length > 2) {
-                this.substitutions.push("/");
-            }
-            const match = /\{(\*?[\p{L}:]{1,50}\??)\}/u.exec(iterator);
-            if (!match) {
-                this.substitutions.push(iterator);
-                regex += StringHelper.escapeRegExp("/");
-                regex += StringHelper.escapeRegExp(iterator);
-                continue;
-            }
-            const start = match.index;
-            const index = match[0].length;
-            const name = match[1];
-            const prefix = iterator.substring(0, start);
-            const suffix = iterator.substring(index + 1);
-            const v = new Variable(name);
-            v.prefix = prefix;
-            v.suffix = suffix;
-            regex += v.regex;
-            this.variables.push(v);
-            this.substitutions.push(v);
-            catchAll ||= v.catchAll;
+      }
+      const match = /\{(\*?[\p{L}:]{1,50}\??)\}/u.exec(iterator);
+      if (!match) {
+        this.substitutions.push(iterator);
+        regex += StringHelper.escapeRegExp("/");
+        regex += StringHelper.escapeRegExp(iterator);
+        continue;
+      }
+      const start = match.index;
+      const index = match[0].length;
+      const name = match[1];
+      const prefix = iterator.substring(0, start);
+      const suffix = iterator.substring(index + 1);
+      const v = new Variable(name);
+      v.prefix = prefix;
+      v.suffix = suffix;
+      regex += v.regex;
+      this.variables.push(v);
+      this.substitutions.push(v);
+      catchAll ||= v.catchAll;
+    }
+    if (!catchAll) {
+      regex += "\\/?$";
+    }
+    this.regex = new RegExp(regex, "i");
+  }
+  matches(route, q) {
+    const matches = this.regex.exec(route);
+    if (matches?.length > 0) {
+      const result = {};
+      const {
+        groups
+      } = matches;
+      for (const iterator of this.variables) {
+        const v = groups[iterator.variable];
+        if (v !== void 0 && v !== null) {
+          const converted = iterator.convert(decodeURIComponent(v));
+          if (converted === void 0) {
+            return null;
+          }
+          result[iterator.variable] = converted;
         }
-        if (!catchAll) {
-            regex += "\\/?$";
+      }
+      if (q) {
+        for (let [key, value] of q.entries()) {
+          const variable = this.queries.get(key) ?? key;
+          result[variable] = value;
         }
-        this.regex = new RegExp(regex, "i");
+      }
+      return result;
     }
-    matches(route, q) {
-        const matches = this.regex.exec(route);
-        if (matches?.length > 0) {
-            const result = {};
-            const { groups } = matches;
-            for (const iterator of this.variables) {
-                const v = groups[iterator.variable];
-                if (v !== void 0 && v !== null) {
-                    const converted = iterator.convert(decodeURIComponent(v));
-                    if (converted === void 0) {
-                        return null;
-                    }
-                    result[iterator.variable] = converted;
-                }
-            }
-            if (q) {
-                for (let [key, value] of q.entries()) {
-                    const variable = this.queries.get(key) ?? key;
-                    result[variable] = value;
-                }
-            }
-            return result;
-        }
-        return null;
+    return null;
+  }
+  substitute(vars) {
+    let result = "";
+    for (const iterator of this.substitutions) {
+      if (typeof iterator === "string") {
+        result += iterator;
+        continue;
+      }
+      result += vars[iterator.variable] ?? "";
     }
-    substitute(vars) {
-        let result = "";
-        for (const iterator of this.substitutions) {
-            if (typeof iterator === "string") {
-                result += iterator;
-                continue;
-            }
-            result += vars[iterator.variable] ?? "";
+    if (this.queries.size > 0) {
+      result += "?";
+      for (const [key, variable] of this.queries.entries()) {
+        const value = vars[variable];
+        if (value) {
+          result += `${encodeURIComponent(key)}=${encodeURIComponent(value)}&`;
         }
-        if (this.queries.size > 0) {
-            result += "?";
-            for (const [key, variable] of this.queries.entries()) {
-                const value = vars[variable];
-                if (value) {
-                    result += `${encodeURIComponent(key)}=${encodeURIComponent(value)}&`;
-                }
-            }
-        }
-        return result;
+      }
     }
-}
-//# sourceMappingURL=Route.js.map
+    return result;
+  }
+}