fix: refactor to reduce codacy findings

Author: Jens Lorenz

src/cards/SummaryCard.ts

@@ -92,15 +92,14 @@ class Simon42SummaryCard extends LitElement {
   private _count = 0;
   private _config!: SummaryCardConfig;
   private _relevantEntityIds: Set<string> | null = null;
-  private _batteryPair: { status: BatteryStatus, group: BatteryStatusGroup } | null = null;
+  private _batteryPair!: { status: BatteryStatus, group: BatteryStatusGroup };
 
   static styles = CSS_STYLES;
 
   setConfig(config: SummaryCardConfig): void {
     this._config = config;
     this._count = 0;
     this._relevantEntityIds = null;
-    this._batteryPair = null;
   }
 
   protected willUpdate(changedProps: PropertyValues): void {
@@ -112,7 +111,6 @@ class Simon42SummaryCard extends LitElement {
     if (!oldHass || oldHass.entities !== this.hass.entities) {
       this._count = 0;
       this._relevantEntityIds = null;
-      this._batteryPair = null;
       debugLog(`summary-${this._config.summary_type}: cache invalidated (registry changed)`);
     }
 
@@ -195,7 +193,7 @@ class Simon42SummaryCard extends LitElement {
           this._batteryPair = { status, group };
           if (group.entities.length > 0) break;
         }
-        result = this._batteryPair?.group.entities || [];
+        result = this._batteryPair.group.entities;
         break;
       }
 
@@ -298,8 +296,8 @@ class Simon42SummaryCard extends LitElement {
         };
 
       case 'batteries': {
-        const status = this._batteryPair?.status || 'good';
-        const display = getBatteryStatusDisplay(this._config)[status];
+        const status = this._batteryPair.status || 'good';
+        const display = getBatteryStatusDisplay(this._config, status);
         return {
           icon: display.icon,
           name: status !== 'good'

src/utils/battery-utils.ts

@@ -23,16 +23,20 @@ type BatteryConfig = Pick<
  * Returns the display configuration for each battery status.
  * Thresholds are taken from the config, with defaults if not set.
  */
-export function getBatteryStatusDisplay(config: BatteryConfig): Record<BatteryStatus, BatteryStatusDisplay> {
+export function getBatteryStatusDisplay(config: BatteryConfig, status: BatteryStatus): BatteryStatusDisplay {
   const criticalThreshold = config.battery_critical_threshold ?? 20;
   const lowThreshold = config.battery_low_threshold ?? 50;
 
-  return {
-    unknown: { icon: 'mdi:battery-unknown', color: 'white', info: null },
-    critical: { icon: 'mdi:battery-alert', color: 'red', info: `< ${criticalThreshold}%` },
-    low: { icon: 'mdi:battery-20', color: 'yellow', info: `${criticalThreshold}% - ${lowThreshold}%` },
-    good: { icon: 'mdi:battery', color: 'green', info: `> ${lowThreshold}%` },
-  };
+  switch (status) {
+    case 'unknown':
+      return { icon: 'mdi:battery-unknown', color: 'white', info: null, };
+    case 'critical':
+      return { icon: 'mdi:battery-alert', color: 'red', info: `< ${criticalThreshold}%`, };
+    case 'low':
+      return { icon: 'mdi:battery-20', color: 'yellow', info: `${criticalThreshold}% - ${lowThreshold}%`, };
+    case 'good':
+      return { icon: 'mdi:battery', color: 'green', info: `> ${lowThreshold}%`, };
+  }
 }
 
 export function buildBatteryStatusGroups(hass: HomeAssistant, config: BatteryConfig): Record<BatteryStatus, BatteryStatusGroup> {
@@ -46,26 +50,22 @@ export function buildBatteryStatusGroups(hass: HomeAssistant, config: BatteryCon
   const criticalThreshold = config.battery_critical_threshold ?? 20;
   const lowThreshold = config.battery_low_threshold ?? 50;
 
-  const isBinarySensor = (entityId: string) => entityId.startsWith('binary_sensor.');
-  const isUnavailableOrUnknown = (state: string) => (state === 'unavailable' || state === 'unknown');
-
   for (const entityId of filterBatteryEntities(hass, config)) {
-    let key: BatteryStatus;
+    let group: BatteryStatusGroup;
 
-    const state = hass.states[entityId];
-    if (config.show_unknown_battery_group && isUnavailableOrUnknown(state.state)) {
-      key = 'unknown';
-    } else if (isBinarySensor(entityId)) {
-      key = state.state === 'on' ? 'critical' : 'good';
+    const state = hass.states[entityId].state;
+    if (config.show_unknown_battery_group && (state === 'unavailable' || state === 'unknown')) {
+      group = batteryGroups.unknown;
+    } else if (entityId.startsWith('binary_sensor.')) {
+      group = state === 'on' ? batteryGroups.critical : batteryGroups.good;
     } else {
-      const value = parseFloat(state.state);
-      if (isNaN(value)) key = 'critical';
-      else if (value < criticalThreshold) key = 'critical';
-      else if (value <= lowThreshold) key = 'low';
-      else key = 'good';
+      const value = parseFloat(state);
+      if (isNaN(value)) group = batteryGroups.critical;
+      else if (value < criticalThreshold) group = batteryGroups.critical;
+      else if (value <= lowThreshold) group = batteryGroups.low;
+      else group = batteryGroups.good;
     }
-
-    batteryGroups[key].entities.push(entityId);
+    group.entities.push(entityId);
   }
 
   return batteryGroups;

src/views/BatteriesViewStrategy.ts

@@ -3,46 +3,47 @@
 // ====================================================================
 
 import type { HomeAssistant } from '../types/homeassistant';
-import type { LovelaceViewConfig, LovelaceSectionConfig } from '../types/lovelace';
+import type { LovelaceViewConfig, LovelaceSectionConfig, LovelaceCardConfig } from '../types/lovelace';
 import { Registry } from '../Registry';
 import { type BatteryStatus, type BatteryStatusGroup, buildBatteryStatusGroups, getBatteryStatusDisplay } from '../utils/battery-utils';
 import { localize } from '../utils/localize';
 
 type BatteryStatusKeys = BatteryStatus[];
+type BatteryStatusKeyList = BatteryStatusKeys[];
 
 /**
  * Smart Grid Layout:
  * Groups battery status groups into 1-3 grid sections based on their entity counts, to optimize visual balance and minimize empty space.
  * - If all groups have very few entities, they are combined into a single section.
  * - If one group has significantly more entities than the others, it gets its own section, while smaller groups are combined.
  */
-function smartGridGrouping(batteryGroups: Record<BatteryStatus, BatteryStatusGroup>): BatteryStatusKeys[] {
+function smartGridGrouping(batteryGroups: Record<BatteryStatus, BatteryStatusGroup>): BatteryStatusKeyList {
 
   // Determine the maximum entity count among groups with entities (ignoring empty groups)
   const maxEntities = [...Object.values(batteryGroups)]
     .filter((group) => group.entities.length > 0)
     .reduce((max, group) => Math.max(max, group.entities.length), 0);
 
-  // Loop through each group and assign to grid groups based on count relative to maxEntities
+  // Loop through each group and assign it to a grid group based on its count relative to maxEntities
   let numEntities = 0;
-  let groupKeys: BatteryStatusKeys[] = [];
+  let statusKeyList: BatteryStatusKeyList = [];
   for (const [key, group] of Object.entries(batteryGroups) as Array<[BatteryStatus, BatteryStatusGroup]>) {
-    numEntities += group.entities.length;
-    if (numEntities === 0) continue;
+    if (group.entities.length === 0) continue;
 
     // If adding this group would exceed 75% of maxEntities, start a new grid group
-    if (groupKeys.length !== 0 && (numEntities <= maxEntities * 0.75)) {
-      groupKeys[groupKeys.length - 1].push(key);
+    numEntities += group.entities.length;
+    if (statusKeyList.length !== 0 && (numEntities <= maxEntities * 0.75)) {
+      statusKeyList[statusKeyList.length - 1].push(key);
     } else {
-      groupKeys.push([key]);
+      statusKeyList.push([key]);
     }
   }
 
-  // If we still ended up still with 4 groups, merge the first and last two groups to a 2-column grid
-  if (groupKeys.length === 4) {
-    return [[groupKeys[0][0], groupKeys[1][0]], [groupKeys[2][0], groupKeys[3][0]]];
+  // If we still end up with 4 groups, merge them into a 2-column grid
+  if (statusKeyList.length === 4) {
+    return [[statusKeyList[0][0], statusKeyList[1][0]], [statusKeyList[2][0], statusKeyList[3][0]]];
   }
-  return groupKeys;
+  return statusKeyList;
 }
 
 class Simon42ViewBatteriesStrategy extends HTMLElement {
@@ -52,19 +53,17 @@ class Simon42ViewBatteriesStrategy extends HTMLElement {
 
     const strategyConfig = config.config || {};
     const batteryGroups = buildBatteryStatusGroups(hass, strategyConfig);
-    const batteryGroupStyles = getBatteryStatusDisplay(strategyConfig);
 
     const sections: LovelaceSectionConfig[] = [];
 
     // Build sections based on grid groups
-    for (const gridGroupKeys of smartGridGrouping(batteryGroups)) {
-      const cards: any[] = [];
+    for (const statusKeyList of smartGridGrouping(batteryGroups)) {
+      const cards: LovelaceCardConfig[] = [];
 
       // Build sections based on grid groups
-      for (const key of gridGroupKeys) {
+      for (const status of statusKeyList) {
 
-        const entities = batteryGroups[key].entities;
-        if (!entities || entities.length === 0) continue;
+        const entities = batteryGroups[status]!.entities;
 
         entities.sort((a: string, b: string) => {
           const valA = parseFloat(hass.states[a]?.state);
@@ -74,11 +73,11 @@ class Simon42ViewBatteriesStrategy extends HTMLElement {
           return valA - valB;
         });
 
-        const style = batteryGroupStyles[key];
+        const style = getBatteryStatusDisplay(strategyConfig, status);
         const oneOrMany = entities.length === 1 ? 'battery_one' : 'battery_many';
         cards.push({
           type: 'heading',
-          heading: `${localize('batteries.' + key)} ` + (style.info ? `(${style.info})` : '') +
+          heading: `${localize('batteries.' + status)} ` + (style.info ? `(${style.info})` : '') +
             ` - ${entities.length} ${localize('batteries.' + oneOrMany)}`,
           heading_style: 'title',
           icon: style.icon,