@web-atoms/core 2.6.21 → 2.6.25

package/dist-esm/services/JsonService.js

@@ -4,127 +4,129 @@ import { RegisterSingleton } from "../di/RegisterSingleton.js";
 import DateTime from "@web-atoms/date-time/dist/DateTime.js";
 export const dateFormatISORegEx = /^(\d{4})-(\d{2})-(\d{2})T(\d{2}):(\d{2}):(\d{2}(?:\.\d*)?)Z$/;
 export const dateFormatMSRegEx = /^\/Date\((d|-|.*)\)[\/|\\]$/;
-const timeZoneDiff = (new Date()).getTimezoneOffset();
+const timeZoneDiff = new Date().getTimezoneOffset();
 let JsonService = class JsonService {
-    constructor() {
-        this.options = {
-            indent: 2,
-            namingStrategy: "none",
-            dateConverter: [
-                {
-                    regex: dateFormatISORegEx,
-                    valueConverter: {
-                        fromSource(v) {
-                            const d = new DateTime(v);
-                            return d;
-                        },
-                        fromTarget(v) {
-                            return v.toISOString();
-                        }
-                    }
-                }, {
-                    regex: dateFormatMSRegEx,
-                    valueConverter: {
-                        fromSource(v) {
-                            const a = dateFormatMSRegEx.exec(v);
-                            const b = a[1].split(/[-+,.]/);
-                            return new DateTime(b[0] ? +b[0] : 0 - +b[1]);
-                        },
-                        fromTarget(v) {
-                            return v.toISOString();
-                        }
-                    }
-                }
-            ]
-        };
-    }
-    transformKeys(t, v) {
-        if (!v) {
-            return v;
-        }
-        if (typeof v !== "object") {
-            return v;
-        }
-        if (v instanceof Date) {
-            return v;
+  constructor() {
+    this.options = {
+      indent: 2,
+      namingStrategy: "none",
+      dateConverter: [{
+        regex: dateFormatISORegEx,
+        valueConverter: {
+          fromSource(v) {
+            const d = new DateTime(v);
+            return d;
+          },
+          fromTarget(v) {
+            return v.toISOString();
+          }
         }
-        if (typeof v === "object" && v.length !== undefined && typeof v.length === "number") {
-            const a = v;
-            if (a.map) {
-                return a.map((x) => this.transformKeys(t, x));
-            }
-            const ra = [];
-            for (let i = 0; i < a.length; i++) {
-                const iterator = a[i];
-                ra.push(this.transformKeys(t, iterator));
-            }
-            return ra;
+      }, {
+        regex: dateFormatMSRegEx,
+        valueConverter: {
+          fromSource(v) {
+            const a = dateFormatMSRegEx.exec(v);
+            const b = a[1].split(/[-+,.]/);
+            return new DateTime(b[0] ? +b[0] : 0 - +b[1]);
+          },
+          fromTarget(v) {
+            return v.toISOString();
+          }
         }
-        const r = {};
-        for (const key in v) {
-            if (v.hasOwnProperty(key)) {
-                const element = v[key];
-                r[t(key)] = this.transformKeys(t, element);
-            }
-        }
-        return r;
+      }]
+    };
+  }
+  transformKeys(t, v) {
+    if (!v) {
+      return v;
     }
-    parse(text, options) {
-        const { dateConverter, namingStrategy } = {
-            ...this.options,
-            ...options
-        };
-        const result = JSON.parse(text, (key, value) => {
-            if (typeof value === "string") {
-                for (const iterator of dateConverter) {
-                    const a = iterator.regex.test(value);
-                    if (a) {
-                        const dv = iterator.valueConverter.fromSource(value);
-                        return dv;
-                    }
-                }
-            }
-            return value;
-        });
-        switch (namingStrategy) {
-            case "hyphen":
-                return this.transformKeys(StringHelper.fromHyphenToCamel, result);
-            case "underscore":
-                return this.transformKeys(StringHelper.fromUnderscoreToCamel, result);
-            case "pascal":
-                return this.transformKeys(StringHelper.fromPascalToCamel, result);
-        }
-        return result;
+    if (typeof v !== "object") {
+      return v;
     }
-    stringify(v, options) {
-        const { namingStrategy, dateConverter, indent } = {
-            ...this.options,
-            ...options
-        };
-        switch (namingStrategy) {
-            case "hyphen":
-                v = this.transformKeys(StringHelper.fromCamelToHyphen, v);
-                break;
-            case "underscore":
-                v = this.transformKeys(StringHelper.fromCamelToUnderscore, v);
-                break;
-            case "pascal":
-                v = this.transformKeys(StringHelper.fromCamelToPascal, v);
-                break;
+    if (v instanceof Date) {
+      return v;
+    }
+    if (typeof v === "object" && v.length !== undefined && typeof v.length === "number") {
+      const a = v;
+      if (a.map) {
+        return a.map(x => this.transformKeys(t, x));
+      }
+      const ra = [];
+      for (let i = 0; i < a.length; i++) {
+        const iterator = a[i];
+        ra.push(this.transformKeys(t, iterator));
+      }
+      return ra;
+    }
+    const r = {};
+    for (const key in v) {
+      if (v.hasOwnProperty(key)) {
+        const element = v[key];
+        r[t(key)] = this.transformKeys(t, element);
+      }
+    }
+    return r;
+  }
+  parse(text, options) {
+    const {
+      dateConverter,
+      namingStrategy
+    } = {
+      ...this.options,
+      ...options
+    };
+    const result = JSON.parse(text, (key, value) => {
+      if (typeof value === "string") {
+        for (const iterator of dateConverter) {
+          const a = iterator.regex.test(value);
+          if (a) {
+            const dv = iterator.valueConverter.fromSource(value);
+            return dv;
+          }
         }
-        return JSON.stringify(v, (key, value) => {
-            if (key && /^\_\$\_/.test(key)) {
-                return undefined;
-            }
-            if (dateConverter && (value instanceof Date)) {
-                return dateConverter[0].valueConverter.fromTarget(value);
-            }
-            return value;
-        }, indent);
+      }
+      return value;
+    });
+    switch (namingStrategy) {
+      case "hyphen":
+        return this.transformKeys(StringHelper.fromHyphenToCamel, result);
+      case "underscore":
+        return this.transformKeys(StringHelper.fromUnderscoreToCamel, result);
+      case "pascal":
+        return this.transformKeys(StringHelper.fromPascalToCamel, result);
+    }
+    return result;
+  }
+  stringify(v, options) {
+    const {
+      namingStrategy,
+      dateConverter,
+      indent
+    } = {
+      ...this.options,
+      ...options
+    };
+    switch (namingStrategy) {
+      case "hyphen":
+        v = this.transformKeys(StringHelper.fromCamelToHyphen, v);
+        break;
+      case "underscore":
+        v = this.transformKeys(StringHelper.fromCamelToUnderscore, v);
+        break;
+      case "pascal":
+        v = this.transformKeys(StringHelper.fromCamelToPascal, v);
+        break;
     }
+    return JSON.stringify(v, (key, value) => {
+      if (key && /^\_\$\_/.test(key)) {
+        return undefined;
+      }
+      if (dateConverter && value instanceof Date) {
+        return dateConverter[0].valueConverter.fromTarget(value);
+      }
+      return value;
+    }, indent);
+  }
 };
-JsonService = __decorate([
-    RegisterSingleton
-], JsonService);
-export { JsonService };
-//# sourceMappingURL=JsonService.js.map
+JsonService = __decorate([RegisterSingleton], JsonService);
+export { JsonService };

package/dist-esm/services/MockNavigationService.js

@@ -4,134 +4,135 @@ import { AtomUri } from "../core/AtomUri.js";
 import { RegisterSingleton } from "../di/RegisterSingleton.js";
 import { AtomWindowViewModel } from "../view-model/AtomWindowViewModel.js";
 import { NavigationService } from "./NavigationService.js";
-export class MockConfirmViewModel extends AtomWindowViewModel {
-}
+export class MockConfirmViewModel extends AtomWindowViewModel {}
 let MockNavigationService = class MockNavigationService extends NavigationService {
-    get location() {
-        return this.mLocation;
-    }
-    set location(v) {
-        if (JSON.stringify(this.location) === JSON.stringify(v)) {
-            return;
-        }
-        this.history.push(this.mLocation);
-        this.mLocation = v;
-    }
-    constructor(app) {
-        super(app);
-        this.windowStack = [];
-        this.history = [];
-        this.mLocation = new AtomUri("");
-    }
-    refresh() {
-    }
-    navigate(url) {
-        this.location = new AtomUri(url);
-    }
-    back() {
-        if (this.history.length) {
-            const top = this.history.pop();
-            this.location = top;
-            this.history.pop();
-        }
-    }
-    alert(msg, title) {
-        return this.openTestWindow(`__AlertWindow_${msg}`, { message: msg, title });
-    }
-    confirm(msg, title) {
-        return this.openTestWindow(`__ConfirmWindow_${msg}`, { message: msg, title });
-    }
-    openPage(pageName, p) {
-        return this.openTestWindow(pageName, p);
-    }
-    async notify(message, title) {
-        const url = `__AlertNotification_${message}`;
-        const w = this.windowStack.find((x) => x.windowType === message);
-        if (!w) {
-            throw new Error(`No notification registered for "${message}"`);
-        }
-        w.action({});
-    }
-    openTestWindow(c, p) {
-        const url = c instanceof AtomUri ? c : new AtomUri(c);
-        if (p) {
-            for (const key in p) {
-                if (p.hasOwnProperty(key)) {
-                    const element = p[key];
-                    url.query[key] = element;
-                }
-            }
+  get location() {
+    return this.mLocation;
+  }
+  set location(v) {
+    if (JSON.stringify(this.location) === JSON.stringify(v)) {
+      return;
+    }
+    this.history.push(this.mLocation);
+    this.mLocation = v;
+  }
+  constructor(app) {
+    super(app);
+    this.windowStack = [];
+    this.history = [];
+    this.mLocation = new AtomUri("");
+  }
+  refresh() {}
+  navigate(url) {
+    this.location = new AtomUri(url);
+  }
+  back() {
+    if (this.history.length) {
+      const top = this.history.pop();
+      this.location = top;
+      this.history.pop();
+    }
+  }
+  alert(msg, title) {
+    return this.openTestWindow(`__AlertWindow_${msg}`, {
+      message: msg,
+      title
+    });
+  }
+  confirm(msg, title) {
+    return this.openTestWindow(`__ConfirmWindow_${msg}`, {
+      message: msg,
+      title
+    });
+  }
+  openPage(pageName, p) {
+    return this.openTestWindow(pageName, p);
+  }
+  async notify(message, title) {
+    const url = `__AlertNotification_${message}`;
+    const w = this.windowStack.find(x => x.windowType === message);
+    if (!w) {
+      throw new Error(`No notification registered for "${message}"`);
+    }
+    w.action({});
+  }
+  openTestWindow(c, p) {
+    const url = c instanceof AtomUri ? c : new AtomUri(c);
+    if (p) {
+      for (const key in p) {
+        if (p.hasOwnProperty(key)) {
+          const element = p[key];
+          url.query[key] = element;
         }
-        return new Promise((resolve, reject) => {
-            const w = this.windowStack.find((x) => x.windowType === url.path);
-            if (!w) {
-                const ex = new Error(`No window registered for "${c} with ${(p ? JSON.stringify(p, undefined, 2) : "")}"`);
-                reject(ex);
-                return;
-            }
-            setTimeout(() => {
-                try {
-                    const vm = new AtomWindowViewModel(this.app);
-                    for (const key in url.query) {
-                        if (url.query.hasOwnProperty(key)) {
-                            const element = url.query[key];
-                            vm[key] = element;
-                        }
-                    }
-                    resolve(w.action(vm));
-                }
-                catch (e) {
-                    reject(e);
-                }
-            }, 5);
-        });
-    }
-    expectAlert(msg) {
-        return this.expectWindow(`__AlertWindow_${msg}`, (vm) => true);
-    }
-    expectNotification(msg) {
-        return this.expectWindow(`__AlertNotification_${msg}`, (vm) => true);
-    }
-    expectConfirm(msg, action) {
-        return this.expectWindow(`__ConfirmWindow_${msg}`, action);
-    }
-    expectPopup(popupType, windowAction) {
-        return this.expectWindow(popupType, windowAction);
-    }
-    expectWindow(windowType, windowAction) {
-        const registration = { windowType, action: windowAction };
-        registration.action = (vm) => {
-            this.removeRegistration(registration);
-            return windowAction(vm);
-        };
-        this.windowStack.push(registration);
-        return {
-            dispose: () => {
-                this.removeRegistration(registration);
+      }
+    }
+    return new Promise((resolve, reject) => {
+      const w = this.windowStack.find(x => x.windowType === url.path);
+      if (!w) {
+        const ex = new Error(`No window registered for "${c} with ${p ? JSON.stringify(p, undefined, 2) : ""}"`);
+        reject(ex);
+        return;
+      }
+      setTimeout(() => {
+        try {
+          const vm = new AtomWindowViewModel(this.app);
+          for (const key in url.query) {
+            if (url.query.hasOwnProperty(key)) {
+              const element = url.query[key];
+              vm[key] = element;
             }
-        };
-    }
-    removeRegistration(r) {
-        this.windowStack = this.windowStack.filter((x) => x !== r);
-    }
-    assert() {
-        if (!this.windowStack.length) {
-            return;
+          }
+          resolve(w.action(vm));
+        } catch (e) {
+          reject(e);
         }
-        throw new Error(`Expected windows did not open ${this.windowStack.map((x) => `"${x.windowType}"`).join(",")}`);
-    }
-    registerForPopup() {
-    }
-    forceRemove(view) {
-        throw new Error("Method not implemented.");
-    }
-    openWindow(url) {
-        return this.openTestWindow(url);
-    }
+      }, 5);
+    });
+  }
+  expectAlert(msg) {
+    return this.expectWindow(`__AlertWindow_${msg}`, vm => true);
+  }
+  expectNotification(msg) {
+    return this.expectWindow(`__AlertNotification_${msg}`, vm => true);
+  }
+  expectConfirm(msg, action) {
+    return this.expectWindow(`__ConfirmWindow_${msg}`, action);
+  }
+  expectPopup(popupType, windowAction) {
+    return this.expectWindow(popupType, windowAction);
+  }
+  expectWindow(windowType, windowAction) {
+    const registration = {
+      windowType,
+      action: windowAction
+    };
+    registration.action = vm => {
+      this.removeRegistration(registration);
+      return windowAction(vm);
+    };
+    this.windowStack.push(registration);
+    return {
+      dispose: () => {
+        this.removeRegistration(registration);
+      }
+    };
+  }
+  removeRegistration(r) {
+    this.windowStack = this.windowStack.filter(x => x !== r);
+  }
+  assert() {
+    if (!this.windowStack.length) {
+      return;
+    }
+    throw new Error(`Expected windows did not open ${this.windowStack.map(x => `"${x.windowType}"`).join(",")}`);
+  }
+  registerForPopup() {}
+  forceRemove(view) {
+    throw new Error("Method not implemented.");
+  }
+  openWindow(url) {
+    return this.openTestWindow(url);
+  }
 };
-MockNavigationService = __decorate([
-    RegisterSingleton,
-    __metadata("design:paramtypes", [App])
-], MockNavigationService);
-export { MockNavigationService };
-//# sourceMappingURL=MockNavigationService.js.map
+MockNavigationService = __decorate([RegisterSingleton, __metadata("design:paramtypes", [App])], MockNavigationService);
+export { MockNavigationService };