@switchbot/homebridge-switchbot 5.0.0-beta.109 → 5.0.0-beta.110

package/src/homebridge-ui/public/js/render.ts

@@ -1,5 +1,126 @@
 import type { DEVICE_TYPES } from './constants.js'
 
+/**
+ * Get RSSI signal quality level and color based on dBm value
+ * @param rssi Signal strength in dBm (typically -30 to -90)
+ * @returns Object with quality level, color, and description
+ */
+export function getRssiSignalQuality(rssi: number | undefined): {
+  level: 'excellent' | 'good' | 'fair' | 'poor' | 'unknown'
+  color: string
+  bgColor: string
+  description: string
+  bars: number
+} {
+  if (!rssi || rssi === 0) {
+    return {
+      level: 'unknown',
+      color: '#999',
+      bgColor: '#f5f5f5',
+      description: 'Signal strength unknown',
+      bars: 0,
+    }
+  }
+
+  const dbm = Math.floor(rssi)
+
+  if (dbm > -60) {
+    return {
+      level: 'excellent',
+      color: '#34a853',
+      bgColor: '#e8f5e9',
+      description: `Excellent (${dbm} dBm)`,
+      bars: 4,
+    }
+  } else if (dbm > -75) {
+    return {
+      level: 'good',
+      color: '#fbbc04',
+      bgColor: '#fffde7',
+      description: `Good (${dbm} dBm)`,
+      bars: 3,
+    }
+  } else if (dbm > -85) {
+    return {
+      level: 'fair',
+      color: '#ff9800',
+      bgColor: '#fff3e0',
+      description: `Fair (${dbm} dBm)`,
+      bars: 2,
+    }
+  } else {
+    return {
+      level: 'poor',
+      color: '#ea4335',
+      bgColor: '#ffebee',
+      description: `Poor (${dbm} dBm) - unreliable`,
+      bars: 1,
+    }
+  }
+}
+
+/**
+ * Create visual signal strength indicator bars
+ * @param rssi Signal strength in dBm
+ * @returns HTML element showing filled bars
+ */
+export function renderSignalBars(rssi: number | undefined): HTMLElement {
+  const quality = getRssiSignalQuality(rssi)
+
+  const container = document.createElement('span')
+  container.style.display = 'inline-flex'
+  container.style.gap = '2px'
+  container.style.alignItems = 'center'
+  container.style.marginLeft = '8px'
+  container.style.fontSize = '12px'
+
+  // Create 4 bars
+  for (let i = 1; i <= 4; i++) {
+    const bar = document.createElement('span')
+    bar.style.height = `${i * 3}px`
+    bar.style.width = '3px'
+    bar.style.borderRadius = '1px'
+    bar.style.border = `1px solid ${quality.color}`
+
+    if (i <= quality.bars) {
+      bar.style.backgroundColor = quality.color
+    } else {
+      bar.style.backgroundColor = 'transparent'
+    }
+
+    container.appendChild(bar)
+  }
+
+  // Add tooltip
+  container.title = quality.description
+
+  return container
+}
+
+/**
+ * Create signal quality badge with color
+ * @param rssi Signal strength in dBm
+ * @returns HTML element showing quality level
+ */
+export function renderSignalQualityBadge(rssi: number | undefined): HTMLElement {
+  const quality = getRssiSignalQuality(rssi)
+
+  const badge = document.createElement('span')
+  badge.textContent = quality.level.charAt(0).toUpperCase() + quality.level.slice(1)
+  badge.style.cssText = `
+    background: ${quality.color};
+    color: white;
+    padding: 2px 6px;
+    border-radius: 3px;
+    font-size: 10px;
+    font-weight: 600;
+    margin-left: 8px;
+  `
+  badge.title = quality.description
+
+  return badge
+}
+
 export function renderBadge(text: string, style: string): HTMLElement {
   const badge = document.createElement('span')
   badge.textContent = text
@@ -35,51 +156,80 @@ export function renderIRBadge(): HTMLElement {
 
 export async function renderDiscoveredDevices(devices: any[]): Promise<HTMLElement> {
   const ul = document.createElement('ul')
-  ul.style.maxHeight = '300px'
+  ul.style.maxHeight = '400px'
   ul.style.overflowY = 'auto'
+  ul.style.marginTop = '12px'
+  ul.style.padding = '0'
+  ul.style.listStyle = 'none'
 
   const { addDeviceToConfig } = await import('./discovery.js')
 
   for (const d of devices) {
     const li = document.createElement('li')
     li.className = 'device-item'
+    li.style.display = 'flex'
+    li.style.alignItems = 'center'
+    li.style.justifyContent = 'space-between'
+    li.style.padding = '10px 12px'
+    li.style.marginBottom = '6px'
+    li.style.borderRadius = '6px'
+    li.style.transition = 'all 0.2s ease'
 
     const info = document.createElement('div')
     info.style.flex = '1'
 
+    const nameContainer = document.createElement('div')
+    nameContainer.style.display = 'flex'
+    nameContainer.style.alignItems = 'center'
+    nameContainer.style.marginBottom = '4px'
+    nameContainer.style.flexWrap = 'wrap'
+    nameContainer.style.gap = '6px'
+
     const name = document.createElement('div')
     name.style.fontWeight = '500'
+    name.style.fontSize = '14px'
     name.textContent = d.name || d.id
 
+    nameContainer.appendChild(name)
+
     // Add connection type badge
     if (d.connectionType) {
-      name.appendChild(document.createTextNode(' '))
       const badge = renderConnectionBadge(d.connectionType)
-      if (badge) { name.appendChild(badge) }
+      if (badge) { nameContainer.appendChild(badge) }
     }
 
     // Add IR badge if it's an IR device
     if (d.isIR) {
-      name.appendChild(document.createTextNode(' '))
-      name.appendChild(renderIRBadge())
+      nameContainer.appendChild(renderIRBadge())
+    }
+
+    // Add signal strength visualization (only for BLE/wireless devices)
+    if (d.rssi !== undefined && d.rssi !== null && d.rssi !== 0) {
+      nameContainer.appendChild(renderSignalBars(d.rssi))
+      nameContainer.appendChild(renderSignalQualityBadge(d.rssi))
     }
 
     const details = document.createElement('div')
-    details.style.fontSize = '12px'
-    details.style.opacity = '0.75'
+    details.style.fontSize = '11px'
+    details.style.opacity = '0.7'
+    details.style.marginTop = '4px'
+    details.style.fontFamily = 'monospace'
 
     let detailsText = `ID: ${d.id} | Type: ${d.type} | Model: ${d.model || 'N/A'}`
     if (d.hubDeviceId) { detailsText += ` | Hub: ${d.hubDeviceId}` }
-    if (d.rssi) { detailsText += ` | Signal: ${d.rssi} dBm` }
     if (d.address) { detailsText += ` | MAC: ${d.address}` }
     details.textContent = detailsText
 
-    info.appendChild(name)
+    info.appendChild(nameContainer)
     info.appendChild(details)
 
     const addBtn = document.createElement('button')
     addBtn.textContent = '+ Add'
     addBtn.style.marginLeft = '8px'
+    addBtn.style.padding = '6px 14px'
+    addBtn.style.fontSize = '12px'
+    addBtn.style.whiteSpace = 'nowrap'
+    addBtn.style.flexShrink = '0'
     addBtn.onclick = async () => {
       await addDeviceToConfig(d)
     }
@@ -92,21 +242,177 @@ export async function renderDiscoveredDevices(devices: any[]): Promise<HTMLEleme
   return ul
 }
 
+/**
+ * Filter devices by connection type and search query
+ * @param devices Discovered devices array
+ * @param connectionType Filter: 'all' | 'ble' | 'api' | 'both' | 'ir'
+ * @param searchQuery Search term to match against name/id/type
+ * @returns Filtered devices array
+ */
+export function filterDevices(
+  devices: any[],
+  connectionType: 'all' | 'ble' | 'api' | 'both' | 'ir' = 'all',
+  searchQuery = '',
+): any[] {
+  let filtered = [...devices]
+
+  // Filter by connection type
+  if (connectionType !== 'all') {
+    filtered = filtered.filter(d => {
+      if (connectionType === 'ir') {
+        return d.isIR === true
+      }
+      if (connectionType === 'ble') {
+        return d.connectionType === 'BLE' || d.connectionType?.includes('BLE')
+      }
+      if (connectionType === 'api') {
+        return d.connectionType === 'OpenAPI' || d.connectionType === 'API' || d.connectionType?.includes('API')
+      }
+      if (connectionType === 'both') {
+        return d.connectionType === 'Both' || d.connectionType?.includes('Both')
+      }
+      return true
+    })
+  }
+
+  // Filter by search query
+  if (searchQuery.trim()) {
+    const query = searchQuery.toLowerCase()
+    filtered = filtered.filter(d => {
+      const name = (d.name || '').toLowerCase()
+      const id = (d.id || '').toLowerCase()
+      const type = (d.type || '').toLowerCase()
+      const model = (d.model || '').toLowerCase()
+      return name.includes(query) || id.includes(query) || type.includes(query) || model.includes(query)
+    })
+  }
+
+  return filtered
+}
+
+/**
+ * Sort devices by specified criteria
+ * @param devices Devices array to sort
+ * @param sortBy Sort criterion: 'name' | 'signal' | 'type' | 'connection'
+ * @returns Sorted devices array
+ */
+export function sortDevices(
+  devices: any[],
+  sortBy: 'name' | 'signal' | 'type' | 'connection' = 'name',
+): any[] {
+  const sorted = [...devices]
+
+  switch (sortBy) {
+    case 'signal': {
+      // Sort by RSSI descending (strongest signal first)
+      sorted.sort((a, b) => {
+        const aRssi = a.rssi || 0
+        const bRssi = b.rssi || 0
+        return bRssi - aRssi // Descending order (higher is stronger)
+      })
+      break
+    }
+    case 'type': {
+      // Sort by device type alphabetically
+      sorted.sort((a, b) => {
+        const aType = (a.type || '').localeCompare(b.type || '')
+        return aType
+      })
+      break
+    }
+    case 'connection': {
+      // Sort by connection type: Both > BLE > OpenAPI > Others
+      const connectionOrder: Record<string, number> = {
+        'Both': 0,
+        'BLE': 1,
+        'OpenAPI': 2,
+        'API': 2,
+        'Unknown': 3,
+      }
+      sorted.sort((a, b) => {
+        const aOrder = connectionOrder[a.connectionType || 'Unknown'] ?? 3
+        const bOrder = connectionOrder[b.connectionType || 'Unknown'] ?? 3
+        return aOrder - bOrder
+      })
+      break
+    }
+    case 'name':
+    default: {
+      // Sort by name alphabetically
+      sorted.sort((a, b) => (a.name || a.id || '').localeCompare(b.name || b.id || ''))
+      break
+    }
+  }
+
+  return sorted
+}
+
+/**
+ * Get filter/sort preferences from localStorage
+ * @returns Object with current filter and sort preferences
+ */
+export function getDiscoveryPreferences(): {
+  connectionType: 'all' | 'ble' | 'api' | 'both' | 'ir'
+  sortBy: 'name' | 'signal' | 'type' | 'connection'
+  searchQuery: string
+} {
+  try {
+    const stored = localStorage.getItem('discoveryPreferences')
+    if (stored) {
+      return JSON.parse(stored)
+    }
+  } catch (_e) {
+    // Ignore parse errors
+  }
+
+  return {
+    connectionType: 'all',
+    sortBy: 'name',
+    searchQuery: '',
+  }
+}
+
+/**
+ * Save filter/sort preferences to localStorage
+ * @param preferences Preferences object to save
+ */
+export function setDiscoveryPreferences(preferences: {
+  connectionType: 'all' | 'ble' | 'api' | 'both' | 'ir'
+  sortBy: 'name' | 'signal' | 'type' | 'connection'
+  searchQuery: string
+}): void {
+  try {
+    localStorage.setItem('discoveryPreferences', JSON.stringify(preferences))
+  } catch (_e) {
+    // Ignore storage errors
+  }
+}
+
 export function renderDeviceList(list: any[]): void {
   const ul = document.getElementById('devices')
   const status = document.getElementById('status')
+  const removeAllContainer = document.getElementById('removeAllContainer')
 
   if (!ul || !status) { return }
 
   if (!list.length) {
     status.textContent = 'No devices found in config.'
     ul.innerHTML = ''
+    // Hide remove all button when no devices
+    if (removeAllContainer) {
+      removeAllContainer.style.display = 'none'
+    }
     return
   }
 
   status.textContent = `Found ${list.length} device(s)`
   ul.innerHTML = ''
 
+  // Show remove all button when devices exist
+  if (removeAllContainer) {
+    removeAllContainer.style.display = 'block'
+  }
+
   for (const d of list) {
     const li = document.createElement('li')
     li.className = 'device-item'
@@ -114,6 +420,12 @@ export function renderDeviceList(list: any[]): void {
     const info = document.createElement('div')
     info.style.flex = '1'
 
+    const nameContainer = document.createElement('div')
+    nameContainer.style.display = 'flex'
+    nameContainer.style.alignItems = 'center'
+    nameContainer.style.flexWrap = 'wrap'
+    nameContainer.style.gap = '6px'
+
     const name = document.createElement('div')
     name.style.fontWeight = '500'
     name.textContent = d.name || d.id
@@ -124,6 +436,15 @@ export function renderDeviceList(list: any[]): void {
     code.style.opacity = '0.75'
     code.style.marginLeft = '8px'
 
+    nameContainer.appendChild(name)
+    nameContainer.appendChild(code)
+
+    // Add signal strength visualization if RSSI is available
+    if (d.rssi !== undefined && d.rssi !== null && d.rssi !== 0) {
+      nameContainer.appendChild(renderSignalBars(d.rssi))
+      nameContainer.appendChild(renderSignalQualityBadge(d.rssi))
+    }
+
     const meta = document.createElement('div')
     meta.style.opacity = '0.75'
     meta.style.marginTop = '4px'
@@ -134,8 +455,7 @@ export function renderDeviceList(list: any[]): void {
     const roomText = d.room ? `room: ${d.room}` : ''
     meta.textContent = [typeText, connText, roomText].filter(Boolean).join(' | ')
 
-    info.appendChild(name)
-    info.appendChild(code)
+    info.appendChild(nameContainer)
     info.appendChild(meta)
 
     const buttons = document.createElement('div')

package/src/homebridge-ui/utils/device-migration.ts

@@ -0,0 +1,144 @@
+import { DEVICE_TYPES, isValidDeviceType, normalizeDeviceType } from '../../device-types.js'
+
+export interface DeviceMigrationResult {
+  migrated: boolean
+  originalType: string | undefined
+  correctedType: string | null
+  message: string
+}
+
+/**
+ * Validate and optionally correct a device's configDeviceType
+ * @param device Device object from config
+ * @param autoCorrect Whether to auto-correct invalid types
+ * @returns Migration result with details
+ */
+export function validateAndMigrateDeviceType(
+  device: any,
+  autoCorrect = false,
+): DeviceMigrationResult {
+  const originalType = device.configDeviceType
+  const deviceId = device.deviceId || device.id || 'unknown'
+
+  // Check if type is valid
+  if (isValidDeviceType(originalType)) {
+    return {
+      migrated: false,
+      originalType,
+      correctedType: originalType,
+      message: `Device "${device.configDeviceName || deviceId}" type is valid`,
+    }
+  }
+
+  // Try to find a valid mapping
+  const correctedType = normalizeDeviceType(originalType)
+
+  if (!correctedType) {
+    return {
+      migrated: false,
+      originalType,
+      correctedType: null,
+      message: `Device "${device.configDeviceName || deviceId}" has invalid type "${originalType}" with no valid mapping`,
+    }
+  }
+
+  // Found a valid mapping
+  if (autoCorrect) {
+    device.configDeviceType = correctedType
+    return {
+      migrated: true,
+      originalType,
+      correctedType,
+      message: `Device "${device.configDeviceName || deviceId}" type auto-corrected: "${originalType}" → "${correctedType}"`,
+    }
+  } else {
+    return {
+      migrated: false,
+      originalType,
+      correctedType,
+      message: `Device "${device.configDeviceName || deviceId}" requires migration: "${originalType}" → "${correctedType}"`,
+    }
+  }
+}
+
+/**
+ * Validate all devices in config and optionally auto-correct invalid types
+ * @param config Configuration object containing devices array
+ * @param autoCorrect Whether to auto-correct invalid types
+ * @returns Array of migration results with statistics
+ */
+export function validateAndMigrateConfig(
+  config: any,
+  autoCorrect = false,
+): {
+  results: DeviceMigrationResult[]
+  statistics: {
+    total: number
+    valid: number
+    corrected: number
+    invalid: number
+  }
+  warnings: string[]
+} {
+  const results: DeviceMigrationResult[] = []
+  const warnings: string[] = []
+  let validCount = 0
+  let correctedCount = 0
+  let invalidCount = 0
+
+  if (!config?.devices || !Array.isArray(config.devices)) {
+    return {
+      results,
+      statistics: {
+        total: 0,
+        valid: 0,
+        corrected: 0,
+        invalid: 0,
+      },
+      warnings: ['No devices found in config'],
+    }
+  }
+
+  for (const device of config.devices) {
+    const result = validateAndMigrateDeviceType(device, autoCorrect)
+    results.push(result)
+
+    if (!result.originalType || isValidDeviceType(result.originalType)) {
+      validCount++
+    } else if (result.migrated) {
+      correctedCount++
+    } else if (result.correctedType) {
+      warnings.push(
+        `Device "${device.configDeviceName || device.deviceId}" needs correction: "${result.originalType}" → "${result.correctedType}"`,
+      )
+      invalidCount++
+    } else {
+      invalidCount++
+      warnings.push(
+        `Device "${device.configDeviceName || device.deviceId}" has INVALID type "${result.originalType}" with no mapping`,
+      )
+    }
+  }
+
+  // Validation complete - results and warnings are returned via return value
+  // Caller (config endpoint) will handle logging/reporting
+
+  return {
+    results,
+    statistics: {
+      total: config.devices.length,
+      valid: validCount,
+      corrected: correctedCount,
+      invalid: invalidCount,
+    },
+    warnings,
+  }
+}
+
+/**
+ * Get list of all valid device types for error messages
+ * @returns Array of valid device types grouped by category
+ */
+export function getValidDeviceTypesList(): Record<string, readonly string[]> {
+  return DEVICE_TYPES
+}

package/src/platform.ts

@@ -1127,7 +1127,7 @@ export class SwitchBotHAPPlatform {
             let accessory: any = this.accessories.get(uuid)
             // If not found by uuid, attempt to find by stored deviceId in accessory.context
             if (!accessory) {
-              for (const [, a] of Array.from(this.accessories.entries())) {
+              for (const [, a] of this.accessories.entries()) {
                 try {
                   if (a && a.context && a.context.deviceId === d.id) {
                     accessory = a
@@ -1486,7 +1486,7 @@ export class SwitchBotMatterPlatform {
         const uuid = matterApi.uuid.generate(`${d.id}`)
         // Try to find existing restored accessory by deviceId
         let existing: any | undefined
-        for (const [, a] of Array.from(this.accessories.entries())) {
+        for (const [, a] of this.accessories.entries()) {
           try {
             if (a && a.context && a.context.deviceId === d.id) {
               existing = a