node-red-contrib-knx-ultimate 5.2.4 → 6.0.0

package/nodes/utils/lightEngines/matterLightEngine.js

@@ -0,0 +1,117 @@
+'use strict'
+const { LightEngine } = require('./lightEngine')
+const { CLUSTER, matterToKnx } = require('../matterKnxConverter')
+const { clampByte, kelvinToMired, rgbToHsv } = require('./canonicalLight')
+
+// Standard "options" arguments required by several Matter cluster commands.
+const LEVEL_OPTS = { optionsMask: {}, optionsOverride: {} }
+
+// Matter speaks DISCRETE, per-cluster commands, so a single canonical patch
+// DECOMPOSES into N writeMatterQueueAdd calls (on + moveToLevel + colour...).
+// This engine wraps matter-config's matterManager (the controller), NOT the
+// generic Matter controller paths.
+class MatterLightEngine extends LightEngine {
+  constructor (opts = {}) {
+    super(opts)
+    this.manager = opts.manager // matter-config's matterManager (writeMatterQueueAdd)
+    this.nodeId = opts.nodeId !== undefined ? opts.nodeId : opts.deviceId // commissioned Matter node id
+    this.endpointId = opts.endpointId !== undefined ? opts.endpointId : 1
+  }
+
+  get kind () { return 'matter' }
+
+  capabilities () {
+    // No native "effects" (candle/fire/prism) equivalent -> node emulates or skips.
+    return { onOff: true, dimming: true, colorTemp: true, color: true, effects: false }
+  }
+
+  translate (patch) {
+    const ops = []
+    if (patch.on !== undefined) {
+      ops.push({ clusterId: CLUSTER.ON_OFF, kind: 'command', name: patch.on ? 'on' : 'off', args: undefined })
+    }
+    if (patch.brightnessPct !== undefined) {
+      ops.push({
+        clusterId: CLUSTER.LEVEL_CONTROL,
+        kind: 'command',
+        name: 'moveToLevelWithOnOff',
+        args: { level: clampByte(Number(patch.brightnessPct) * 254 / 100, 254), transitionTime: 0, ...LEVEL_OPTS }
+      })
+    }
+    if (patch.colorTempK !== undefined) {
+      ops.push({
+        clusterId: CLUSTER.COLOR_CONTROL,
+        kind: 'command',
+        name: 'moveToColorTemperature',
+        args: { colorTemperatureMireds: kelvinToMired(patch.colorTempK), transitionTime: 0, ...LEVEL_OPTS }
+      })
+    }
+    if (patch.rgb !== undefined) {
+      const { h, s } = rgbToHsv(patch.rgb)
+      ops.push({
+        clusterId: CLUSTER.COLOR_CONTROL,
+        kind: 'command',
+        name: 'moveToHue',
+        args: { hue: clampByte(h * 254 / 360, 254), direction: 0, transitionTime: 0, ...LEVEL_OPTS }
+      })
+      ops.push({
+        clusterId: CLUSTER.COLOR_CONTROL,
+        kind: 'command',
+        name: 'moveToSaturation',
+        args: { saturation: clampByte(s * 254, 254), transitionTime: 0, ...LEVEL_OPTS }
+      })
+    }
+    return ops
+  }
+
+  applyState (patch) {
+    const issued = []
+    let ops = []
+    try {
+      ops = this.translate(patch)
+    } catch (error) {
+      ops = []
+    }
+    ops.forEach((op) => {
+      const item = {
+        nodeId: this.nodeId,
+        endpointId: this.endpointId,
+        clusterId: op.clusterId,
+        kind: op.kind,
+        name: op.name,
+        args: op.args
+      }
+      try {
+        if (this.manager && typeof this.manager.writeMatterQueueAdd === 'function') {
+          const ret = this.manager.writeMatterQueueAdd(item)
+          // writeMatterQueueAdd is async: swallow a late rejection so this
+          // fire-and-forget call can never become an unhandled rejection (process crash).
+          if (ret && typeof ret.catch === 'function') ret.catch(() => { })
+        }
+      } catch (error) { /* one failed write must never break the batch */ }
+      issued.push({ api: 'writeMatterQueueAdd', ...item })
+    })
+    return issued
+  }
+
+  // Matter attribute report -> canonical patch. Reuses matterToKnx value scaling
+  // (currentLevel -> percent, colorTemperatureMireds -> kelvin, onOff -> bool).
+  parseIncoming (event) {
+    try {
+      if (!event) return null
+      if (event.nodeId !== undefined && this.nodeId !== undefined && event.nodeId !== this.nodeId) return null
+      const value = matterToKnx(Number(event.clusterId), event.attributeName, event.value)
+      if (value === undefined) return null
+      switch (event.attributeName) {
+        case 'onOff': return { on: !!value }
+        case 'currentLevel': return { brightnessPct: Number(value) }
+        case 'colorTemperatureMireds': return { colorTempK: Number(value) }
+        default: return null
+      }
+    } catch (error) {
+      return null
+    }
+  }
+}
+
+module.exports = { MatterLightEngine }

