@switchbot/homebridge-switchbot 5.0.0-beta.34 → 5.0.0-beta.36

package/src/platform-matter.ts

@@ -42,7 +42,7 @@ import {
   WindowBlindAccessory,
 } from './devices-matter/index.js'
 import { PLATFORM_NAME, PLUGIN_NAME } from './settings.js'
-import { ApiRequestTracker, cleanDeviceConfig, createPlatformLogger, formatDeviceIdAsMac, hs2rgb, isSuccessfulStatusCode, makeBLESender, makeOpenAPISender, mergeByDeviceId, normalizeDeviceId, rgb2hs, sleep } from './utils.js'
+import { ApiRequestTracker, applyDeviceTypeTemplates, createPlatformLogger, formatDeviceIdAsMac, hs2rgb, isSuccessfulStatusCode, makeBLESender, makeOpenAPISender, mergeByDeviceId, normalizeDeviceId, rgb2hs, sleep } from './utils.js'
 
 export class SwitchBotMatterPlatform implements DynamicPlatformPlugin {
   // Track restored HAP cached accessories (required for DynamicPlatformPlugin)
@@ -130,19 +130,8 @@ export class SwitchBotMatterPlatform implements DynamicPlatformPlugin {
 
     this.debugLog('Finished initializing platform:', this.config.name)
 
-    // Normalize deviceConfig to remove UI-inserted defaults
-    try {
-      if ((this.config as any).options) {
-        const cleaned = cleanDeviceConfig((this.config as any).options.deviceConfig)
-        if (cleaned) {
-          ;(this.config as any).options.deviceConfig = cleaned
-        } else {
-          delete (this.config as any).options.deviceConfig
-        }
-      }
-    } catch (e) {
-      this.debugLog('Failed to clean deviceConfig: %s', e)
-    }
+    // Note: deviceConfig and irdeviceConfig have been removed from the platform.
+    // All device-specific configuration should be done via options.devices arrays.
 
     // Does the user have a version of Homebridge that is compatible with matter?
     if (!this.api.isMatterAvailable?.()) {
@@ -419,56 +408,37 @@ export class SwitchBotMatterPlatform implements DynamicPlatformPlugin {
   }
 
   /**
-   * Merge two arrays by deviceId. For each item in a1 (user-provided devices list),
-   * find matching item in a2 (discovered devices) and merge them with user overrides last.
-   * @deprecated Use shared mergeByDeviceId from utils.js instead
-   */
-  private mergeByDeviceId(a1: { deviceId: string }[], a2: any[]) {
-    const allowConfigOnly = Boolean(this.config.options?.allowConfigOnlyDevices)
-    return mergeByDeviceId(a1, a2, allowConfigOnly)
-  }
-
-  /**
-   * Merge discovered devices with deviceConfig (per deviceType) and per-device overrides
-   * from `config.options.devices`, matching the behavior used in platform-hap.
+   * Merge discovered devices with per-device overrides from `config.options.devices`.
+   * Also applies device-type templates when applyToAllDevicesOfType is set.
    */
   private async mergeDiscoveredDevices(discovered: device[]): Promise<any[]> {
-    // If there's no device config or per-device config, return discovered as-is
-    if (!this.config.options?.devices && !this.config.options?.deviceConfig) {
+    // If there's no per-device config, return discovered as-is
+    if (!this.config.options?.devices) {
       return discovered
     }
 
-    // Step 1: Assign missing deviceType from configDeviceType and merge deviceType-level configs
-    const devicesWithTypeConfig = await Promise.all(discovered.map(async (deviceObj) => {
+    // Assign missing deviceType from configDeviceType if needed
+    const devicesWithTypeAssigned = discovered.map((deviceObj) => {
       if (!deviceObj.deviceType) {
         deviceObj.deviceType = (deviceObj as any).configDeviceType !== undefined ? (deviceObj as any).configDeviceType : 'Unknown'
         this.debugLog(`API missing deviceType for ${deviceObj.deviceId}, using configDeviceType: ${(deviceObj as any).configDeviceType}`)
       }
-      const deviceTypeConfig = this.config.options?.deviceConfig?.[deviceObj.deviceType] || {}
-      return Object.assign({}, deviceObj, deviceTypeConfig)
-    }))
-
-    // Merge per-device overrides by matching deviceId
-    const merged = this.mergeByDeviceId(this.config.options?.devices ?? [], devicesWithTypeConfig ?? [])
+      return deviceObj
+    })
 
-    // For any entries in merged (which are based on config.options.devices), ensure final per-device merges include deviceId-specific config
-    const final: any[] = []
-    for (const device of merged) {
-      // Find per-device config entry by deviceId (config.options.devices is an array)
-      const deviceIdConfig = (this.config.options?.devices || []).find((d: any) => this.normalizeDeviceId(d.deviceId) === this.normalizeDeviceId(device.deviceId)) || {}
-      const deviceWithConfig = Object.assign({}, device, deviceIdConfig)
-      final.push(deviceWithConfig)
-    }
+    // Apply device-type templates from config entries with applyToAllDevicesOfType=true
+    const devicesWithTemplates = applyDeviceTypeTemplates(
+      devicesWithTypeAssigned,
+      this.config.options.devices,
+      'deviceType',
+      msg => this.debugLog(msg),
+    )
 
-    // Also include any discovered devices that weren't present in the user devices list
-    const userDeviceIds = new Set((this.config.options?.devices || []).map((d: any) => this.normalizeDeviceId(d.deviceId)))
-    for (const d of devicesWithTypeConfig) {
-      if (!userDeviceIds.has(this.normalizeDeviceId(d.deviceId))) {
-        final.push(d)
-      }
-    }
+    // Merge per-device overrides by matching deviceId
+    const allowConfigOnly = Boolean(this.config.options?.allowConfigOnlyDevices)
+    const merged = mergeByDeviceId(this.config.options?.devices ?? [], devicesWithTemplates ?? [], allowConfigOnly)
 
-    return final
+    return merged
   }
 
   /**
@@ -1714,10 +1684,6 @@ export class SwitchBotMatterPlatform implements DynamicPlatformPlugin {
    * Register all Matter accessories
    */
   private async registerMatterAccessories() {
-    this.debugLog('═'.repeat(80))
-    this.infoLog('Homebridge Matter Plugin')
-    this.debugLog('═'.repeat(80))
-
     // Remove accessories that are disabled in config
     await this.removeDisabledAccessories()
 

package/src/settings.ts

@@ -32,9 +32,7 @@ interface credentials {
 
 export interface options {
   devices?: devicesConfig[]
-  deviceConfig?: { [deviceType: string]: devicesConfig }
   irdevices?: irDevicesConfig[]
-  irdeviceConfig?: { [remoteType: string]: irDevicesConfig }
   allowInvalidCharacters?: boolean
   // When true, devices declared in config.options.devices that are not
   // discovered via the SwitchBot OpenAPI will still be included (config-only
@@ -100,6 +98,12 @@ export interface BaseDeviceConfig extends device {
   mqttPubOptions?: IClientOptions
   history?: boolean
   webhook?: boolean
+  /**
+   * When true, applies this device's configuration to all other devices
+   * of the same deviceType/configDeviceType (e.g., all Humidifiers).
+   * Specific per-device settings will override these template settings.
+   */
+  applyToAllDevicesOfType?: boolean
 }
 
 export interface botConfig extends BaseDeviceConfig {
@@ -259,6 +263,12 @@ export interface irBaseDeviceConfig extends irdevice {
   logging?: string
   customOn?: string
   customOff?: string
+  /**
+   * When true, applies this IR device's configuration to all other IR devices
+   * of the same remoteType/configRemoteType (e.g., all IR Fans).
+   * Specific per-device settings will override these template settings.
+   */
+  applyToAllDevicesOfType?: boolean
   customize?: boolean
   commandType?: string
   disablePushOn?: boolean

package/src/utils.ts

@@ -672,55 +672,6 @@ export function m2hs(m) {
   return [Math.round(toReturn[1]), Math.round(toReturn[0])]
 }
 
-/**
- * Remove deviceConfig entries that contain only default/empty values.
- * Returns undefined if nothing meaningful remains.
- */
-export function cleanDeviceConfig(deviceConfig?: Record<string, Record<string, any>>): Record<string, Record<string, any>> | undefined {
-  if (!deviceConfig || typeof deviceConfig !== 'object') {
-    return undefined
-  }
-
-  const cleaned: Record<string, Record<string, any>> = {}
-
-  for (const [deviceName, cfg] of Object.entries(deviceConfig)) {
-    if (!cfg || typeof cfg !== 'object') {
-      continue
-    }
-
-    const hasMeaningful = Object.values(cfg).some((v) => {
-      if (v === null || v === undefined) {
-        return false
-      }
-      if (typeof v === 'boolean') {
-        return v === true
-      }
-      if (typeof v === 'string') {
-        return v.trim().length > 0
-      }
-      if (typeof v === 'number') {
-        return Number.isFinite(v)
-      }
-      if (Array.isArray(v)) {
-        return v.length > 0
-      }
-      if (typeof v === 'object') {
-        return Object.keys(v).length > 0
-      }
-      return true
-    })
-
-    if (hasMeaningful) {
-      cleaned[deviceName] = cfg
-    }
-  }
-
-  if (Object.keys(cleaned).length > 0) {
-    return cleaned
-  }
-  return undefined
-}
-
 /**
  * Factory that returns a function to send OpenAPI commands using a retry wrapper.
  *
@@ -1157,6 +1108,67 @@ export function mergeByDeviceId(a1: { deviceId: string }[], a2: any[], allowConf
   return result
 }
 
+/**
+ * Apply device-type or remote-type templates to an array of devices.
+ * Templates are config entries with applyToAllDevicesOfType=true.
+ *
+ * @param devices - Array of devices to apply templates to
+ * @param configDevices - User config array that may contain template entries
+ * @param typeKey - Property name to match device types ('deviceType' for devices, 'remoteType' for IR devices)
+ * @param debugLog - Optional debug logging function
+ * @returns Array of devices with templates applied
+ */
+export function applyDeviceTypeTemplates(
+  devices: any[],
+  configDevices: any[],
+  typeKey: string,
+  debugLog?: (message: string) => void,
+): any[] {
+  // Build a map of device-type templates from config devices with applyToAllDevicesOfType=true
+  const typeTemplates = new Map<string, any>()
+
+  for (const configDevice of configDevices || []) {
+    if (configDevice.applyToAllDevicesOfType) {
+      // Get the type value from multiple possible sources
+      const deviceType = configDevice[typeKey] || (configDevice as any).configDeviceType || (configDevice as any).configRemoteType
+      if (!deviceType) {
+        continue
+      }
+
+      // Store all config properties except deviceId and applyToAllDevicesOfType flag
+      const template: any = { ...configDevice }
+      delete template.deviceId
+      delete template.applyToAllDevicesOfType
+
+      typeTemplates.set(deviceType, template)
+      if (debugLog) {
+        debugLog(`Device type template found for '${deviceType}': ${JSON.stringify(template)}`)
+      }
+    }
+  }
+
+  // If no templates found, return original array
+  if (typeTemplates.size === 0) {
+    return devices
+  }
+
+  // Apply templates to devices
+  return devices.map((device) => {
+    const deviceType = device[typeKey] || (device as any).configDeviceType || (device as any).configRemoteType
+    const template = typeTemplates.get(deviceType)
+
+    if (template) {
+      if (debugLog) {
+        debugLog(`Applying device type template to ${device.deviceId} (${deviceType})`)
+      }
+      // Template settings go first, then device data (device data takes precedence)
+      return Object.assign({}, template, device)
+    }
+
+    return device
+  })
+}
+
 /**
  * Check if an API status code indicates success
  */