matterbridge 1.6.6-dev.1 → 1.6.6-dev.13

package/dist/matterbridgeEndpoint.js

@@ -26,6 +26,7 @@ export class MatterbridgeEndpoint extends Endpoint {
     static logLevel = "info";
     log;
     plugin = undefined;
+    configUrl = undefined;
     deviceName = undefined;
     serialNumber = undefined;
     uniqueId = undefined;
@@ -41,6 +42,7 @@ export class MatterbridgeEndpoint extends Endpoint {
     deviceType;
     uniqueStorageKey = undefined;
     tagList = undefined;
+    subType = '';
     deviceTypes = new Map();
     clusterServers = new Map();
     clusterClients = new Map();
@@ -115,7 +117,7 @@ export class MatterbridgeEndpoint extends Endpoint {
         });
         return behaviorTypes;
     }
-    static getBehaviourTypeFromClusterServerId(clusterId, type) {
+    static getBehaviourTypeFromClusterServerId(clusterId, subType) {
         if (clusterId === Identify.Cluster.id)
             return MatterbridgeIdentifyServer;
         if (clusterId === Groups.Cluster.id)
@@ -123,30 +125,36 @@ export class MatterbridgeEndpoint extends Endpoint {
         if (clusterId === OnOff.Cluster.id)
             return MatterbridgeOnOffServer.with('Lighting');
         if (clusterId === LevelControl.Cluster.id)
-            return MatterbridgeLevelControlServer;
-        if (clusterId === ColorControl.Cluster.id && type === 'CompleteColorControl')
+            return MatterbridgeLevelControlServer.with('OnOff', 'Lighting');
+        if (clusterId === ColorControl.Cluster.id && subType === undefined)
             return MatterbridgeColorControlServer;
-        if (clusterId === ColorControl.Cluster.id && type === 'XyColorControl')
+        if (clusterId === ColorControl.Cluster.id && subType === 'CompleteColorControl')
+            return MatterbridgeColorControlServer;
+        if (clusterId === ColorControl.Cluster.id && subType === 'XyColorControl')
             return MatterbridgeColorControlServer.with('Xy');
-        if (clusterId === ColorControl.Cluster.id && type === 'HueSaturationColorControl')
+        if (clusterId === ColorControl.Cluster.id && subType === 'HueSaturationColorControl')
             return MatterbridgeColorControlServer.with('HueSaturation');
-        if (clusterId === ColorControl.Cluster.id && type === 'ColorTemperatureColorControl')
+        if (clusterId === ColorControl.Cluster.id && subType === 'ColorTemperatureColorControl')
             return MatterbridgeColorControlServer.with('ColorTemperature');
         if (clusterId === DoorLock.Cluster.id)
             return MatterbridgeDoorLockServer;
-        if (clusterId === Thermostat.Cluster.id && type === 'AutoModeThermostat')
+        if (clusterId === Thermostat.Cluster.id && subType === undefined)
+            return MatterbridgeThermostatServer.with('AutoMode', 'Heating', 'Cooling');
+        if (clusterId === Thermostat.Cluster.id && subType === 'AutoModeThermostat')
             return MatterbridgeThermostatServer.with('AutoMode', 'Heating', 'Cooling');
-        if (clusterId === Thermostat.Cluster.id && type === 'HeatingThermostat')
+        if (clusterId === Thermostat.Cluster.id && subType === 'HeatingThermostat')
             return MatterbridgeThermostatServer.with('Heating');
-        if (clusterId === Thermostat.Cluster.id && type === 'CoolingThermostat')
+        if (clusterId === Thermostat.Cluster.id && subType === 'CoolingThermostat')
             return MatterbridgeThermostatServer.with('Cooling');
         if (clusterId === WindowCovering.Cluster.id)
             return MatterbridgeWindowCoveringServer;
         if (clusterId === FanControl.Cluster.id)
             return MatterbridgeFanControlServer;
-        if (clusterId === Switch.Cluster.id && type === 'MomentarySwitch')
+        if (clusterId === Switch.Cluster.id && subType === undefined)
+            return SwitchServer.with('MomentarySwitch', 'MomentarySwitchRelease', 'MomentarySwitchLongPress', 'MomentarySwitchMultiPress');
+        if (clusterId === Switch.Cluster.id && subType === 'MomentarySwitch')
             return SwitchServer.with('MomentarySwitch', 'MomentarySwitchRelease', 'MomentarySwitchLongPress', 'MomentarySwitchMultiPress');
-        if (clusterId === Switch.Cluster.id && type === 'LatchingSwitch')
+        if (clusterId === Switch.Cluster.id && subType === 'LatchingSwitch')
             return SwitchServer.with('LatchingSwitch');
         if (clusterId === TemperatureMeasurement.Cluster.id)
             return TemperatureMeasurementServer;
@@ -200,11 +208,13 @@ export class MatterbridgeEndpoint extends Endpoint {
             return ElectricalPowerMeasurementServer.with('AlternatingCurrent');
         if (clusterId === ElectricalEnergyMeasurement.Cluster.id)
             return ElectricalEnergyMeasurementServer.with('ImportedEnergy', 'ExportedEnergy', 'CumulativeEnergy');
-        if (clusterId === PowerSource.Cluster.id && type === 'WiredPowerSource')
+        if (clusterId === PowerSource.Cluster.id && subType === undefined)
+            return PowerSourceServer;
+        if (clusterId === PowerSource.Cluster.id && subType === 'WiredPowerSource')
             return PowerSourceServer.with(PowerSource.Feature.Wired);
-        if (clusterId === PowerSource.Cluster.id && type === 'BatteryReplaceablePowerSource')
+        if (clusterId === PowerSource.Cluster.id && subType === 'BatteryReplaceablePowerSource')
             return PowerSourceServer.with(PowerSource.Feature.Battery, PowerSource.Feature.Replaceable);
-        if (clusterId === PowerSource.Cluster.id && type === 'BatteryRechargeablePowerSource')
+        if (clusterId === PowerSource.Cluster.id && subType === 'BatteryRechargeablePowerSource')
             return PowerSourceServer.with(PowerSource.Feature.Battery, PowerSource.Feature.Rechargeable);
         if (clusterId === BasicInformation.Cluster.id)
             return BasicInformationServer;
@@ -410,40 +420,32 @@ export class MatterbridgeEndpoint extends Endpoint {
         if (this.clusterServers.has(cluster.id)) {
             this.log.debug(`****cluster ${hk}${'0x' + cluster.id.toString(16).padStart(4, '0')}${db}-${hk}${getClusterNameById(cluster.id)}${db} already added`);
         }
-        let type = undefined;
+        this.subType = '';
         if (cluster.id === ColorControl.Cluster.id && cluster.isAttributeSupportedByName('currentX') && !cluster.isAttributeSupportedByName('currentHue') && !cluster.isAttributeSupportedByName('colorTemperatureMireds'))
-            type = 'XyColorControl';
+            this.subType = 'XyColorControl';
         else if (cluster.id === ColorControl.Cluster.id && cluster.isAttributeSupportedByName('currentHue') && !cluster.isAttributeSupportedByName('currentX') && !cluster.isAttributeSupportedByName('colorTemperatureMireds'))
-            type = 'HueSaturationColorControl';
+            this.subType = 'HueSaturationColorControl';
         else if (cluster.id === ColorControl.Cluster.id && cluster.isAttributeSupportedByName('colorTemperatureMireds') && !cluster.isAttributeSupportedByName('currentHue') && !cluster.isAttributeSupportedByName('currentX'))
-            type = 'ColorTemperatureColorControl';
+            this.subType = 'ColorTemperatureColorControl';
         else
-            type = 'CompleteColorControl';
+            this.subType = 'CompleteColorControl';
         if (cluster.id === SwitchCluster.id && cluster.isEventSupportedByName('multiPressComplete'))
-            type = 'MomentarySwitch';
+            this.subType = 'MomentarySwitch';
         if (cluster.id === SwitchCluster.id && cluster.isEventSupportedByName('switchLatched'))
-            type = 'LatchingSwitch';
+            this.subType = 'LatchingSwitch';
         if (cluster.id === PowerSourceCluster.id && cluster.isAttributeSupportedByName('wiredCurrentType'))
-            type = 'WiredPowerSource';
+            this.subType = 'WiredPowerSource';
         if (cluster.id === PowerSourceCluster.id && cluster.isAttributeSupportedByName('batReplacementDescription'))
-            type = 'BatteryReplaceablePowerSource';
+            this.subType = 'BatteryReplaceablePowerSource';
         if (cluster.id === PowerSourceCluster.id && cluster.isAttributeSupportedByName('batChargeState'))
-            type = 'BatteryRechargeablePowerSource';
+            this.subType = 'BatteryRechargeablePowerSource';
         if (cluster.id === ThermostatCluster.id && cluster.isAttributeSupportedByName('occupiedCoolingSetpoint'))
-            type = 'CoolingThermostat';
+            this.subType = 'CoolingThermostat';
         if (cluster.id === ThermostatCluster.id && cluster.isAttributeSupportedByName('occupiedHeatingSetpoint'))
-            type = 'HeatingThermostat';
+            this.subType = 'HeatingThermostat';
         if (cluster.id === ThermostatCluster.id && cluster.isAttributeSupportedByName('minSetpointDeadBand'))
-            type = 'AutoModeThermostat';
-        const behavior = MatterbridgeEndpoint.getBehaviourTypeFromClusterServerId(cluster.id, type);
-        if (cluster.id === PowerTopologyCluster.id && this.clusterServers.has(cluster.id))
-            return;
-        if (cluster.id === ElectricalPowerMeasurementCluster.id && this.clusterServers.has(cluster.id))
-            return;
-        if (cluster.id === ElectricalEnergyMeasurementCluster.id && this.clusterServers.has(cluster.id))
-            return;
-        if (cluster.id === ThermostatCluster.id && this.clusterServers.has(cluster.id))
-            return;
+            this.subType = 'AutoModeThermostat';
+        const behavior = MatterbridgeEndpoint.getBehaviourTypeFromClusterServerId(cluster.id, this.subType);
         this.clusterServers.set(cluster.id, cluster);
         if (cluster.id === BasicInformationCluster.id)
             return;
@@ -707,6 +709,7 @@ export class MatterbridgeEndpoint extends Endpoint {
             vendorName: vendorName.slice(0, 32),
             productId: productId,
             productName: productName.slice(0, 32),
+            productUrl: 'https://www.npmjs.com/package/matterbridge',
             productLabel: deviceName.slice(0, 64),
             nodeLabel: deviceName.slice(0, 32),
             serialNumber: serialNumber.slice(0, 32),
@@ -751,6 +754,7 @@ export class MatterbridgeEndpoint extends Endpoint {
             vendorId: vendorId !== undefined ? VendorId(vendorId) : undefined,
             vendorName: vendorName.slice(0, 32),
             productName: productName.slice(0, 32),
+            productUrl: 'https://www.npmjs.com/package/matterbridge',
             productLabel: deviceName.slice(0, 64),
             nodeLabel: deviceName.slice(0, 32),
             serialNumber: serialNumber.slice(0, 32),
@@ -854,47 +858,39 @@ export class MatterbridgeEndpoint extends Endpoint {
     createDefaultOnOffClusterServer(onOff = false, globalSceneControl = false, onTime = 0, offWaitTime = 0, startUpOnOff = null) {
         this.addClusterServer(this.getDefaultOnOffClusterServer(onOff, globalSceneControl, onTime, offWaitTime, startUpOnOff));
     }
-    getDefaultLevelControlClusterServer(currentLevel = 254, minLevel = 0, maxLevel = 254, onLevel = 254) {
-        return ClusterServer(LevelControlCluster.with(LevelControl.Feature.OnOff), {
+    getDefaultLevelControlClusterServer(currentLevel = 254, minLevel = 1, maxLevel = 254, onLevel = null, startUpCurrentLevel = null) {
+        return ClusterServer(LevelControlCluster.with(LevelControl.Feature.OnOff, LevelControl.Feature.Lighting), {
             currentLevel,
             minLevel,
             maxLevel,
             onLevel,
+            remainingTime: 0,
+            startUpCurrentLevel,
             options: {
                 executeIfOff: false,
                 coupleColorTempToLevel: false,
             },
         }, {
             moveToLevel: async (data) => {
-                this.log.debug('Matter command: moveToLevel request:', data.request, 'attributes.currentLevel:', data.attributes.currentLevel.getLocal());
-                await this.commandHandler.executeHandler('moveToLevel', data);
             },
             move: async () => {
-                this.log.error('Matter command: move not implemented');
             },
             step: async () => {
-                this.log.error('Matter command: step not implemented');
             },
             stop: async () => {
-                this.log.error('Matter command: stop not implemented');
             },
             moveToLevelWithOnOff: async (data) => {
-                this.log.debug('Matter command: moveToLevelWithOnOff request:', data.request, 'attributes.currentLevel:', data.attributes.currentLevel.getLocal());
-                await this.commandHandler.executeHandler('moveToLevelWithOnOff', data);
             },
             moveWithOnOff: async () => {
-                this.log.error('Matter command: moveWithOnOff not implemented');
             },
             stepWithOnOff: async () => {
-                this.log.error('Matter command: stepWithOnOff not implemented');
             },
             stopWithOnOff: async () => {
-                this.log.error('Matter command: stopWithOnOff not implemented');
             },
         });
     }
-    createDefaultLevelControlClusterServer(currentLevel = 254, minLevel = 0, maxLevel = 254, onLevel = 254) {
-        this.addClusterServer(this.getDefaultLevelControlClusterServer(currentLevel, minLevel, maxLevel, onLevel));
+    createDefaultLevelControlClusterServer(currentLevel = 254, minLevel = 1, maxLevel = 254, onLevel = null, startUpCurrentLevel = null) {
+        this.addClusterServer(this.getDefaultLevelControlClusterServer(currentLevel, minLevel, maxLevel, onLevel, startUpCurrentLevel));
     }
     getDefaultColorControlClusterServer(currentX = 0, currentY = 0, currentHue = 0, currentSaturation = 0, colorTemperatureMireds = 500, colorTempPhysicalMinMireds = 147, colorTempPhysicalMaxMireds = 500) {
         return ClusterServer(ColorControlCluster.with(ColorControl.Feature.Xy, ColorControl.Feature.HueSaturation, ColorControl.Feature.ColorTemperature), {
@@ -913,54 +909,36 @@ export class MatterbridgeEndpoint extends Endpoint {
             colorTempPhysicalMinMireds,
             colorTempPhysicalMaxMireds,
             coupleColorTempToLevelMinMireds: colorTempPhysicalMinMireds,
+            remainingTime: 0,
             startUpColorTemperatureMireds: null,
         }, {
             moveToColor: async (data) => {
-                this.log.debug('Matter command: moveToColor request:', data.request, 'attributes.currentX:', data.attributes.currentX.getLocal(), 'attributes.currentY:', data.attributes.currentY.getLocal());
-                this.commandHandler.executeHandler('moveToColor', data);
             },
             moveColor: async () => {
-                this.log.error('Matter command: moveColor not implemented');
             },
             stepColor: async () => {
-                this.log.error('Matter command: stepColor not implemented');
             },
             moveToHue: async (data) => {
-                this.log.debug('Matter command: moveToHue request:', data.request, 'attributes.currentHue:', data.attributes.currentHue.getLocal());
-                this.commandHandler.executeHandler('moveToHue', data);
             },
             moveHue: async () => {
-                this.log.error('Matter command: moveHue not implemented');
             },
             stepHue: async () => {
-                this.log.error('Matter command: stepHue not implemented');
             },
             moveToSaturation: async (data) => {
-                this.log.debug('Matter command: moveToSaturation request:', data.request, 'attributes.currentSaturation:', data.attributes.currentSaturation.getLocal());
-                this.commandHandler.executeHandler('moveToSaturation', data);
             },
             moveSaturation: async () => {
-                this.log.error('Matter command: moveSaturation not implemented');
             },
             stepSaturation: async () => {
-                this.log.error('Matter command: stepSaturation not implemented');
             },
             moveToHueAndSaturation: async (data) => {
-                this.log.debug('Matter command: moveToHueAndSaturation request:', data.request, 'attributes.currentHue:', data.attributes.currentHue.getLocal(), 'attributes.currentSaturation:', data.attributes.currentSaturation.getLocal());
-                this.commandHandler.executeHandler('moveToHueAndSaturation', data);
             },
             stopMoveStep: async () => {
-                this.log.error('Matter command: stopMoveStep not implemented');
             },
             moveToColorTemperature: async (data) => {
-                this.log.debug('Matter command: moveToColorTemperature request:', data.request, 'attributes.colorTemperatureMireds:', data.attributes.colorTemperatureMireds.getLocal());
-                this.commandHandler.executeHandler('moveToColorTemperature', data);
             },
             moveColorTemperature: async () => {
-                this.log.error('Matter command: moveColorTemperature not implemented');
             },
             stepColorTemperature: async () => {
-                this.log.error('Matter command: stepColorTemperature not implemented');
             },
         }, {});
     }
@@ -978,6 +956,7 @@ export class MatterbridgeEndpoint extends Endpoint {
             numberOfPrimaries: null,
             currentX,
             currentY,
+            remainingTime: 0,
         }, {
             moveToColor: async () => {
             },
@@ -989,7 +968,7 @@ export class MatterbridgeEndpoint extends Endpoint {
             },
         }, {});
     }
-    createXyControlClusterServer(currentX = 0, currentY = 0) {
+    createXyColorControlClusterServer(currentX = 0, currentY = 0) {
         this.addClusterServer(this.getXyColorControlClusterServer(currentX, currentY));
     }
     getHsColorControlClusterServer(currentHue = 0, currentSaturation = 0) {
@@ -1003,6 +982,7 @@ export class MatterbridgeEndpoint extends Endpoint {
             numberOfPrimaries: null,
             currentHue,
             currentSaturation,
+            remainingTime: 0,
         }, {
             moveToHue: async ({ request, attributes, endpoint }) => {
             },
@@ -1037,6 +1017,9 @@ export class MatterbridgeEndpoint extends Endpoint {
             colorTemperatureMireds,
             colorTempPhysicalMinMireds,
             colorTempPhysicalMaxMireds,
+            coupleColorTempToLevelMinMireds: colorTempPhysicalMinMireds,
+            remainingTime: 0,
+            startUpColorTemperatureMireds: null,
         }, {
             stopMoveStep: async () => {
             },
@@ -1101,21 +1084,12 @@ export class MatterbridgeEndpoint extends Endpoint {
             currentPositionLiftPercent100ths: positionPercent100ths ?? 0,
         }, {
             upOrOpen: async (data) => {
-                this.log.debug('Matter command: upOrOpen');
-                await this.commandHandler.executeHandler('upOrOpen', data);
             },
             downOrClose: async (data) => {
-                this.log.debug('Matter command: downOrClose');
-                await this.commandHandler.executeHandler('downOrClose', data);
             },
             stopMotion: async (data) => {
-                this.log.debug('Matter command: stopMotion');
-                await this.commandHandler.executeHandler('stopMotion', data);
             },
             goToLiftPercentage: async (data) => {
-                this.log.debug(`Matter command: goToLiftPercentage: ${data.request.liftPercent100thsValue} current: ${data.attributes.currentPositionLiftPercent100ths?.getLocal()} ` +
-                    `target: ${data.attributes.targetPositionLiftPercent100ths?.getLocal()} status: ${data.attributes.operationalStatus.getLocal().lift}`);
-                await this.commandHandler.executeHandler('goToLiftPercentage', data);
             },
         }, {});
     }
@@ -1181,12 +1155,8 @@ export class MatterbridgeEndpoint extends Endpoint {
             supportedOperatingModes: { normal: true, vacation: false, privacy: false, noRemoteLockUnlock: false, passage: false },
         }, {
             lockDoor: async (data) => {
-                this.log.debug('Matter command: lockDoor', data.request);
-                await this.commandHandler.executeHandler('lockDoor', data);
             },
             unlockDoor: async (data) => {
-                this.log.debug('Matter command: unlockDoor', data.request);
-                await this.commandHandler.executeHandler('unlockDoor', data);
             },
         }, {
             doorLockAlarm: true,
@@ -1301,8 +1271,6 @@ export class MatterbridgeEndpoint extends Endpoint {
             startUpMode: startUpMode,
         }, {
             changeToMode: async (data) => {
-                this.log.debug('Matter command: ModeSelectCluster.changeToMode', data.request);
-                await this.commandHandler.executeHandler('changeToMode', data);
             },
         });
     }
@@ -1398,8 +1366,6 @@ export class MatterbridgeEndpoint extends Endpoint {
             sensorFault: { generalFault: sensorFault },
         }, {
             enableDisableAlarm: async (data) => {
-                this.log.debug('Matter command: enableDisableAlarm', data.request);
-                await this.commandHandler.executeHandler('enableDisableAlarm', data);
             },
         }, {
             alarmsStateChanged: true,
@@ -1498,8 +1464,6 @@ export class MatterbridgeEndpoint extends Endpoint {
             absMaxHeatSetpointLimit: maxHeatSetpointLimit * 100,
         }, {
             setpointRaiseLower: async (data) => {
-                this.log.debug('Matter command: setpointRaiseLower', data.request);
-                await this.commandHandler.executeHandler('setpointRaiseLower', data);
             },
         }, {});
     }
@@ -1518,8 +1482,6 @@ export class MatterbridgeEndpoint extends Endpoint {
             absMaxCoolSetpointLimit: maxCoolSetpointLimit * 100,
         }, {
             setpointRaiseLower: async (data) => {
-                this.log.debug('Matter command: setpointRaiseLower', data.request);
-                await this.commandHandler.executeHandler('setpointRaiseLower', data);
             },
         }, {});
     }
@@ -1545,8 +1507,6 @@ export class MatterbridgeEndpoint extends Endpoint {
             thermostatRunningMode: Thermostat.ThermostatRunningMode.Off,
         }, {
             setpointRaiseLower: async (data) => {
-                this.log.debug('Matter command: setpointRaiseLower', data.request);
-                await this.commandHandler.executeHandler('setpointRaiseLower', data);
             },
         }, {});
     }
@@ -1567,8 +1527,6 @@ export class MatterbridgeEndpoint extends Endpoint {
             interconnectCoAlarm: SmokeCoAlarm.AlarmState.Normal,
         }, {
             selfTestRequest: async (data) => {
-                this.log.debug('Matter command: selfTestRequest');
-                await this.commandHandler.executeHandler('selfTestRequest', data);
             },
         }, {
             smokeAlarm: true,
@@ -1715,8 +1673,6 @@ export class MatterbridgeEndpoint extends Endpoint {
             speedCurrent: 0,
         }, {
             step: async (data) => {
-                this.log.debug('Matter command: step', data.request);
-                await this.commandHandler.executeHandler('step', data);
             },
         }, {});
     }

package/dist/matterbridgePlatform.js

@@ -1,5 +1,7 @@
 import { MatterbridgeDevice } from './matterbridgeDevice.js';
+import { CYAN, nf, wr } from 'node-ansi-logger';
 import { MatterbridgeEndpoint } from './matterbridgeEndpoint.js';
+import { isValidArray, isValidObject } from './utils/utils.js';
 export class MatterbridgePlatform {
     matterbridge;
     log;
@@ -39,13 +41,16 @@ export class MatterbridgePlatform {
             await this.matterbridge.removeBridgedEndpoint(this.name, device);
     }
     async unregisterAllDevices() {
-        await this.matterbridge.removeAllBridgedDevices(this.name);
+        if (this.matterbridge.edge)
+            await this.matterbridge.removeAllBridgedEndpoints(this.name);
+        else
+            await this.matterbridge.removeAllBridgedDevices(this.name);
     }
     verifyMatterbridgeVersion(requiredVersion) {
         const compareVersions = (matterbridgeVersion, requiredVersion) => {
             const stripTag = (v) => {
                 const parts = v.split('-');
-                return parts.length > 0 ? parts[0] : v;
+                return parts[0];
             };
             const v1Parts = stripTag(matterbridgeVersion).split('.').map(Number);
             const v2Parts = stripTag(requiredVersion).split('.').map(Number);
@@ -65,4 +70,30 @@ export class MatterbridgePlatform {
             return false;
         return true;
     }
+    validateDeviceWhiteBlackList(device, log = true) {
+        if (isValidArray(this.config.whiteList, 1) && !this.config.whiteList.includes(device)) {
+            if (log)
+                this.log.info(`Skipping device ${CYAN}${device}${nf} because not in whitelist`);
+            return false;
+        }
+        if (isValidArray(this.config.blackList, 1) && this.config.blackList.includes(device)) {
+            if (log)
+                this.log.info(`Skipping device ${CYAN}${device}${nf} because in blacklist`);
+            return false;
+        }
+        return true;
+    }
+    validateEntityBlackList(device, entity, log = true) {
+        if (isValidArray(this.config.entityBlackList, 1) && this.config.entityBlackList.find((e) => e === entity)) {
+            if (log)
+                this.log.info(`Skipping entity ${CYAN}${entity}${nf} because in entityBlackList`);
+            return false;
+        }
+        if (isValidObject(this.config.deviceEntityBlackList, 1) && device in this.config.deviceEntityBlackList && this.config.deviceEntityBlackList[device].includes(entity)) {
+            if (log)
+                this.log.info(`Skipping entity ${CYAN}${entity}${wr} for device ${CYAN}${device}${nf} because in deviceEntityBlackList`);
+            return false;
+        }
+        return true;
+    }
 }

package/dist/matterbridgeWebsocket.js

@@ -81,6 +81,9 @@ export async function wsMessageHandler(client, message) {
             this.matterbridgeInformation.mattermdnsinterface = (await this.nodeContext?.get('mattermdnsinterface', '')) || '';
             this.matterbridgeInformation.matteripv4address = (await this.nodeContext?.get('matteripv4address', '')) || '';
             this.matterbridgeInformation.matteripv6address = (await this.nodeContext?.get('matteripv6address', '')) || '';
+            this.matterbridgeInformation.matterPort = (await this.nodeContext?.get('matterport', 5540)) ?? 5540;
+            this.matterbridgeInformation.matterDiscriminator = await this.nodeContext?.get('matterdiscriminator');
+            this.matterbridgeInformation.matterPasscode = await this.nodeContext?.get('matterpasscode');
             this.matterbridgeInformation.matterbridgePaired = this.matterbridgePaired;
             this.matterbridgeInformation.matterbridgeConnected = this.matterbridgeConnected;
             this.matterbridgeInformation.matterbridgeQrPairingCode = this.matterbridgeQrPairingCode;
@@ -108,6 +111,9 @@ export async function wsMessageHandler(client, message) {
                 let serial = device.getClusterServer(BasicInformationCluster)?.attributes.serialNumber?.getLocal();
                 if (!serial)
                     serial = device.getClusterServer(BridgedDeviceBasicInformationCluster)?.attributes.serialNumber?.getLocal() ?? 'Unknown';
+                let productUrl = device.getClusterServer(BasicInformationCluster)?.attributes.productUrl?.getLocal();
+                if (!productUrl)
+                    productUrl = device.getClusterServer(BridgedDeviceBasicInformationCluster)?.attributes.productUrl?.getLocal() ?? 'Unknown';
                 let uniqueId = device.getClusterServer(BasicInformationCluster)?.attributes.uniqueId?.getLocal();
                 if (!uniqueId)
                     uniqueId = device.getClusterServer(BridgedDeviceBasicInformationCluster)?.attributes.uniqueId?.getLocal() ?? 'Unknown';
@@ -118,6 +124,8 @@ export async function wsMessageHandler(client, message) {
                     endpoint: device.number,
                     name,
                     serial,
+                    productUrl,
+                    configUrl: device.configUrl,
                     uniqueId,
                     cluster: cluster,
                 });

package/dist/utils/colorUtils.js

@@ -139,99 +139,43 @@ export function xyToHsl(x, y) {
     const rgb = xyColorToRgbColor(x, y);
     return rgbColorToHslColor(rgb);
 }
-export function testColors() {
-    const colors = [
-        { name: 'Pure Red          0', hsl: { h: 0, s: 100, l: 50 }, rgb: { r: 255, g: 0, b: 0 }, xy: { x: 0.7006, y: 0.2993 } },
-        { name: 'Bright Orange    30', hsl: { h: 30, s: 100, l: 50 }, rgb: { r: 255, g: 128, b: 0 }, xy: { x: 0.6112, y: 0.375 } },
-        { name: 'Pure Yellow      60', hsl: { h: 60, s: 100, l: 50 }, rgb: { r: 255, g: 255, b: 0 }, xy: { x: 0.4442, y: 0.5166 } },
-        { name: 'Lime Green       90', hsl: { h: 90, s: 100, l: 50 }, rgb: { r: 128, g: 255, b: 0 }, xy: { x: 0.2707, y: 0.6635 } },
-        { name: 'Pure Green      120', hsl: { h: 120, s: 100, l: 50 }, rgb: { r: 0, g: 255, b: 0 }, xy: { x: 0.1724, y: 0.7468 } },
-        { name: 'Light Sea Green 150', hsl: { h: 150, s: 100, l: 50 }, rgb: { r: 0, g: 255, b: 128 }, xy: { x: 0.1642, y: 0.5886 } },
-        { name: 'Pure Cyan       180', hsl: { h: 180, s: 100, l: 50 }, rgb: { r: 0, g: 255, b: 255 }, xy: { x: 0.1513, y: 0.3425 } },
-        { name: 'Deep Sky Blue   210', hsl: { h: 210, s: 100, l: 50 }, rgb: { r: 0, g: 128, b: 255 }, xy: { x: 0.1406, y: 0.1382 } },
-        { name: 'Pure Blue       240', hsl: { h: 240, s: 100, l: 50 }, rgb: { r: 0, g: 0, b: 255 }, xy: { x: 0.1355, y: 0.0399 } },
-        { name: 'Blue Violet     270', hsl: { h: 270, s: 100, l: 50 }, rgb: { r: 128, g: 0, b: 255 }, xy: { x: 0.2181, y: 0.0778 } },
-        { name: 'Pure Magenta    300', hsl: { h: 300, s: 100, l: 50 }, rgb: { r: 255, g: 0, b: 255 }, xy: { x: 0.3855, y: 0.1546 } },
-        { name: 'Deep Pink       330', hsl: { h: 330, s: 100, l: 50 }, rgb: { r: 255, g: 0, b: 128 }, xy: { x: 0.5797, y: 0.2438 } },
-        { name: 'Pure Red        50%   0', hsl: { h: 0, s: 50, l: 50 }, rgb: { r: 192, g: 64, b: 64 }, xy: { x: 0.6036, y: 0.3069 } },
-        { name: 'Bright Orange   50%  30', hsl: { h: 30, s: 50, l: 50 }, rgb: { r: 192, g: 128, b: 64 }, xy: { x: 0.5194, y: 0.3928 } },
-        { name: 'Pure Yellow     50%  60', hsl: { h: 60, s: 50, l: 50 }, rgb: { r: 192, g: 192, b: 64 }, xy: { x: 0.4258, y: 0.4883 } },
-        { name: 'Lime Green      50%  90', hsl: { h: 90, s: 50, l: 50 }, rgb: { r: 128, g: 192, b: 64 }, xy: { x: 0.3159, y: 0.5639 } },
-        { name: 'Pure Green      50% 120', hsl: { h: 120, s: 50, l: 50 }, rgb: { r: 64, g: 192, b: 64 }, xy: { x: 0.2127, y: 0.6349 } },
-        { name: 'Light Sea Green 50% 150', hsl: { h: 150, s: 50, l: 50 }, rgb: { r: 64, g: 192, b: 128 }, xy: { x: 0.1932, y: 0.4845 } },
-        { name: 'Pure Cyan       50% 180', hsl: { h: 180, s: 50, l: 50 }, rgb: { r: 64, g: 192, b: 192 }, xy: { x: 0.1745, y: 0.3407 } },
-        { name: 'Deep Sky Blue   50% 210', hsl: { h: 210, s: 50, l: 50 }, rgb: { r: 64, g: 128, b: 192 }, xy: { x: 0.1752, y: 0.211 } },
-        { name: 'Pure Blue       50% 240', hsl: { h: 240, s: 50, l: 50 }, rgb: { r: 64, g: 64, b: 192 }, xy: { x: 0.1758, y: 0.102 } },
-        { name: 'Blue Violet     50% 270', hsl: { h: 270, s: 50, l: 50 }, rgb: { r: 128, g: 64, b: 192 }, xy: { x: 0.2688, y: 0.137 } },
-        { name: 'Pure Magenta    50% 300', hsl: { h: 300, s: 50, l: 50 }, rgb: { r: 192, g: 64, b: 192 }, xy: { x: 0.3772, y: 0.1777 } },
-        { name: 'Deep Pink       50% 330', hsl: { h: 330, s: 50, l: 50 }, rgb: { r: 192, g: 64, b: 128 }, xy: { x: 0.489, y: 0.2416 } },
-    ];
-    colors.forEach((color) => {
-        console.log(`\x1b[48;2;${color.rgb.r};${color.rgb.g};${color.rgb.b}mColor: ${color.name}\x1b[0m, hsl: { h: ${color.hsl.h}, s: ${color.hsl.s}, l: ${color.hsl.l} }, rgb: { r: ${color.rgb.r}, g: ${color.rgb.g}, b: ${color.rgb.b} }, xy: { x: ${color.xy.x}, y: ${color.xy.y} }`);
-        const rgb = hslColorToRgbColor(color.hsl.h, color.hsl.s, color.hsl.l);
-        assert(rgb.r === color.rgb.r && rgb.g === color.rgb.g && rgb.b === color.rgb.b, `\x1b[48;2;${rgb.r};${rgb.g};${rgb.b}mColor: ${color.name}\x1b[0m hslColorToRgbColor { r: ${rgb.r}, g: ${rgb.g}, b: ${rgb.b} } conversion error`);
-        const hsl = rgbColorToHslColor({ r: color.rgb.r, g: color.rgb.g, b: color.rgb.b });
-        assert(hsl.h === color.hsl.h && hsl.s === color.hsl.s && hsl.l === color.hsl.l, `Color: ${color.name} rgbColorToHslColor conversion error`);
-        const xy = rgbColorToXYColor({ r: color.rgb.r, g: color.rgb.g, b: color.rgb.b });
-        assert(xy.x === color.xy.x && xy.y === color.xy.y, `Color: ${color.name} rgbColorToXYColor conversion error got x ${xy.x} y ${xy.y}`);
-        const rgb2 = xyColorToRgbColor(color.xy.x, color.xy.y);
-        assert(rgb2.r === color.rgb.r && rgb2.g === color.rgb.g && rgb2.b === color.rgb.b, `\x1b[48;2;${rgb2.r};${rgb2.g};${rgb2.b}mColor: ${color.name}\x1b[0m xyColorToRgbColor(${color.xy.x}, ${color.xy.y}) conversion error -> r: ${rgb2.r} g: ${rgb2.g} b: ${rgb2.g}`);
-    });
+export function miredToKelvin(mired) {
+    return Math.round(1000000 / mired);
 }
-export function cie_to_rgb(x, y, brightness = 254) {
-    const z = 1.0 - x - y;
-    const Y = (brightness / 254).toFixed(2);
-    const X = (Number(Y) / y) * x;
-    const Z = (Number(Y) / y) * z;
-    let red = X * 1.656492 - Number(Y) * 0.354851 - Z * 0.255038;
-    let green = -X * 0.707196 + Number(Y) * 1.655397 + Z * 0.036152;
-    let blue = X * 0.051713 - Number(Y) * 0.121364 + Z * 1.01153;
-    if (red > blue && red > green && red > 1.0) {
-        green = green / red;
-        blue = blue / red;
-        red = 1.0;
+export function kelvinToMired(kelvin) {
+    return Math.round(1000000 / kelvin);
+}
+export function kelvinToRGB(kelvin) {
+    kelvin = Math.max(1000, Math.min(40000, kelvin)) / 100;
+    let r, g, b;
+    if (kelvin <= 66) {
+        r = 255;
     }
-    else if (green > blue && green > red && green > 1.0) {
-        red = red / green;
-        blue = blue / green;
-        green = 1.0;
+    else {
+        r = kelvin - 60;
+        r = 329.698727446 * Math.pow(r, -0.1332047592);
+        r = Math.max(0, Math.min(255, r));
     }
-    else if (blue > red && blue > green && blue > 1.0) {
-        red = red / blue;
-        green = green / blue;
-        blue = 1.0;
+    if (kelvin <= 66) {
+        g = kelvin;
+        g = 99.4708025861 * Math.log(g) - 161.1195681661;
+        g = Math.max(0, Math.min(255, g));
     }
-    red = red <= 0.0031308 ? 12.92 * red : (1.0 + 0.055) * Math.pow(red, 1.0 / 2.4) - 0.055;
-    green = green <= 0.0031308 ? 12.92 * green : (1.0 + 0.055) * Math.pow(green, 1.0 / 2.4) - 0.055;
-    blue = blue <= 0.0031308 ? 12.92 * blue : (1.0 + 0.055) * Math.pow(blue, 1.0 / 2.4) - 0.055;
-    red = Math.round(red * 255);
-    green = Math.round(green * 255);
-    blue = Math.round(blue * 255);
-    if (isNaN(red) || red < 0) {
-        red = 0;
+    else {
+        g = kelvin - 60;
+        g = 288.1221695283 * Math.pow(g, -0.0755148492);
+        g = Math.max(0, Math.min(255, g));
     }
-    if (isNaN(green) || green < 0) {
-        green = 0;
+    if (kelvin >= 66) {
+        b = 255;
     }
-    if (isNaN(blue) || blue < 0) {
-        blue = 0;
+    else if (kelvin <= 19) {
+        b = 0;
     }
-    return { r: red, g: green, b: blue };
-}
-export function rgb_to_cie(red, green, blue) {
-    red = red > 0.04045 ? Math.pow((red + 0.055) / (1.0 + 0.055), 2.4) : red / 12.92;
-    green = green > 0.04045 ? Math.pow((green + 0.055) / (1.0 + 0.055), 2.4) : green / 12.92;
-    blue = blue > 0.04045 ? Math.pow((blue + 0.055) / (1.0 + 0.055), 2.4) : blue / 12.92;
-    const X = red * 0.664511 + green * 0.154324 + blue * 0.162028;
-    const Y = red * 0.283881 + green * 0.668433 + blue * 0.047685;
-    const Z = red * 0.000088 + green * 0.07231 + blue * 0.986039;
-    let x = (X / (X + Y + Z)).toFixed(4);
-    let y = (Y / (X + Y + Z)).toFixed(4);
-    if (isNaN(Number(x))) {
-        x = '0';
-    }
-    if (isNaN(Number(y))) {
-        y = '0';
-    }
-    return { x: Number(x), y: Number(y) };
+    else {
+        b = kelvin - 10;
+        b = 138.5177312231 * Math.log(b) - 305.0447927307;
+        b = Math.max(0, Math.min(255, b));
+    }
+    return { r: Math.round(r), g: Math.round(g), b: Math.round(b) };
 }

package/frontend/build/asset-manifest.json

@@ -1,7 +1,7 @@
 {
   "files": {
     "main.css": "./static/css/main.823e08b6.css",
-    "main.js": "./static/js/main.0ab89802.js",
+    "main.js": "./static/js/main.a742de4e.js",
     "static/js/453.abd36b29.chunk.js": "./static/js/453.abd36b29.chunk.js",
     "static/media/roboto-latin-700-normal.woff2": "./static/media/roboto-latin-700-normal.4535474e1cf8598695ad.woff2",
     "static/media/roboto-latin-500-normal.woff2": "./static/media/roboto-latin-500-normal.7077203b1982951ecf76.woff2",
@@ -61,11 +61,11 @@
     "static/media/roboto-greek-ext-400-normal.woff": "./static/media/roboto-greek-ext-400-normal.16eb83b4a3b1ea994243.woff",
     "index.html": "./index.html",
     "main.823e08b6.css.map": "./static/css/main.823e08b6.css.map",
-    "main.0ab89802.js.map": "./static/js/main.0ab89802.js.map",
+    "main.a742de4e.js.map": "./static/js/main.a742de4e.js.map",
     "453.abd36b29.chunk.js.map": "./static/js/453.abd36b29.chunk.js.map"
   },
   "entrypoints": [
     "static/css/main.823e08b6.css",
-    "static/js/main.0ab89802.js"
+    "static/js/main.a742de4e.js"
   ]
 }