@matter-server/dashboard 0.2.6 → 0.2.7-alpha.0-20260118-45c7af0

package/dist/web/js/main.js

@@ -31,13 +31,77 @@ function toBigIntAwareJson(value, spaces) {
   return result;
 }
 function parseBigIntAwareJson(json) {
-  const processed = json.replace(/([:,[])\s*(\d{15,})(?=[,}\]\s])/g, (match, prefix, number) => {
-    const num = BigInt(number);
-    if (num > Number.MAX_SAFE_INTEGER) {
-      return `${prefix}"${BIGINT_MARKER}${number}"`;
+  const result = [];
+  let i = 0;
+  let inString = false;
+  while (i < json.length) {
+    const char = json[i];
+    if (inString) {
+      if (char === "\\") {
+        result.push(char);
+        i++;
+        if (i < json.length) {
+          result.push(json[i]);
+          i++;
+        }
+      } else if (char === '"') {
+        result.push(char);
+        inString = false;
+        i++;
+      } else {
+        result.push(char);
+        i++;
+      }
+    } else {
+      if (char === '"') {
+        result.push(char);
+        inString = true;
+        i++;
+      } else if (char >= "0" && char <= "9") {
+        const hasMinus = result.length > 0 && result[result.length - 1] === "-";
+        if (hasMinus) {
+          result.pop();
+        }
+        const start = i;
+        while (i < json.length && json[i] >= "0" && json[i] <= "9") {
+          i++;
+        }
+        let isFloat = false;
+        if (i < json.length && json[i] === ".") {
+          isFloat = true;
+          i++;
+          while (i < json.length && json[i] >= "0" && json[i] <= "9") {
+            i++;
+          }
+        }
+        if (i < json.length && (json[i] === "e" || json[i] === "E")) {
+          isFloat = true;
+          i++;
+          if (i < json.length && (json[i] === "+" || json[i] === "-")) {
+            i++;
+          }
+          while (i < json.length && json[i] >= "0" && json[i] <= "9") {
+            i++;
+          }
+        }
+        const numberStr = (hasMinus ? "-" : "") + json.slice(start, i);
+        if (!isFloat && numberStr.length - (hasMinus ? 1 : 0) >= 15) {
+          const num = BigInt(numberStr);
+          if (num > Number.MAX_SAFE_INTEGER || num < Number.MIN_SAFE_INTEGER) {
+            result.push(`"${BIGINT_MARKER}${numberStr}"`);
+          } else {
+            result.push(numberStr);
+          }
+        } else {
+          result.push(numberStr);
+        }
+      } else {
+        result.push(char);
+        i++;
+      }
     }
-    return match;
-  });
+  }
+  const processed = result.join("");
   return JSON.parse(processed, (_key, value) => {
     if (typeof value === "string" && value.startsWith(BIGINT_MARKER)) {
       return BigInt(value.slice(BIGINT_MARKER.length));
@@ -82,6 +146,8 @@ class Connection {
       };
       this.socket.onclose = () => {
         console.log("WebSocket Closed");
+        this.socket = void 0;
+        this.serverInfo = void 0;
         onConnectionLost();
       };
       this.socket.onerror = error => {
@@ -106,6 +172,7 @@ class Connection {
       this.socket.close();
       this.socket = void 0;
     }
+    this.serverInfo = void 0;
   }
   sendMessage(message) {
     if (!this.socket) {
@@ -364,6 +431,26 @@ class MatterClient {
       label
     });
   }
+  /**
+   * Get the current log levels for console and file logging.
+   * @returns The current log level configuration
+   */
+  async getLogLevel() {
+    return await this.sendCommand("get_loglevel", 0, {});
+  }
+  /**
+   * Set the log level for console and/or file logging.
+   * Changes are temporary and will be reset when the server restarts.
+   * @param consoleLoglevel Console log level to set (optional)
+   * @param fileLoglevel File log level to set, only applied if file logging is enabled (optional)
+   * @returns The log level configuration after the change
+   */
+  async setLogLevel(consoleLoglevel, fileLoglevel) {
+    return await this.sendCommand("set_loglevel", 0, {
+      console_loglevel: consoleLoglevel,
+      file_loglevel: fileLoglevel
+    });
+  }
   sendCommand(command, require_schema = void 0, args) {
     if (require_schema && this.serverInfo.schema_version < require_schema) {
       throw new InvalidServerVersion(`Command not available due to incompatible server version. Update the Matter Server to a version that supports at least api schema ${require_schema}.`);
@@ -503,13 +590,81 @@ class MatterClient {
   onRawEvent(_event) {}
 }
 
+/**
+ * @license
+ * Copyright 2025-2026 Open Home Foundation
+ * SPDX-License-Identifier: Apache-2.0
+ */
+const STORAGE_KEY = "matterTheme";
+class ThemeServiceImpl {
+  constructor() {
+    this._preference = "system";
+    this._listeners = /* @__PURE__ */new Set();
+    this._mediaQuery = window.matchMedia("(prefers-color-scheme: dark)");
+    this._mediaQuery.addEventListener("change", () => this._applyTheme());
+    this._loadPreference();
+    this._applyTheme();
+  }
+  get preference() {
+    return this._preference;
+  }
+  get effectiveTheme() {
+    if (this._preference === "system") {
+      return this._mediaQuery.matches ? "dark" : "light";
+    }
+    return this._preference;
+  }
+  setPreference(pref) {
+    this._preference = pref;
+    localStorage.setItem(STORAGE_KEY, pref);
+    this._applyTheme();
+  }
+  cycleTheme() {
+    const cycle = ["light", "dark", "system"];
+    const currentIndex = cycle.indexOf(this._preference);
+    const nextIndex = (currentIndex + 1) % cycle.length;
+    this.setPreference(cycle[nextIndex]);
+    return this._preference;
+  }
+  subscribe(callback) {
+    this._listeners.add(callback);
+    return () => this._listeners.delete(callback);
+  }
+  _loadPreference() {
+    const urlParams = new URLSearchParams(window.location.search);
+    const themeParam = urlParams.get("theme");
+    if (themeParam && ["light", "dark", "system"].includes(themeParam)) {
+      this._preference = themeParam;
+      localStorage.setItem(STORAGE_KEY, themeParam);
+      urlParams.delete("theme");
+      const newUrl = urlParams.toString() ? `${window.location.pathname}?${urlParams.toString()}${window.location.hash}` : `${window.location.pathname}${window.location.hash}`;
+      history.replaceState({}, "", newUrl);
+      return;
+    }
+    const stored = localStorage.getItem(STORAGE_KEY);
+    if (stored && ["light", "dark", "system"].includes(stored)) {
+      this._preference = stored;
+    }
+  }
+  _applyTheme() {
+    const effective = this.effectiveTheme;
+    document.documentElement.classList.toggle("dark-theme", effective === "dark");
+    const metaThemeColor = document.querySelector('meta[name="theme-color"]');
+    if (metaThemeColor) {
+      metaThemeColor.setAttribute("content", effective === "dark" ? "#1e1e1e" : "#03a9f4");
+    }
+    this._listeners.forEach(cb => cb(effective));
+  }
+}
+const ThemeService = new ThemeServiceImpl();
+
 /**
  * @license
  * Copyright 2025-2026 Open Home Foundation
  * SPDX-License-Identifier: Apache-2.0
  */
 async function main() {
-  import('./matter-dashboard-app-CU3-L2nl.js').then(function (n) { return n.s; });
+  import('./matter-dashboard-app-DlHSE_Qh.js').then(function (n) { return n.z; });
   let url = "";
   const isProductionServer = location.origin.includes(":5580") || location.href.includes("hassio_ingress") || location.href.includes("/api/ingress/");
   if (!isProductionServer) {
@@ -544,4 +699,4 @@ async function main() {
 }
 main();
 
-export { toBigIntAwareJson as t };
+export { ThemeService as T, toBigIntAwareJson as t };