matterbridge 3.0.4-dev-20250525-b1cbfb7 → 3.0.5-dev-20250526-422f029

package/CHANGELOG.md

@@ -8,12 +8,26 @@ If you like this project and find it useful, please consider giving it a star on
   <img src="bmc-button.svg" alt="Buy me a coffee" width="120">
 </a>
 
-## [3.0.4] - 2025-05-??
+## [3.0.5] - 2025-05-??
+
+### Added
+
+### Changed
+
+### Fixed
+
+- [selectAreas]: Fixed MatterbridgeServiceAreaServer.selectAreas.
+
+<a href="https://www.buymeacoffee.com/luligugithub">
+  <img src="bmc-button.svg" alt="Buy me a coffee" width="80">
+</a>
+
+## [3.0.4] - 2025-05-26
 
 ### Added
 
 - [jsdoc]: Improved jsdoc for cluster helpers.
-- [cover]: Added createDefaultTiltWindowCoveringClusterServer().
+- [cover]: Added createDefaultLiftTiltWindowCoveringClusterServer() that create a window covering cluser with both lift and tilt features (supported by Apple Home).
 
 ### Changed
 

package/dist/cli.js

@@ -100,12 +100,20 @@ async function stopCpuMemoryCheck() {
 async function startInspector() {
     const { Session } = await import('node:inspector');
     log.debug(`Starting heap sampling...`);
-    session = new Session();
-    session.connect();
-    await new Promise((resolve, reject) => {
-        session?.post('HeapProfiler.startSampling', {}, (err) => (err ? reject(err) : resolve()));
-    });
-    log.debug(`Started heap sampling`);
+    try {
+        session = new Session();
+        session.connect();
+        await new Promise((resolve, reject) => {
+            session?.post('HeapProfiler.startSampling', (err) => (err ? reject(err) : resolve()));
+        });
+        log.debug(`Started heap sampling`);
+    }
+    catch (err) {
+        log.error(`Failed to start heap sampling: ${err instanceof Error ? err.message : err}`);
+        session?.disconnect();
+        session = undefined;
+        return;
+    }
 }
 async function stopInspector() {
     const { writeFileSync } = await import('node:fs');

package/dist/laundryWasher.js

@@ -0,0 +1,122 @@
+import { OperationalState } from '@matter/main/clusters/operational-state';
+import { LaundryWasherControls } from '@matter/main/clusters/laundry-washer-controls';
+import { LaundryWasherMode } from '@matter/main/clusters/laundry-washer-mode';
+import { TemperatureControl } from '@matter/main/clusters/temperature-control';
+import { ModeBase } from '@matter/main/clusters/mode-base';
+import { TemperatureControlServer } from '@matter/main/behaviors/temperature-control';
+import { LaundryWasherModeServer } from '@matter/main/behaviors/laundry-washer-mode';
+import { LaundryWasherControlsServer } from '@matter/main/behaviors/laundry-washer-controls';
+import { laundryWasher } from './matterbridgeDeviceTypes.js';
+import { MatterbridgeEndpoint } from './matterbridgeEndpoint.js';
+import { MatterbridgeOnOffServer, MatterbridgeServer } from './matterbridgeBehaviors.js';
+export class LaundryWasher extends MatterbridgeEndpoint {
+    constructor(name, serial) {
+        super(laundryWasher, { uniqueStorageKey: `${name.replaceAll(' ', '')}-${serial.replaceAll(' ', '')}` }, true);
+        this.createDefaultIdentifyClusterServer();
+        this.createDefaultBasicInformationClusterServer(name, serial, 0xfff1, 'Matterbridge', 0x8000, 'Matterbridge Laundry Washer');
+        this.createDefaultPowerSourceWiredClusterServer();
+        this.createDeadFrontOnOffClusterServer();
+        this.createLevelTemperatureControlClusterServer(3, ['Cold', '30°', '40°', '60°', '80°']);
+        this.createDefaultLaundryWasherControlsClusterServer();
+        this.createDefaultLaundryWasherModeClusterServer();
+        this.createDefaultOperationalStateClusterServer(OperationalState.OperationalStateEnum.Stopped);
+    }
+    createDefaultLaundryWasherControlsClusterServer(spinSpeedCurrent = 3, spinSpeeds = ['400', '800', '1200', '1600'], numberOfRinses = LaundryWasherControls.NumberOfRinses.Normal, supportedRinses = [LaundryWasherControls.NumberOfRinses.None, LaundryWasherControls.NumberOfRinses.Normal, LaundryWasherControls.NumberOfRinses.Max, LaundryWasherControls.NumberOfRinses.Extra]) {
+        this.behaviors.require(LaundryWasherControlsServer.with(LaundryWasherControls.Feature.Spin, LaundryWasherControls.Feature.Rinse), {
+            spinSpeeds,
+            spinSpeedCurrent,
+            supportedRinses,
+            numberOfRinses,
+        });
+        return this;
+    }
+    createDefaultLaundryWasherModeClusterServer(currentMode = 2, supportedModes = [
+        { label: 'Delicate', mode: 1, modeTags: [{ value: LaundryWasherMode.ModeTag.Delicate }] },
+        { label: 'Normal', mode: 2, modeTags: [{ value: LaundryWasherMode.ModeTag.Normal }] },
+        { label: 'Heavy', mode: 3, modeTags: [{ value: LaundryWasherMode.ModeTag.Heavy }] },
+        { label: 'Whites', mode: 4, modeTags: [{ value: LaundryWasherMode.ModeTag.Whites }] },
+    ]) {
+        this.behaviors.require(MatterbridgeLaundryWasherModeServer, {
+            supportedModes,
+            currentMode,
+        });
+        return this;
+    }
+    createLevelTemperatureControlClusterServer(selectedTemperatureLevel = 1, supportedTemperatureLevels = ['Cold', 'Warm', 'Hot']) {
+        this.behaviors.require(MatterbridgeLevelTemperatureControlServer.with(TemperatureControl.Feature.TemperatureLevel), {
+            selectedTemperatureLevel,
+            supportedTemperatureLevels,
+        });
+        return this;
+    }
+    createNumberTemperatureControlClusterServer(temperatureSetpoint = 40 * 100, minTemperature = 30 * 100, maxTemperature = 60 * 100, step = 10 * 100) {
+        this.behaviors.require(MatterbridgeNumberTemperatureControlServer.with(TemperatureControl.Feature.TemperatureNumber, TemperatureControl.Feature.TemperatureStep), {
+            temperatureSetpoint,
+            minTemperature,
+            maxTemperature,
+            step,
+        });
+        return this;
+    }
+}
+class MatterbridgeLevelTemperatureControlServer extends TemperatureControlServer.with(TemperatureControl.Feature.TemperatureLevel) {
+    initialize() {
+        if (this.state.supportedTemperatureLevels.length >= 2) {
+            const device = this.endpoint.stateOf(MatterbridgeServer).deviceCommand;
+            device.log.info('MatterbridgeLevelTemperatureControlServer initialized');
+        }
+    }
+    setTemperature(request) {
+        const device = this.endpoint.stateOf(MatterbridgeServer).deviceCommand;
+        if (request.targetTemperatureLevel !== undefined && request.targetTemperatureLevel >= 0 && request.targetTemperatureLevel < this.state.supportedTemperatureLevels.length) {
+            device.log.info(`MatterbridgeLevelTemperatureControlServer: setTemperature called setting selectedTemperatureLevel to ${request.targetTemperatureLevel}: ${this.state.supportedTemperatureLevels[request.targetTemperatureLevel]}`);
+            this.state.selectedTemperatureLevel = request.targetTemperatureLevel;
+        }
+        else {
+            device.log.error(`MatterbridgeLevelTemperatureControlServer: setTemperature called with invalid targetTemperatureLevel ${request.targetTemperatureLevel}`);
+        }
+    }
+}
+class MatterbridgeNumberTemperatureControlServer extends TemperatureControlServer.with(TemperatureControl.Feature.TemperatureNumber) {
+    initialize() {
+        const device = this.endpoint.stateOf(MatterbridgeServer).deviceCommand;
+        device.log.info('MatterbridgeNumberTemperatureControlServer initialized');
+    }
+    setTemperature(request) {
+        const device = this.endpoint.stateOf(MatterbridgeServer).deviceCommand;
+        if (request.targetTemperature !== undefined && request.targetTemperature >= this.state.minTemperature && request.targetTemperature <= this.state.maxTemperature) {
+            device.log.info(`MatterbridgeNumberTemperatureControlServer: setTemperature called setting temperatureSetpoint to ${request.targetTemperature}`);
+            this.state.temperatureSetpoint = request.targetTemperature;
+        }
+        else {
+            device.log.error(`MatterbridgeNumberTemperatureControlServer: setTemperature called with invalid targetTemperature ${request.targetTemperature}`);
+        }
+    }
+}
+class MatterbridgeLaundryWasherModeServer extends LaundryWasherModeServer {
+    initialize() {
+        const device = this.endpoint.stateOf(MatterbridgeServer).deviceCommand;
+        device.log.info(`LaundryWasherModeServer initialized: currentMode is ${this.state.currentMode}`);
+        this.reactTo(this.agent.get(MatterbridgeOnOffServer).events.onOff$Changed, this.handleOnOffChange);
+    }
+    handleOnOffChange(onOff) {
+        const device = this.endpoint.stateOf(MatterbridgeServer).deviceCommand;
+        if (onOff === false) {
+            device.log.notice('OnOffServer changed to OFF: setting Dead Front state to Manufacturer Specific');
+            this.state.currentMode = 2;
+        }
+    }
+    changeToMode(request) {
+        const device = this.endpoint.stateOf(MatterbridgeServer).deviceCommand;
+        const supportedMode = this.state.supportedModes.find((supportedMode) => supportedMode.mode === request.newMode);
+        if (supportedMode) {
+            device.log.info(`LaundryWasherModeServer: changeToMode called with mode ${supportedMode.mode} = ${supportedMode.label}`);
+            this.state.currentMode = request.newMode;
+            return { status: ModeBase.ModeChangeStatus.Success, statusText: 'Success' };
+        }
+        else {
+            device.log.error(`LaundryWasherModeServer: changeToMode called with invalid mode ${request.newMode}`);
+            return { status: ModeBase.ModeChangeStatus.InvalidInMode, statusText: 'Invalid mode' };
+        }
+    }
+}

package/dist/matterbridgeBehaviors.js

@@ -581,9 +581,7 @@ export class MatterbridgeServiceAreaServer extends ServiceAreaServer {
         }
         device.selectAreas({ newAreas });
         this.state.selectedAreas = newAreas;
-        this.state.currentArea = newAreas[0];
         device.log.info(`MatterbridgeServiceAreaServer selectAreas called with: ${newAreas.map((area) => area.toString()).join(', ')}`);
-        device.selectAreas({ newAreas });
         return { status: ServiceArea.SelectAreasStatus.Success, statusText: 'Succesfully selected new areas' };
     }
 }

