@web-atoms/core 2.6.24 → 2.6.25

package/dist-esm/core/AtomLoader.js

@@ -6,236 +6,250 @@ import { displayRouteSymbol } from "./Command.js";
 import { getOwnInheritedProperty } from "./InheritedProperty.js";
 import { CancelToken } from "./types.js";
 export class AtomLoader {
-    static { this.id = 1; }
-    static async load(url, app) {
-        if (url instanceof AtomUri) {
-            if (url.host === "reference") {
-                const r = app.get(ReferenceService).get(url.path);
-                if (!r) {
-                    throw new Error("reference not found");
-                }
-                return r.consume();
-            }
-            if (url.host === "class") {
-                const r = app.get(ReferenceService).get(url.path);
-                if (!r) {
-                    throw new Error("reference not found");
-                }
-                return app.resolve(r.consume(), true);
-            }
-            url = url.path;
+  static {
+    this.id = 1;
+  }
+  static async load(url, app) {
+    if (url instanceof AtomUri) {
+      if (url.host === "reference") {
+        const r = app.get(ReferenceService).get(url.path);
+        if (!r) {
+          throw new Error("reference not found");
         }
-        const obj = app.resolve(url, true);
-        return obj;
+        return r.consume();
+      }
+      if (url.host === "class") {
+        const r = app.get(ReferenceService).get(url.path);
+        if (!r) {
+          throw new Error("reference not found");
+        }
+        return app.resolve(r.consume(), true);
+      }
+      url = url.path;
     }
-    static async loadView(url, app, hookCloseEvents, vmFactory) {
-        const env_1 = { stack: [], error: void 0, hasError: false };
-        try {
-            const _busy = __addDisposableResource(env_1, app.createBusyIndicator({
-                title: url.toString(),
-                description: `Loading View ${url}`
-            }), false);
-            const view = await AtomLoader.load(url, app);
-            let vm = view.viewModel;
-            if (!vm) {
-                if (!vmFactory) {
-                    return { view };
-                }
-                vm = vmFactory();
-                view.viewModel = vm;
+    const obj = app.resolve(url, true);
+    return obj;
+  }
+  static async loadView(url, app, hookCloseEvents, vmFactory) {
+    const env_1 = {
+      stack: [],
+      error: void 0,
+      hasError: false
+    };
+    try {
+      const _busy = __addDisposableResource(env_1, app.createBusyIndicator({
+        title: url.toString(),
+        description: `Loading View ${url}`
+      }), false);
+      const view = await AtomLoader.load(url, app);
+      let vm = view.viewModel;
+      if (!vm) {
+        if (!vmFactory) {
+          return {
+            view
+          };
+        }
+        vm = vmFactory();
+        view.viewModel = vm;
+      }
+      if ("parameters" in view) {
+        vm = view.parameters;
+      }
+      if (vm) {
+        const jsonService = app.get(JsonService);
+        for (const key in url.query) {
+          if (url.query.hasOwnProperty(key)) {
+            const element = url.query[key];
+            if (typeof element === "object") {
+              vm[key] = jsonService.parse(jsonService.stringify(element));
+              continue;
             }
-            if ("parameters" in view) {
-                vm = view.parameters;
+            if (/^json\:/.test(key)) {
+              const k = key.split(":")[1];
+              vm[k] = jsonService.parse(element.toString());
+              continue;
             }
-            if (vm) {
-                const jsonService = app.get(JsonService);
-                for (const key in url.query) {
-                    if (url.query.hasOwnProperty(key)) {
-                        const element = url.query[key];
-                        if (typeof element === "object") {
-                            vm[key] = jsonService.parse(jsonService.stringify(element));
-                            continue;
-                        }
-                        if (/^json\:/.test(key)) {
-                            const k = key.split(":")[1];
-                            vm[k] = jsonService.parse(element.toString());
-                            continue;
-                        }
-                        if (/^ref\:/.test(key)) {
-                            const rs = app.get(ReferenceService);
-                            const v = rs.get(element);
-                            vm[key.split(":", 2)[1]] = v.consume();
-                            continue;
-                        }
-                        try {
-                            vm[key] = element;
-                        }
-                        catch (e) {
-                            console.error(e);
-                        }
-                    }
-                }
+            if (/^ref\:/.test(key)) {
+              const rs = app.get(ReferenceService);
+              const v = rs.get(element);
+              vm[key.split(":", 2)[1]] = v.consume();
+              continue;
             }
-            if (hookCloseEvents && vm) {
-                const disposables = view.disposables;
-                const id = (AtomLoader.id++).toString();
-                view.id = id;
-                const returnPromise = new Promise((resolve, reject) => {
-                    disposables.add(app.subscribe(`atom-window-close:${id}`, (m, r) => {
-                        resolve(r);
-                        view.dispose();
-                    }));
-                    disposables.add(app.subscribe(`atom-window-cancel:${id}`, () => {
-                        reject("cancelled");
-                        view.dispose();
-                    }));
-                });
-                vm.windowName = id;
-                view.returnPromise = returnPromise;
-                return { view, disposables, returnPromise, id };
+            try {
+              vm[key] = element;
+            } catch (e) {
+              console.error(e);
             }
-            return { view };
-        }
-        catch (e_1) {
-            env_1.error = e_1;
-            env_1.hasError = true;
-        }
-        finally {
-            __disposeResources(env_1);
+          }
         }
+      }
+      if (hookCloseEvents && vm) {
+        const disposables = view.disposables;
+        const id = (AtomLoader.id++).toString();
+        view.id = id;
+        const returnPromise = new Promise((resolve, reject) => {
+          disposables.add(app.subscribe(`atom-window-close:${id}`, (m, r) => {
+            resolve(r);
+            view.dispose();
+          }));
+          disposables.add(app.subscribe(`atom-window-cancel:${id}`, () => {
+            reject("cancelled");
+            view.dispose();
+          }));
+        });
+        vm.windowName = id;
+        view.returnPromise = returnPromise;
+        return {
+          view,
+          disposables,
+          returnPromise,
+          id
+        };
+      }
+      return {
+        view
+      };
+    } catch (e_1) {
+      env_1.error = e_1;
+      env_1.hasError = true;
+    } finally {
+      __disposeResources(env_1);
     }
-    static async loadClass(url, { title, [displayRouteSymbol]: route, ...parameters } = {}, app) {
-        const env_2 = { stack: [], error: void 0, hasError: false };
-        try {
-            const _busyIndicator = __addDisposableResource(env_2, app.createBusyIndicator({
-                title: url?.toString(),
-                description: `Loading View ${url}`
-            }), false);
-            const view = await AtomLoader.load(url, app);
-            const vm = getOwnInheritedProperty(view, "viewModel");
-            let params;
-            if ("parameters" in view) {
-                params = view.parameters;
-            }
-            if (!vm) {
-                params = view.parameters ??= {};
+  }
+  static async loadClass(url, {
+    title,
+    [displayRouteSymbol]: route,
+    ...parameters
+  } = {}, app) {
+    const env_2 = {
+      stack: [],
+      error: void 0,
+      hasError: false
+    };
+    try {
+      const _busyIndicator = __addDisposableResource(env_2, app.createBusyIndicator({
+        title: url?.toString(),
+        description: `Loading View ${url}`
+      }), false);
+      const view = await AtomLoader.load(url, app);
+      const vm = getOwnInheritedProperty(view, "viewModel");
+      let params;
+      if ("parameters" in view) {
+        params = view.parameters;
+      }
+      if (!vm) {
+        params = view.parameters ??= {};
+      } else {
+        console.warn("ViewModel is deprecated");
+      }
+      if (title) {
+        view.title = title;
+      }
+      if (params) {
+        params[displayRouteSymbol] = route;
+      }
+      if ((vm || params) && parameters) {
+        for (const key in parameters) {
+          if (parameters.hasOwnProperty(key)) {
+            const element = parameters[key];
+            try {
+              if (vm) {
+                vm[key] = element;
+              }
+              if (params) {
+                params[key] = element;
+              }
+            } catch (e) {
+              console.error(e);
             }
-            else {
-                console.warn("ViewModel is deprecated");
-            }
-            if (title) {
-                view.title = title;
-            }
-            if (params) {
-                params[displayRouteSymbol] = route;
-            }
-            if ((vm || params) && parameters) {
-                for (const key in parameters) {
-                    if (parameters.hasOwnProperty(key)) {
-                        const element = parameters[key];
-                        try {
-                            if (vm) {
-                                vm[key] = element;
-                            }
-                            if (params) {
-                                params[key] = element;
-                            }
-                        }
-                        catch (e) {
-                            console.error(e);
-                        }
-                    }
-                }
-            }
-            view.init?.()
-                ?.catch((error) => {
-                if (!CancelToken.isCancelled(error)) {
-                    console.error(error);
-                }
-            });
-            return view;
-        }
-        catch (e_2) {
-            env_2.error = e_2;
-            env_2.hasError = true;
+          }
         }
-        finally {
-            __disposeResources(env_2);
+      }
+      view.init?.()?.catch(error => {
+        if (!CancelToken.isCancelled(error)) {
+          console.error(error);
         }
+      });
+      return view;
+    } catch (e_2) {
+      env_2.error = e_2;
+      env_2.hasError = true;
+    } finally {
+      __disposeResources(env_2);
     }
-    static async loadControl(url, app) {
-        const env_3 = { stack: [], error: void 0, hasError: false };
-        try {
-            const _busyIndicator = __addDisposableResource(env_3, app.createBusyIndicator({
-                title: url?.toString(),
-                description: `Loading View ${url}`
-            }), false);
-            const view = await AtomLoader.load(url, app);
-            const vm = getOwnInheritedProperty(view, "viewModel");
-            let params;
-            if ("parameters" in view) {
-                params = view.parameters;
+  }
+  static async loadControl(url, app) {
+    const env_3 = {
+      stack: [],
+      error: void 0,
+      hasError: false
+    };
+    try {
+      const _busyIndicator = __addDisposableResource(env_3, app.createBusyIndicator({
+        title: url?.toString(),
+        description: `Loading View ${url}`
+      }), false);
+      const view = await AtomLoader.load(url, app);
+      const vm = getOwnInheritedProperty(view, "viewModel");
+      let params;
+      if ("parameters" in view) {
+        params = view.parameters;
+      }
+      if (!vm) {
+        params = view.parameters ??= {};
+      }
+      if (vm || params) {
+        const jsonService = app.get(JsonService);
+        for (const key in url.query) {
+          if (url.query.hasOwnProperty(key)) {
+            const element = url.query[key];
+            if (/^json\:/.test(key)) {
+              const k = key.split(":")[1];
+              const v = jsonService.parse(element.toString());
+              if (vm) {
+                vm[k] = v;
+              }
+              if (params) {
+                params[k] = v;
+              }
+              continue;
             }
-            if (!vm) {
-                params = view.parameters ??= {};
+            if (/^ref\:/.test(key)) {
+              const rs = app.get(ReferenceService);
+              const v = rs.get(element).consume();
+              const keyName = key.split(":", 2)[1];
+              if (vm) {
+                vm[keyName] = v;
+              }
+              if (params) {
+                params[keyName] = v;
+              }
+              continue;
             }
-            if (vm || params) {
-                const jsonService = app.get(JsonService);
-                for (const key in url.query) {
-                    if (url.query.hasOwnProperty(key)) {
-                        const element = url.query[key];
-                        if (/^json\:/.test(key)) {
-                            const k = key.split(":")[1];
-                            const v = jsonService.parse(element.toString());
-                            if (vm) {
-                                vm[k] = v;
-                            }
-                            if (params) {
-                                params[k] = v;
-                            }
-                            continue;
-                        }
-                        if (/^ref\:/.test(key)) {
-                            const rs = app.get(ReferenceService);
-                            const v = rs.get(element).consume();
-                            const keyName = key.split(":", 2)[1];
-                            if (vm) {
-                                vm[keyName] = v;
-                            }
-                            if (params) {
-                                params[keyName] = v;
-                            }
-                            continue;
-                        }
-                        try {
-                            if (vm) {
-                                vm[key] = element;
-                            }
-                            if (params) {
-                                params[key] = element;
-                            }
-                        }
-                        catch (e) {
-                            console.error(e);
-                        }
-                    }
-                }
+            try {
+              if (vm) {
+                vm[key] = element;
+              }
+              if (params) {
+                params[key] = element;
+              }
+            } catch (e) {
+              console.error(e);
             }
-            view.init?.()
-                ?.catch((error) => {
-                if (!CancelToken.isCancelled(error)) {
-                    console.error(error);
-                }
-            });
-            return view;
-        }
-        catch (e_3) {
-            env_3.error = e_3;
-            env_3.hasError = true;
+          }
         }
-        finally {
-            __disposeResources(env_3);
+      }
+      view.init?.()?.catch(error => {
+        if (!CancelToken.isCancelled(error)) {
+          console.error(error);
         }
+      });
+      return view;
+    } catch (e_3) {
+      env_3.error = e_3;
+      env_3.hasError = true;
+    } finally {
+      __disposeResources(env_3);
     }
-}
-//# sourceMappingURL=AtomLoader.js.map
+  }
+}

package/dist-esm/core/AtomMap.js

@@ -1,10 +1,9 @@
 Map.prototype.getOrCreate = function (key, factory) {
-    let item = this.get(key);
-    if (item === undefined) {
-        item = factory(key);
-        this.set(key, item);
-    }
-    return item;
+  let item = this.get(key);
+  if (item === undefined) {
+    item = factory(key);
+    this.set(key, item);
+  }
+  return item;
 };
-export default Map;
-//# sourceMappingURL=AtomMap.js.map
+export default Map;

package/dist-esm/core/AtomOnce.js

@@ -1,26 +1,24 @@
 export class AtomOnce {
-    run(f) {
-        if (this.isRunning) {
-            return;
-        }
-        let isAsync = false;
-        try {
-            this.isRunning = true;
-            const p = f();
-            if (p && p.then && p.catch) {
-                isAsync = true;
-                p.then(() => {
-                    this.isRunning = false;
-                }).catch(() => {
-                    this.isRunning = false;
-                });
-            }
-        }
-        finally {
-            if (!isAsync) {
-                this.isRunning = false;
-            }
-        }
+  run(f) {
+    if (this.isRunning) {
+      return;
     }
-}
-//# sourceMappingURL=AtomOnce.js.map
+    let isAsync = false;
+    try {
+      this.isRunning = true;
+      const p = f();
+      if (p && p.then && p.catch) {
+        isAsync = true;
+        p.then(() => {
+          this.isRunning = false;
+        }).catch(() => {
+          this.isRunning = false;
+        });
+      }
+    } finally {
+      if (!isAsync) {
+        this.isRunning = false;
+      }
+    }
+  }
+}