package/nodes/utils/matterEngine.mjs

@@ -1,7 +1,23 @@
 /* eslint-disable max-len */
 import { EventEmitter } from 'events'
+import dns from 'dns/promises'
 import { setTimeout as pleaseWait } from 'timers/promises'
 
+// Last 4 hex chars of an id-ish string (serial, uniqueId, mDNS name...), uppercased.
+// Used to disambiguate identical device names (Shelly encode the MAC in the serial).
+const shortHexSuffix = (value) => {
+  if (value === undefined || value === null) return ''
+  const hex = String(value).replace(/[^0-9a-fA-F]/g, '')
+  if (hex.length >= 4) return hex.slice(-4).toUpperCase()
+  const alnum = String(value).replace(/[^0-9a-zA-Z]/g, '')
+  return alnum.length >= 4 ? alnum.slice(-4).toUpperCase() : alnum.toUpperCase()
+}
+
+const normalizeHostForCompare = (value) => {
+  if (value === undefined || value === null) return ''
+  return String(value).trim().toLowerCase().replace(/^\[/, '').replace(/\]$/, '').split('%')[0]
+}
+
 // Wrapper around the matter.js CommissioningController.
 // It mirrors the contract of hueEngine.mjs: an EventEmitter with a command queue,
 // emitting 'connected', 'disconnected', 'event' (attribute changes), 'matterEvent' (cluster events),