package/dist/matterbridgeEndpointHelpers.js

@@ -384,7 +384,7 @@ export function getClusterId(endpoint, cluster) {
 }
 export function getAttributeId(endpoint, cluster, attribute) {
     const clusterBehavior = endpoint.behaviors.supported[lowercaseFirstLetter(cluster)];
-    return clusterBehavior?.cluster.attributes[lowercaseFirstLetter(attribute)]?.id;
+    return clusterBehavior?.cluster?.attributes[lowercaseFirstLetter(attribute)]?.id;
 }
 export function getAttribute(endpoint, cluster, attribute, log) {
     const clusterName = getBehavior(endpoint, cluster)?.id;

package/npm-shrinkwrap.json

@@ -1,12 +1,12 @@
 {
   "name": "matterbridge",
-  "version": "3.0.4-dev-20250525-b1cbfb7",
+  "version": "3.0.5-dev-20250526-422f029",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "matterbridge",
-      "version": "3.0.4-dev-20250525-b1cbfb7",
+      "version": "3.0.5-dev-20250526-422f029",
       "license": "Apache-2.0",
       "dependencies": {
         "@matter/main": "0.13.0",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "matterbridge",
-  "version": "3.0.4-dev-20250525-b1cbfb7",
+  "version": "3.0.5-dev-20250526-422f029",
   "description": "Matterbridge plugin manager for Matter",
   "author": "https://github.com/Luligu",
   "license": "Apache-2.0",