myio-js-library 0.1.239 → 0.1.241

package/dist/index.cjs

@@ -712,6 +712,7 @@ __export(index_exports, {
   groupByDay: () => groupByDay,
   handleDeviceType: () => handleDeviceType,
   interpolateTemperature: () => interpolateTemperature,
+  isConnectionStale: () => isConnectionStale,
   isDeviceOffline: () => isDeviceOffline,
   isEnergyDevice: () => isEnergyDevice,
   isHydrometerDevice: () => isHydrometerDevice,
@@ -1604,6 +1605,27 @@ function normalizeConnectionStatus(rawStatus) {
   }
   return "offline";
 }
+function isConnectionStale({
+  lastConnectTime = null,
+  lastDisconnectTime = null,
+  delayTimeConnectionInMins = 60
+} = {}) {
+  if (!lastConnectTime) {
+    return false;
+  }
+  const lastConnect = new Date(lastConnectTime);
+  const lastDisconnect = lastDisconnectTime ? new Date(lastDisconnectTime) : null;
+  const now = /* @__PURE__ */ new Date();
+  const delayMs = delayTimeConnectionInMins * 60 * 1e3;
+  if (lastDisconnect && lastDisconnect.getTime() > lastConnect.getTime()) {
+    return true;
+  }
+  const timeSinceConnect = now.getTime() - lastConnect.getTime();
+  if (timeSinceConnect > delayMs) {
+    return true;
+  }
+  return false;
+}
 function mapConnectionStatus(rawStatus) {
   return normalizeConnectionStatus(rawStatus);
 }
@@ -1670,14 +1692,26 @@ function calculateDeviceStatus({
   lastConsumptionValue,
   limitOfPowerOnStandByWatts,
   limitOfPowerOnAlertWatts,
-  limitOfPowerOnFailureWatts
+  limitOfPowerOnFailureWatts,
+  // RFC-0110: Optional timestamp parameters for stale connection detection
+  lastConnectTime = null,
+  lastDisconnectTime = null,
+  delayTimeConnectionInMins = 60
 }) {
   const normalizedStatus = normalizeConnectionStatus(connectionStatus);
   if (normalizedStatus === "waiting") {
     return DeviceStatusType.NOT_INSTALLED;
   }
   if (normalizedStatus === "offline") {
-    return DeviceStatusType.NO_INFO;
+    return DeviceStatusType.OFFLINE;
+  }
+  const connectionStale = isConnectionStale({
+    lastConnectTime,
+    lastDisconnectTime,
+    delayTimeConnectionInMins
+  });
+  if (connectionStale && normalizedStatus === "online") {
+    return DeviceStatusType.OFFLINE;
   }
   if (normalizedStatus === "bad") {
     return DeviceStatusType.WEAK_CONNECTION;
@@ -1708,14 +1742,26 @@ function calculateDeviceStatus({
 function calculateDeviceStatusWithRanges({
   connectionStatus,
   lastConsumptionValue,
-  ranges
+  ranges,
+  // RFC-0110: Optional timestamp parameters for stale connection detection
+  lastConnectTime = null,
+  lastDisconnectTime = null,
+  delayTimeConnectionInMins = 60
 }) {
   const normalizedStatus = normalizeConnectionStatus(connectionStatus);
   if (normalizedStatus === "waiting") {
     return DeviceStatusType.NOT_INSTALLED;
   }
   if (normalizedStatus === "offline") {
-    return DeviceStatusType.NO_INFO;
+    return DeviceStatusType.OFFLINE;
+  }
+  const connectionStale = isConnectionStale({
+    lastConnectTime,
+    lastDisconnectTime,
+    delayTimeConnectionInMins
+  });
+  if (connectionStale && normalizedStatus === "online") {
+    return DeviceStatusType.OFFLINE;
   }
   if (normalizedStatus === "bad") {
     return DeviceStatusType.WEAK_CONNECTION;
@@ -1851,7 +1897,9 @@ function createDeviceItem(entityId, meta, options = {}) {
     labelWidget = null,
     apiRow = null,
     globalMapInstantaneousPower = null,
-    temperatureLimits = null
+    temperatureLimits = null,
+    // RFC-0110: Configurable delay time for stale connection detection (default 60 min)
+    delayTimeConnectionInMins = 60
   } = options;
   const deviceType = meta.deviceType || meta.deviceProfile || "";
   const deviceProfile = meta.deviceProfile || deviceType || "";
@@ -1874,11 +1922,19 @@ function createDeviceItem(entityId, meta, options = {}) {
     deviceStatus = calculateDeviceStatusWithRanges({
       connectionStatus,
       lastConsumptionValue: consumptionValue,
-      ranges
+      ranges,
+      lastConnectTime: meta.lastConnectTime ?? null,
+      lastDisconnectTime: meta.lastDisconnectTime ?? null,
+      delayTimeConnectionInMins
     });
   } else {
-    if (connectionStatus === "offline") {
-      deviceStatus = DeviceStatusType.NO_INFO;
+    const staleConnection = isConnectionStale({
+      lastConnectTime: meta.lastConnectTime,
+      lastDisconnectTime: meta.lastDisconnectTime,
+      delayTimeConnectionInMins
+    });
+    if (connectionStatus === "offline" || staleConnection) {
+      deviceStatus = DeviceStatusType.OFFLINE;
     } else if (connectionStatus === "bad") {
       deviceStatus = DeviceStatusType.WEAK_CONNECTION;
     } else if (connectionStatus === "waiting") {
@@ -2001,7 +2057,10 @@ function recalculateDeviceStatus(item, newData = {}, options = {}) {
     ...newData,
     connectionStatus: newData.connectionStatus ?? item.connectionStatus,
     consumption: newData.value ?? newData.consumption ?? item.consumptionPower ?? item.value,
-    deviceMapInstaneousPower: newData.deviceMapInstaneousPower ?? item.deviceMapInstaneousPower
+    deviceMapInstaneousPower: newData.deviceMapInstaneousPower ?? item.deviceMapInstaneousPower,
+    // RFC-0110: Ensure timestamps are passed through
+    lastConnectTime: newData.lastConnectTime ?? item.lastConnectTime,
+    lastDisconnectTime: newData.lastDisconnectTime ?? item.lastDisconnectTime
   };
   const updatedOptions = {
     domain: options.domain ?? getDomainFromDeviceType(item.deviceType),
@@ -2010,7 +2069,9 @@ function recalculateDeviceStatus(item, newData = {}, options = {}) {
     temperatureLimits: options.temperatureLimits ?? {
       min: item.temperatureMin,
       max: item.temperatureMax
-    }
+    },
+    // RFC-0110: Pass delay time for stale connection detection
+    delayTimeConnectionInMins: options.delayTimeConnectionInMins ?? 60
   };
   return createDeviceItem(item.tbId, updatedMeta, updatedOptions);
 }
@@ -34225,10 +34286,10 @@ var ENERGY_SUMMARY_TOOLTIP_CSS = `
   font-size: 11px;
 }
 
-/* Status Matrix */
+/* Status Matrix - RFC-0109: 8 status items (4 columns x 2 rows) */
 .energy-summary-tooltip__status-matrix {
   display: grid;
-  grid-template-columns: repeat(3, 1fr);
+  grid-template-columns: repeat(4, 1fr);
   gap: 6px;
   margin: 6px 0 12px 0;
 }
@@ -34268,6 +34329,17 @@ var ENERGY_SUMMARY_TOOLTIP_CSS = `
   color: #6b7280;
 }
 
+.energy-summary-tooltip__status-item.waiting {
+  background: #fef3c7;
+  color: #92400e;
+  border: 1px dashed #f59e0b;
+}
+
+.energy-summary-tooltip__status-item.weak-connection {
+  background: #ffedd5;
+  color: #c2410c;
+}
+
 .energy-summary-tooltip__status-item.no-consumption {
   background: #f8fafc;
   color: #9ca3af;
@@ -34286,6 +34358,8 @@ var ENERGY_SUMMARY_TOOLTIP_CSS = `
 .energy-summary-tooltip__status-dot.failure { background: #ef4444; }
 .energy-summary-tooltip__status-dot.standby { background: #3b82f6; }
 .energy-summary-tooltip__status-dot.offline { background: #6b7280; }
+.energy-summary-tooltip__status-dot.waiting { background: #fbbf24; }
+.energy-summary-tooltip__status-dot.weak-connection { background: #fb923c; }
 .energy-summary-tooltip__status-dot.no-consumption { background: #d1d5db; }
 
 .energy-summary-tooltip__status-count {
@@ -34349,6 +34423,16 @@ var ENERGY_SUMMARY_TOOLTIP_CSS = `
   color: white;
 }
 
+.energy-summary-tooltip__status-item.waiting .energy-summary-tooltip__status-expand:hover {
+  background: #92400e;
+  color: white;
+}
+
+.energy-summary-tooltip__status-item.weak-connection .energy-summary-tooltip__status-expand:hover {
+  background: #c2410c;
+  color: white;
+}
+
 .energy-summary-tooltip__status-item.no-consumption .energy-summary-tooltip__status-expand:hover {
   background: #9ca3af;
   color: white;
@@ -34363,6 +34447,8 @@ var ENERGY_SUMMARY_TOOLTIP_CSS = `
 .energy-summary-tooltip__device-dot.failure { background: #ef4444; }
 .energy-summary-tooltip__device-dot.standby { background: #3b82f6; }
 .energy-summary-tooltip__device-dot.offline { background: #6b7280; }
+.energy-summary-tooltip__device-dot.waiting { background: #fbbf24; }
+.energy-summary-tooltip__device-dot.weak-connection { background: #fb923c; }
 .energy-summary-tooltip__device-dot.no-consumption { background: #d1d5db; }
 
 /* Total Consumption Footer */
@@ -34447,6 +34533,12 @@ var ENERGY_SUMMARY_TOOLTIP_CSS = `
 }
 
 /* Responsive adjustments */
+@media (max-width: 800px) {
+  .energy-summary-tooltip__status-matrix {
+    grid-template-columns: repeat(3, 1fr);
+  }
+}
+
 @media (max-width: 600px) {
   .energy-summary-tooltip__content {
     min-width: 360px;
@@ -34566,17 +34658,23 @@ var EnergySummaryTooltip = {
   },
   /**
    * Render status matrix with expand buttons
+   * RFC-0109: Reorganized to show connectivity status separately from consumption status
+   * Note: A device can appear in multiple categories (e.g., offline AND noConsumption)
    */
   renderStatusMatrix(status) {
-    const items = [
+    const connectivityItems = [
+      { key: "waiting", label: "N\xE3o Instalado", count: status.waiting, devices: status.waitingDevices },
+      { key: "weak-connection", label: "Conex\xE3o Fraca", count: status.weakConnection, devices: status.weakConnectionDevices },
+      { key: "offline", label: "Offline", count: status.offline, devices: status.offlineDevices }
+    ];
+    const consumptionItems = [
       { key: "normal", label: "Normal", count: status.normal, devices: status.normalDevices },
       { key: "alert", label: "Alerta", count: status.alert, devices: status.alertDevices },
       { key: "failure", label: "Falha", count: status.failure, devices: status.failureDevices },
       { key: "standby", label: "Standby", count: status.standby, devices: status.standbyDevices },
-      { key: "offline", label: "Offline", count: status.offline, devices: status.offlineDevices },
       { key: "no-consumption", label: "Sem Consumo", count: status.noConsumption, devices: status.noConsumptionDevices }
     ];
-    return items.map((item) => {
+    const renderItem = (item) => {
       const expandBtn = item.count > 0 ? `
         <button
           class="energy-summary-tooltip__status-expand"
@@ -34593,7 +34691,9 @@ var EnergySummaryTooltip = {
           ${expandBtn}
         </div>
       `;
-    }).join("");
+    };
+    const allItems = [...connectivityItems, ...consumptionItems];
+    return allItems.map(renderItem).join("");
   },
   /**
    * Render excluded devices notice (if any devices are excluded from CAG)
@@ -34853,11 +34953,15 @@ var EnergySummaryTooltip = {
   _getDevicesForStatus(statusKey) {
     if (!this._currentStatus) return [];
     const deviceMap = {
+      // Connectivity status (RFC-0109)
+      "waiting": this._currentStatus.waitingDevices,
+      "weak-connection": this._currentStatus.weakConnectionDevices,
+      "offline": this._currentStatus.offlineDevices,
+      // Consumption status
       "normal": this._currentStatus.normalDevices,
       "alert": this._currentStatus.alertDevices,
       "failure": this._currentStatus.failureDevices,
       "standby": this._currentStatus.standbyDevices,
-      "offline": this._currentStatus.offlineDevices,
       "no-consumption": this._currentStatus.noConsumptionDevices
     };
     return deviceMap[statusKey] || [];
@@ -34867,11 +34971,15 @@ var EnergySummaryTooltip = {
    */
   _getStatusIcon(statusKey) {
     const icons = {
+      // Connectivity status (RFC-0109)
+      "waiting": "\u{1F4E6}",
+      "weak-connection": "\u{1F4F6}",
+      "offline": "\u{1F4F4}",
+      // Consumption status
       "normal": "\u2705",
       "alert": "\u26A0\uFE0F",
       "failure": "\u274C",
       "standby": "\u{1F4A4}",
-      "offline": "\u{1F4F4}",
       "no-consumption": "\u{1F50C}"
     };
     return icons[statusKey] || "\u{1F4CB}";
@@ -35234,18 +35342,24 @@ var EnergySummaryTooltip = {
       unit: "kWh",
       byCategory: [],
       byStatus: {
+        // Connectivity status (RFC-0109)
+        waiting: 0,
+        weakConnection: 0,
+        offline: 0,
+        // Consumption status
         normal: 0,
         alert: 0,
         failure: 0,
         standby: 0,
-        offline: 0,
         noConsumption: 0,
         // Device lists - populated from orchestrator data
+        waitingDevices: [],
+        weakConnectionDevices: [],
+        offlineDevices: [],
         normalDevices: [],
         alertDevices: [],
         failureDevices: [],
         standbyDevices: [],
-        offlineDevices: [],
         noConsumptionDevices: []
       },
       lastUpdated: (/* @__PURE__ */ new Date()).toISOString()
@@ -35366,20 +35480,27 @@ var EnergySummaryTooltip = {
     const widgetAggregation = receivedData?.deviceStatusAggregation;
     if (widgetAggregation && widgetAggregation.hasData) {
       summary.byStatus = {
+        // Connectivity status (RFC-0109)
+        waiting: widgetAggregation.waiting || 0,
+        weakConnection: widgetAggregation.weakConnection || 0,
+        offline: widgetAggregation.offline || 0,
+        // Consumption status
         normal: widgetAggregation.normal || 0,
         alert: widgetAggregation.alert || 0,
         failure: widgetAggregation.failure || 0,
         standby: widgetAggregation.standby || 0,
-        offline: widgetAggregation.offline || 0,
         noConsumption: widgetAggregation.noConsumption || 0,
+        // Device lists
+        waitingDevices: widgetAggregation.waitingDevices || [],
+        weakConnectionDevices: widgetAggregation.weakConnectionDevices || [],
+        offlineDevices: widgetAggregation.offlineDevices || [],
         normalDevices: widgetAggregation.normalDevices || [],
         alertDevices: widgetAggregation.alertDevices || [],
         failureDevices: widgetAggregation.failureDevices || [],
         standbyDevices: widgetAggregation.standbyDevices || [],
-        offlineDevices: widgetAggregation.offlineDevices || [],
         noConsumptionDevices: widgetAggregation.noConsumptionDevices || []
       };
-      const orchestratorTotal = (widgetAggregation.normal || 0) + (widgetAggregation.alert || 0) + (widgetAggregation.failure || 0) + (widgetAggregation.standby || 0) + (widgetAggregation.offline || 0) + (widgetAggregation.noConsumption || 0);
+      const orchestratorTotal = (widgetAggregation.waiting || 0) + (widgetAggregation.weakConnection || 0) + (widgetAggregation.offline || 0) + (widgetAggregation.normal || 0) + (widgetAggregation.alert || 0) + (widgetAggregation.failure || 0) + (widgetAggregation.standby || 0);
       if (orchestratorTotal > 0) {
         summary.totalDevices = orchestratorTotal;
       }
@@ -35387,7 +35508,7 @@ var EnergySummaryTooltip = {
       const statusAggregation = this._aggregateDeviceStatusFromOrchestrator(domain);
       if (statusAggregation.hasData) {
         summary.byStatus = statusAggregation.byStatus;
-        const orchestratorTotal = statusAggregation.byStatus.normal + statusAggregation.byStatus.alert + statusAggregation.byStatus.failure + statusAggregation.byStatus.standby + statusAggregation.byStatus.offline + statusAggregation.byStatus.noConsumption;
+        const orchestratorTotal = statusAggregation.byStatus.waiting + statusAggregation.byStatus.weakConnection + statusAggregation.byStatus.offline + statusAggregation.byStatus.normal + statusAggregation.byStatus.alert + statusAggregation.byStatus.failure + statusAggregation.byStatus.standby;
         if (orchestratorTotal > 0) {
           summary.totalDevices = orchestratorTotal;
         }
@@ -35396,25 +35517,31 @@ var EnergySummaryTooltip = {
         const statusData = receivedData?.statusCounts || receivedData?.deviceStatus || null;
         if (statusData && typeof statusData === "object") {
           summary.byStatus = {
+            // Connectivity status (RFC-0109)
+            waiting: statusData.waiting || statusData.notInstalled || 0,
+            weakConnection: statusData.weakConnection || statusData.badConnection || 0,
+            offline: statusData.offline || 0,
+            // Consumption status
             normal: statusData.normal || 0,
             alert: statusData.alert || 0,
             failure: statusData.failure || 0,
             standby: statusData.standby || 0,
-            offline: statusData.offline || 0,
             noConsumption: statusData.noConsumption || statusData.zeroConsumption || 0
           };
         } else {
           summary.byStatus = {
-            normal: Math.floor(totalDevices * 0.75),
+            // Connectivity status (RFC-0109) - estimated
+            waiting: Math.floor(totalDevices * 0.01),
+            weakConnection: Math.floor(totalDevices * 0.02),
+            offline: Math.floor(totalDevices * 0.03),
+            // Consumption status - estimated
+            normal: Math.floor(totalDevices * 0.72),
             alert: Math.floor(totalDevices * 0.06),
             failure: Math.floor(totalDevices * 0.02),
             standby: Math.floor(totalDevices * 0.02),
-            offline: Math.floor(totalDevices * 0.03),
             noConsumption: Math.floor(totalDevices * 0.12)
           };
-          const statusSum = Object.values(summary.byStatus).reduce((a, b) => {
-            return typeof b === "number" ? a + b : a;
-          }, 0);
+          const statusSum = (summary.byStatus.waiting || 0) + (summary.byStatus.weakConnection || 0) + (summary.byStatus.offline || 0) + (summary.byStatus.normal || 0) + (summary.byStatus.alert || 0) + (summary.byStatus.failure || 0) + (summary.byStatus.standby || 0);
           if (statusSum !== totalDevices && totalDevices > 0) {
             summary.byStatus.normal += totalDevices - statusSum;
           }
@@ -35424,23 +35551,36 @@ var EnergySummaryTooltip = {
     return summary;
   },
   /**
-   * RFC-0105: Aggregate device status from MyIOOrchestratorData
-   * Iterates through all orchestrator items and groups devices by status
-   * Returns both counts and device lists
+   * RFC-0109: Aggregate device status from MyIOOrchestratorData
+   * Iterates through all orchestrator items and groups devices by:
+   * 1. Connectivity status (waiting, weakConnection, offline) - independent dimension
+   * 2. Consumption status (normal, alert, failure, standby, noConsumption) - for online devices
+   *
+   * IMPORTANT: A device can appear in multiple lists:
+   * - An offline device can ALSO be in noConsumption
+   * - A weakConnection device can ALSO be in normal/alert/failure/standby
+   * EXCEPTION: waiting devices should NOT appear in noConsumption (not installed yet)
    */
   _aggregateDeviceStatusFromOrchestrator(domain = "energy") {
     const result = {
+      // Connectivity status (RFC-0109)
+      waiting: 0,
+      weakConnection: 0,
+      offline: 0,
+      // Consumption status
       normal: 0,
       alert: 0,
       failure: 0,
       standby: 0,
-      offline: 0,
       noConsumption: 0,
+      // Device lists
+      waitingDevices: [],
+      weakConnectionDevices: [],
+      offlineDevices: [],
       normalDevices: [],
       alertDevices: [],
       failureDevices: [],
       standbyDevices: [],
-      offlineDevices: [],
       noConsumptionDevices: []
     };
     const win = typeof window !== "undefined" ? window : null;
@@ -35455,16 +35595,11 @@ var EnergySummaryTooltip = {
       return { hasData: false, byStatus: result };
     }
     const NO_CONSUMPTION_THRESHOLD = 0.01;
-    const statusMapping = {
+    const consumptionStatusMapping = {
       "power_on": "normal",
       "warning": "alert",
       "failure": "failure",
-      "standby": "standby",
-      "power_off": "offline",
-      "maintenance": "offline",
-      "no_info": "offline",
-      "not_installed": "offline",
-      "offline": "offline"
+      "standby": "standby"
     };
     items.forEach((item) => {
       const deviceInfo = {
@@ -35473,19 +35608,45 @@ var EnergySummaryTooltip = {
         name: item.name || item.entityLabel || ""
       };
       const deviceStatus = item.deviceStatus || "no_info";
+      const connectionStatus = item.connectionStatus || "";
       const value = Number(item.value || item.val || 0);
-      const isOnline = !["no_info", "offline", "not_installed", "maintenance", "power_off"].includes(deviceStatus);
-      if (isOnline && Math.abs(value) < NO_CONSUMPTION_THRESHOLD) {
-        result.noConsumption++;
-        result.noConsumptionDevices?.push(deviceInfo);
+      const isWaiting = deviceStatus === "not_installed" || connectionStatus === "waiting";
+      const isWeakConnection = deviceStatus === "weak_connection" || connectionStatus === "bad" || ["bad", "weak", "unstable", "poor", "degraded"].includes(String(connectionStatus).toLowerCase());
+      const isOffline = deviceStatus === "offline" || deviceStatus === "no_info" || deviceStatus === "power_off" || deviceStatus === "maintenance" || connectionStatus === "offline" || connectionStatus === "disconnected";
+      if (isWaiting) {
+        result.waiting++;
+        result.waitingDevices?.push(deviceInfo);
+        return;
+      } else if (isWeakConnection) {
+        result.weakConnection++;
+        result.weakConnectionDevices?.push(deviceInfo);
+      } else if (isOffline) {
+        result.offline++;
+        result.offlineDevices?.push(deviceInfo);
+        if (Math.abs(value) < NO_CONSUMPTION_THRESHOLD || value === null || value === void 0) {
+          result.noConsumption++;
+          result.noConsumptionDevices?.push(deviceInfo);
+        }
         return;
       }
-      const mappedStatus = statusMapping[deviceStatus] || "offline";
-      result[mappedStatus]++;
-      const deviceListKey = `${mappedStatus}Devices`;
-      const deviceList = result[deviceListKey];
-      if (deviceList) {
-        deviceList.push(deviceInfo);
+      const isOnline = !isOffline && !isWaiting;
+      if (isOnline) {
+        if (Math.abs(value) < NO_CONSUMPTION_THRESHOLD) {
+          result.noConsumption++;
+          result.noConsumptionDevices?.push(deviceInfo);
+        }
+        const consumptionCategory = consumptionStatusMapping[deviceStatus];
+        if (consumptionCategory) {
+          result[consumptionCategory]++;
+          const deviceListKey = `${consumptionCategory}Devices`;
+          const deviceList = result[deviceListKey];
+          if (deviceList) {
+            deviceList.push(deviceInfo);
+          }
+        } else {
+          result.normal++;
+          result.normalDevices?.push(deviceInfo);
+        }
       }
     });
     return { hasData: true, byStatus: result };
@@ -48144,6 +48305,7 @@ ${errors.slice(0, 5).join("\n")}` + (errors.length > 5 ? `
   groupByDay,
   handleDeviceType,
   interpolateTemperature,
+  isConnectionStale,
   isDeviceOffline,
   isEnergyDevice,
   isHydrometerDevice,