@@ -54,15 +70,90 @@ class classMatter extends EventEmitter {
   _loadApi = async () => {
     if (this._api !== null) return this._api
     const { Environment, StorageService, Logger, LogLevel } = await import('@matter/main')
+    const { Seconds } = await import('@matter/general')
     const { CommissioningController, NodeStates } = await import('@project-chip/matter.js')
     const { ManualPairingCodeCodec, QrPairingCodeCodec, NodeId } = await import('@matter/main/types')
-    const { GeneralCommissioning } = await import('@matter/main/clusters')
+    const { BasicInformation, GeneralCommissioning } = await import('@matter/main/clusters')
     this._api = {
-      Environment, StorageService, Logger, LogLevel, CommissioningController, NodeStates, ManualPairingCodeCodec, QrPairingCodeCodec, NodeId, GeneralCommissioning
+      Environment, StorageService, Logger, LogLevel, Seconds, CommissioningController, NodeStates, ManualPairingCodeCodec, QrPairingCodeCodec, NodeId, BasicInformation, GeneralCommissioning
     }
     return this._api
   }
 
+  _resolveTargetHosts = async (_targetHost) => {
+    const host = normalizeHostForCompare(_targetHost)
+    if (host === '') return []
+    const ret = new Set([host])
+    try {
+      const entries = await dns.lookup(host, { all: true })
+      entries.forEach((entry) => {
+        const address = normalizeHostForCompare(entry.address)
+        if (address !== '') ret.add(address)
+      })
+    } catch (error) { /* Host may already be an IP or only resolvable by Matter/mDNS. */ }
+    return Array.from(ret)
+  }
+
+  _deviceHasTargetHost = (device, targetHosts) => {
+    if (!Array.isArray(targetHosts) || targetHosts.length === 0) return false
+    try {
+      return (device.addresses || []).some((address) => targetHosts.includes(normalizeHostForCompare(address.ip)))
+    } catch (error) {
+      return false
+    }
+  }
+
+  _discoverCommissionableDeviceAtHost = async (identifierData, discoveryCapabilities, targetHost) => {
+    const targetHosts = await this._resolveTargetHosts(targetHost)
+    if (targetHosts.length === 0) return undefined
+    const devices = await this.controller.discoverCommissionableDevices(
+      identifierData,
+      discoveryCapabilities,
+      undefined,
+      this._api.Seconds(20)
+    )
+    return devices.find((device) => this._deviceHasTargetHost(device, targetHosts))
+  }
+
+  _buildKnownAddressDiscoveryAttempts = (identifierData, discoveryCapabilities, targetHost) => {
+    const host = normalizeHostForCompare(targetHost)
+    if (host === '') return []
+    // Matter devices normally listen for commissioning on UDP/5540. Shelly's HTTP RPC
+    // gives us the device IP, not its mDNS service port, so try the standard PASE port
+    // before falling back to mDNS-filtered discovery.
+    return [{
+      identifierData,
+      discoveryCapabilities,
+      knownAddress: {
+        ip: host,
+        port: 5540,
+        type: 'udp'
+      }
+    }, {
+      identifierData,
+      discoveryCapabilities,
+      knownAddress: {
+        ip: host,
+        port: 5540
+      }
+    }]
+  }
+
+  _allocateCommissionNodeId = () => {
+    const commissioned = new Set()
+    try {
+      this.controller.getCommissionedNodes().forEach((nodeId) => commissioned.add(nodeId.toString()))
+    } catch (error) { /* empty */ }
+    try {
+      if (this.controller.nodeId !== undefined) commissioned.add(this.controller.nodeId.toString())
+    } catch (error) { /* empty */ }
+    for (let index = 0; index < 100; index++) {
+      const nodeId = this._api.NodeId.randomOperationalNodeId(this.controller.crypto)
+      if (!commissioned.has(nodeId.toString())) return nodeId
+    }
+    throw new Error('Unable to allocate a free Matter Node ID for commissioning')
+  }
+
   nodeStateToString = (state) => {
     try {
       const { NodeStates } = this._api
@@ -164,13 +255,14 @@ class classMatter extends EventEmitter {
   }
 
   // Commission (pair) a new device using an 11-digit manual pairing code or a QR code string (MT:...)
-  commission = async (_pairingCode) => {
+  commission = async (_pairingCode, _options = {}) => {
     if (this.controller === null) throw new Error('Matter controller not started')
     const api = await this._loadApi()
     const code = (_pairingCode || '').toString().trim()
     if (code === '') throw new Error('Empty pairing code')
     let passcode
     let identifierData
+    const discoveryCapabilities = { onIpNetwork: true }
     if (code.toUpperCase().startsWith('MT:')) {
       const qr = api.QrPairingCodeCodec.decode(code)[0]
       passcode = qr.passcode
@@ -180,16 +272,65 @@ class classMatter extends EventEmitter {
       passcode = manual.passcode
       identifierData = { shortDiscriminator: manual.shortDiscriminator }
     }
-    const nodeId = await this.controller.commissionNode({
-      commissioning: {
-        regulatoryLocation: api.GeneralCommissioning.RegulatoryLocationType.IndoorOutdoor
-      },
-      discovery: {
+    let nodeId
+    try {
+      const commissioningNodeId = this._allocateCommissionNodeId()
+      this._log('info', `classMatter: commission: using Node ID ${commissioningNodeId.toString()} for new device`)
+      let discovery = {
         identifierData,
-        discoveryCapabilities: { onIpNetwork: true }
-      },
-      passcode
-    }, { connectNodeAfterCommissioning: false })
+        discoveryCapabilities
+      }
+      const targetHost = (_options?.targetHost || '').toString().trim()
+      if (targetHost !== '') {
+        const commissionableDevice = await this._discoverCommissionableDeviceAtHost(identifierData, discoveryCapabilities, targetHost)
+        discovery = commissionableDevice !== undefined
+          ? {
+              commissionableDevice,
+              discoveryCapabilities
+            }
+          : undefined
+      }
+      const discoveryAttempts = discovery !== undefined
+        ? [discovery]
+        : this._buildKnownAddressDiscoveryAttempts(identifierData, discoveryCapabilities, targetHost)
+      let lastError
+      for (const discoveryAttempt of discoveryAttempts) {
+        try {
+          nodeId = await this.controller.commissionNode({
+            commissioning: {
+              nodeId: commissioningNodeId,
+              regulatoryLocation: api.GeneralCommissioning.RegulatoryLocationType.IndoorOutdoor
+            },
+            discovery: discoveryAttempt,
+            passcode
+          }, { connectNodeAfterCommissioning: false })
+          lastError = undefined
+          break
+        } catch (error) {
+          lastError = error
+        }
+      }
+      if (nodeId === undefined) {
+        if (targetHost !== '' && discoveryAttempts.length > 0) {
+          throw new Error(`No commissionable Matter device matching this pairing code could be commissioned at ${targetHost}. Direct PASE on UDP/5540 and mDNS discovery both failed.${lastError ? ` Last error: ${lastError.message || lastError}` : ''}`)
+        }
+        throw lastError || new Error('Matter commissioning failed')
+      }
+    } catch (error) {
+      // The 11-digit MANUAL code carries only the 4-bit short discriminator, so several
+      // identical devices (e.g. same-model Shelly) look alike to discovery: it can reach
+      // the WRONG one — typically the first, already-commissioned device — and fail with a
+      // "node ID already commissioned" conflict. Point the user to the QR code.
+      const msg = String((error && error.message) || error)
+      const isManual = !code.toUpperCase().startsWith('MT:')
+      if (/already commissioned|can not be reused/i.test(msg)) {
+        throw new Error(`${msg} — the commissioner reached a device that is ALREADY paired to this controller.${isManual ? ' The MANUAL code can reach the wrong identical device (short discriminator): use the QR code (MT:...) to target the exact one.' : ''} If you really mean this device, factory-reset it (or unpair that node) and try again. Pair one device at a time.`)
+      }
+      if (isManual) {
+        throw new Error(`${msg} — tip: the MANUAL code can't tell identical devices apart (short discriminator). Use the QR code (MT:...) for a precise match, pair one device at a time, and factory-reset the device if it is already commissioned elsewhere.`)
+      }
+      throw error
+    }
     try {
       await this._attachNode(nodeId)
     } catch (error) {
@@ -234,7 +375,7 @@ class classMatter extends EventEmitter {
       try {
         const key = detail.nodeId.toString()
         const node = this.pairedNodes.get(key)
-        let basicInfo = detail.basicInformationData || {}
+        let basicInfo = detail.basicInformationData || detail.deviceData?.basicInformation || {}
         try {
           if (node !== undefined && node.basicInformation !== undefined) basicInfo = node.basicInformation
         } catch (error) { /* empty */ }
@@ -242,9 +383,21 @@ class classMatter extends EventEmitter {
         try {
           if (node !== undefined) connectionState = this.nodeStateToString(node.connectionState)
         } catch (error) { /* empty */ }
+        // Name: prefer the user-assigned label; otherwise fall back to the model and
+        // append a short unique suffix so identical devices (e.g. several Shelly of the
+        // same model) are distinguishable. Shelly expose their MAC in the serial number,
+        // so its last 4 hex chars are effectively the "last 4 of the MAC" other apps show.
+        const userLabel = basicInfo.nodeLabel || basicInfo.productLabel
+        const baseName = userLabel || basicInfo.productName || detail.advertisedName || `Node ${key}`
+        let displayName = baseName
+        if (!userLabel) {
+          const idSource = basicInfo.serialNumber || basicInfo.uniqueId || detail.advertisedName || key
+          const suffix = shortHexSuffix(idSource)
+          if (suffix && !baseName.toUpperCase().includes(suffix)) displayName = `${baseName} (${suffix})`
+        }
         retArray.push({
           nodeId: key,
-          name: basicInfo.nodeLabel || basicInfo.productLabel || basicInfo.productName || detail.advertisedName || `Node ${key}`,
+          name: displayName,
           vendorName: basicInfo.vendorName || '',
           productName: basicInfo.productName || '',
           serialNumber: basicInfo.serialNumber || '',
@@ -399,6 +552,24 @@ class classMatter extends EventEmitter {
     }
   }
 
+  renameNode = async (_nodeIdString, _label) => {
+    const label = (_label || '').toString().trim()
+    if (label === '') throw new Error('Empty Matter device name')
+    if (label.length > 64) throw new Error('Matter device name is too long')
+    const node = this.pairedNodes.get(_nodeIdString)
+    if (node === undefined) throw new Error(`Matter node ${_nodeIdString} unknown or not yet connected`)
+    let clusterClient
+    try {
+      if (typeof node.getRootClusterClient === 'function') clusterClient = node.getRootClusterClient(this._api.BasicInformation)
+    } catch (error) { /* empty */ }
+    if (clusterClient === undefined) clusterClient = this._findClusterClient(node, 0, 40) // BasicInformation on the root endpoint
+    if (clusterClient === undefined) throw new Error(`BasicInformation cluster not found on node ${_nodeIdString}`)
+    const attribute = clusterClient.attributes.nodeLabel
+    if (attribute === undefined) throw new Error(`nodeLabel attribute not found on node ${_nodeIdString}`)
+    await attribute.set(label)
+    return label
+  }
+
   _enqueueCommand = (command) => {
     if (!command) return false
     if (!Array.isArray(this.commandQueue)) this.commandQueue = []

package/nodes/utils/matterKnxConverter.js

@@ -1,6 +1,6 @@
 /* eslint-disable max-len */
 // Value conversions between KNX (decoded DPT payloads) and Matter clusters.
-// Used by knxUltimateMatterDevice to translate group address payloads into Matter
+// Used by the Matter controller nodes to translate group address payloads into Matter
 // commands/attribute-writes and Matter attribute reports into KNX payloads.
 
 // Matter cluster IDs

package/package.json

@@ -3,7 +3,7 @@
   "engines": {
     "node": ">=20.18.1"
   },
-  "version": "5.2.4",
+  "version": "6.0.0",
   "description": "Control your KNX and KNX Secure intallation via Node-Red! A bunch of KNX nodes, with integrated Philips HUE control, ETS group address importer, KNX AI for diagnosticsand KNX routing between interfaces. Easy to use and highly configurable.",
   "files": [
     "nodes/",
@@ -55,6 +55,7 @@
       "knxUltimate-config": "/nodes/knxUltimate-config.js",
       "hueConfig": "/nodes/hue-config.js",
       "knxUltimateHueLight": "/nodes/knxUltimateHueLight.js",
+      "knxUltimateMatterControllerDevice": "/nodes/knxUltimateMatterControllerDevice.js",
       "knxUltimateHueButton": "/nodes/knxUltimateHueButton.js",
       "knxUltimateHueMotion": "/nodes/knxUltimateHueMotion.js",
       "knxUltimateHueAreaMotion": "/nodes/knxUltimateHueAreaMotion.js",
@@ -71,7 +72,6 @@
       "knxUltimateHueHumiditySensor": "/nodes/knxUltimateHueHumiditySensor.js",
       "knxUltimateHueCameraMotion": "/nodes/knxUltimateHueCameraMotion.js",
       "matter-config": "/nodes/matter-config.js",
-      "knxUltimateMatterDevice": "/nodes/knxUltimateMatterDevice.js",
       "matterbridge-config": "/nodes/matterbridge-config.js",
       "knxUltimateMatterBridge": "/nodes/knxUltimateMatterBridge.js"
     }
@@ -82,12 +82,22 @@
   },
   "keywords": [
     "node-red",
+    "node-red-contrib",
     "KNX",
+    "knx-secure",
     "ETS",
     "eib",
     "konnex",
     "IOT",
-    "philips hue"
+    "philips hue",
+    "hue",
+    "matter",
+    "mqtt",
+    "home-assistant",
+    "building-automation",
+    "home-automation",
+    "smarthome",
+    "routing"
   ],
   "author": "Massimo Saccani (Supergiovane)",
   "license": "MIT",
@@ -97,6 +107,14 @@
     "prepublishOnly": "npm run build",
     "test": "DEBUG_KNX_HUE_TEST=0 npm run test:unit && node scripts/check-node-load.js",
     "test:unit": "mocha \"test/**/*.test.js\"",
+    "avviaquesto-itest:light": "node test/integration/hueLiveTest.mjs",
+    "avviaquesto-itest:matterlight": "node test/integration/matterLiveTest.mjs",
+    "avviaquesto-itest:nodered-knx": "node test/integration/nodeRedLiveTest.mjs",
+    "avviaquesto-itest:nodered-matter": "node test/integration/nodeRedLiveTest.mjs --matter",
+    "avviaquesto-itest:knxbus": "node test/integration/knxLightTest.js",
+    "avviaquesto-itest:buildflow": "node test/integration/buildTestFlow.js",
+    "avviaquesto-itest:serve": "node test/integration/serveFlow.mjs",
+    "lint:fix": "standard --fix",
     "lint-fix": "standard --fix",
     "knx-ai:dev": "vite --config ui/knxUltimateAI-vue/vite.config.mjs",
     "knx-ai:build": "vite build --config ui/knxUltimateAI-vue/vite.config.mjs",

package/resources/KNXSendSnippets.js

@@ -1,9 +1,9 @@
 ; (function (root) {
-    const KNXSendSnippets = [
-        {
-            id: 'status-ga-check',
-            title: 'Status GA check',
-            code: `// @ts-nocheck
+  const KNXSendSnippets = [
+    {
+      id: 'status-ga-check',
+      title: 'Status GA check',
+      code: `// @ts-nocheck
 // Replace '' with the real status group address.
 const statusGA = await getGAValue('','1.001');
 if (msg.payload !== statusGA){ // " !==" means " not equal"
@@ -13,21 +13,21 @@ if (msg.payload !== statusGA){ // " !==" means " not equal"
     node.status({fill:"grey",shape:"dot",text:"Not sent"}); 
     return; 
 }`
-        },
-        {
-            id: 'toggle-value-no-check',
-            title: 'Toggle value (without status check)',
-            code: `// @ts-nocheck
+    },
+    {
+      id: 'toggle-value-no-check',
+      title: 'Toggle value (without status check)',
+      code: `// @ts-nocheck
 // After 5000 milliseconds, toggle.
 setTimeout(function() {
     toggle();
 }, 5000);
 return msg;`
-        },
-        {
-            id: 'toggle-value-with-check',
-            title: 'Toggle value (with status check)',
-            code: `// @ts-nocheck
+    },
+    {
+      id: 'toggle-value-with-check',
+      title: 'Toggle value (with status check)',
+      code: `// @ts-nocheck
 // Get the current value of the status GA. insert the actual STATUS GA here.
 let prevValue = await getGAValue('InsertHereTheStatusGA', '1.001')
 if (prevValue === null)
@@ -39,31 +39,31 @@ if (prevValue === null)
     // Otherwise, toggles the value
     self(!prevValue);
 }`
-        },
-        {
-            id: 'send-false-delay',
-            title: 'Send false after 5 secs',
-            code: `// @ts-nocheck
+    },
+    {
+      id: 'send-false-delay',
+      title: 'Send false after 5 secs',
+      code: `// @ts-nocheck
 // After 5000 milliseconds, send false.
 setTimeout(function () {
     self(false);
 }, 5000);
 return msg;`
-        },
-        {
-            id: 'send-20-percent-other-ga',
-            title: 'Send 20% to another GA',
-            code: `// @ts-nocheck
+    },
+    {
+      id: 'send-20-percent-other-ga',
+      title: 'Send 20% to another GA',
+      code: `// @ts-nocheck
 // Send 20% to the GA 1/0/1 having DPT 5.001
 if (msg.payload === true){
     setGAValue('1/0/1',20,'5.001') 
 }
 return msg;`
-        },
-        {
-            id: 'motion-activated-light',
-            title: 'Turn on light on motion, auto off',
-            code: `// @ts-nocheck
+    },
+    {
+      id: 'motion-activated-light',
+      title: 'Turn on light on motion, auto off',
+      code: `// @ts-nocheck
 // This snippet expects a motion sensor boolean on msg.payload.
 // When motion is detected turn the light on, otherwise schedule an auto-off.
 if (msg.payload === true) {
@@ -79,11 +79,11 @@ if (msg.payload === true) {
     context.set('autoOffTimer', timer);
 }
 return;`
-        },
-        {
-            id: 'window-hvac-standby',
-            title: 'HVAC standby when window open',
-            code: `// @ts-nocheck
+    },
+    {
+      id: 'window-hvac-standby',
+      title: 'HVAC standby when window open',
+      code: `// @ts-nocheck
 // msg.payload should contain the window contact state (true = open).
 // If the window is open, set the HVAC to standby, otherwise restore comfort.
 const hvacGa = ''; // Replace with your HVAC GA.
@@ -98,11 +98,11 @@ if (msg.payload === true) {
     node.status({fill: 'green', shape: 'dot', text: 'HVAC comfort'});
 }
 return;`
-        },
-        {
-            id: 'night-door-alert',
-            title: 'Night door alert',
-            code: `// @ts-nocheck
+    },
+    {
+      id: 'night-door-alert',
+      title: 'Night door alert',
+      code: `// @ts-nocheck
 // Send a KNX notification GA if a door opens between 22:00 and 06:00.
 const now = new Date();
 const hour = now.getHours();
@@ -112,11 +112,11 @@ if (msg.payload === true && (hour >= 22 || hour < 6)) {
     node.status({fill: 'red', shape: 'ring', text: 'Door alert sent'});
 }
 return;`
-        },
-        {
-            id: 'bedtime-all-off',
-            title: 'Bedtime all off',
-            code: `// @ts-nocheck
+    },
+    {
+      id: 'bedtime-all-off',
+      title: 'Bedtime all off',
+      code: `// @ts-nocheck
 // Turn off a list of lights when a bedtime command is received.
 const lights = [
     '', // Replace with GA of the first light
@@ -133,13 +133,13 @@ if (msg.payload === 'bedtime') {
     return;
 }
 return msg;`
-        }
-    ]
-
-    if (root) {
-        root.KNXSendSnippets = KNXSendSnippets
-    }
-    if (typeof module !== 'undefined' && module.exports) {
-        module.exports = KNXSendSnippets
     }
+  ]
+
+  if (root) {
+    root.KNXSendSnippets = KNXSendSnippets
+  }
+  if (typeof module !== 'undefined' && module.exports) {
+    module.exports = KNXSendSnippets
+  }
 })(typeof window !== 'undefined' ? window : (typeof globalThis !== 'undefined' ? globalThis : this))

package/resources/htmlUtils.js

@@ -1,3 +1,6 @@
+/* global window, document, MutationObserver, $, jQuery */
+/* eslint-disable camelcase */
+
 // 31/03/2020 Search Helper
 function htmlUtilsfullCSVSearch (sourceText, searchString) {
   let aSearchWords = []
@@ -23,7 +26,7 @@ function htmlUtilsfullCSVSearch (sourceText, searchString) {
   for (let index = 0; index < aSearchWords.length; index++) {
     if (sourceText.toLowerCase().indexOf(aSearchWords[index]) > -1) i += 1
   }
-  return i == aSearchWords.length
+  return i === aSearchWords.length
 }
 
 // 2025-09 Secure KNX helpers for GA autocompletes
@@ -112,7 +115,6 @@ function KNX_makeSelectSearchable ($select) {
 
     function syncFromSelect ($input) {
       try {
-        const val = $select.val()
         const txt = ($select.find('option:selected').text()) || ''
         if ($input) { $input.val(txt) }
         // refresh source
@@ -196,10 +198,10 @@ function KNX_makeSelectSearchable ($select) {
   } catch (e) {}
 })()
 
-window.KNX_makeSelectSearchable = KNX_makeSelectSearchable;
+window.KNX_makeSelectSearchable = KNX_makeSelectSearchable
 
 // Ensure autocomplete lists open immediately on focus/click
-(function ($) {
+;(function ($) {
   if (!$.ui || !$.ui.autocomplete) return
   const _create = $.ui.autocomplete.prototype._create
   $.ui.autocomplete.prototype._create = function () {