npm - matterbridge-example-dynamic-platform - Versions diffs - 1.1.9 → 1.2.0-edge.10 - Mend

matterbridge-example-dynamic-platform 1.1.9 → 1.2.0-edge.10

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (7) hide show

package/CHANGELOG.md CHANGED Viewed

@@ -8,6 +8,30 @@ 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>
+## [1.2.0] - 2025-04-??
+### Added
+- [platform]: Added OnOff Mounted Switch device (supported by SmartThings, Alexa, Home Assistant).
+- [platform]: Added Dimmer Mounted Switch device (supported by SmartThings, Alexa, Home Assistant).
+- [platform]: Added Robot Vacuum Cleaner device (supported by SmartThings, Alexa, Home Assistant and Apple Home).
+- [platform]: Added Laundry Washer device (supported by SmartThings, Alexa and Home Assistant).
+- [platform]: Added Laundry Dryer device (supported by SmartThings, Alexa and Home Assistant).
+- [platform]: Added Dishwasher device (supported by SmartThings, Alexa and Home Assistant).
+- [platform]: Added Refrigerator device (supported by SmartThings, Alexa and Home Assistant).
+- [platform]: Added Oven device (supported by SmartThings, Alexa and Home Assistant).
+- [platform]: Added Microwave Oven device (supported by SmartThings, Alexa and Home Assistant).
+- [platform]: Added Extractor Hood device (supported by SmartThings, Alexa and Home Assistant).
+- [platform]: Added Cooktop device (supported by SmartThings, Alexa and Home Assistant).
+### Changed
+- [package]: Updated dependencies.
+<a href="https://www.buymeacoffee.com/luligugithub">
+  <img src="bmc-button.svg" alt="Buy me a coffee" width="80">
+</a>
 ## [1.1.9] - 2025-04-07
 ### Added

package/dist/appliances.js ADDED Viewed

@@ -0,0 +1,530 @@
+import { MatterbridgeEndpoint, MatterbridgeServer, MatterbridgeOnOffServer, RefrigeratorTag, PositionTag, laundryWasher, laundryDryer, dishwasher, refrigerator, temperatureControlledCabinetCooler, oven, temperatureControlledCabinetHeater, microwaveOven, extractorHood, cooktop, cookSurface, } from 'matterbridge';
+import { ClusterBehavior } from 'matterbridge/matter';
+import { OperationalState, TemperatureControl, DishwasherMode, LaundryWasherControls, LaundryWasherMode, LaundryDryerControls, OvenMode, ModeBase, RefrigeratorAndTemperatureControlledCabinetMode, MicrowaveOvenMode, MicrowaveOvenControl, OvenCavityOperationalState, } from 'matterbridge/matter/clusters';
+import { DishwasherAlarmServer, LaundryDryerControlsServer, LaundryWasherControlsServer, MicrowaveOvenControlBehavior, MicrowaveOvenModeServer, OperationalStateBehavior, TemperatureControlBehavior, } from 'matterbridge/matter/behaviors';
+export class Appliances extends MatterbridgeEndpoint {
+    constructor(deviceType, name, serial) {
+        super(deviceType, { uniqueStorageKey: `${name}-${serial}` }, true);
+        if (deviceType.code === laundryWasher.code) {
+            this.createDefaultIdentifyClusterServer();
+            this.createDefaultBasicInformationClusterServer(name, serial, 0xfff1, 'Matterbridge', 0x8000, 'Laundry Washer');
+            this.createDeadFrontOnOffClusterServer();
+            this.createLevelTemperatureControlClusterServer(3, ['Cold', '30°', '40°', '60°', '80°']);
+            this.createDefaultLaundryWasherModeClusterServer();
+            this.createSpinLaundryWasherControlsClusterServer(3, ['400', '800', '1200', '1600']);
+            this.createDefaultOperationalStateClusterServer(OperationalState.OperationalStateEnum.Stopped);
+        }
+        else if (deviceType.code === laundryDryer.code) {
+            this.createDefaultIdentifyClusterServer();
+            this.createDefaultBasicInformationClusterServer(name, serial, 0xfff1, 'Matterbridge', 0x8000, 'Laundry Dryer');
+            this.createDeadFrontOnOffClusterServer();
+            this.createLevelTemperatureControlClusterServer(3, ['Cold', '30°', '40°', '60°', '80°']);
+            this.createDefaultLaundryWasherModeClusterServer();
+            this.createDefaultLaundryDryerControlsClusterServer(1);
+            this.createDefaultOperationalStateClusterServer(OperationalState.OperationalStateEnum.Stopped);
+        }
+        else if (deviceType.code === dishwasher.code) {
+            this.createDefaultIdentifyClusterServer();
+            this.createDefaultBasicInformationClusterServer(name, serial, 0xfff1, 'Matterbridge', 0x8000, 'Dishwasher');
+            this.createDeadFrontOnOffClusterServer();
+            this.createLevelTemperatureControlClusterServer(1, ['Cold', '30°', '40°', '60°']);
+            this.createDefaultDishwasherModeClusterServer();
+            this.createDefaultDishwasherAlarmClusterServer();
+            this.createDefaultOperationalStateClusterServer(OperationalState.OperationalStateEnum.Stopped);
+        }
+        else if (deviceType.name === refrigerator.name) {
+            this.createDefaultIdentifyClusterServer();
+            this.createDefaultBasicInformationClusterServer(name, serial, 0xfff1, 'Matterbridge', 0x8000, 'Refrigerator');
+            const refrigerator = this.addChildDeviceType('Refrigerator', temperatureControlledCabinetCooler, { tagList: [{ mfgCode: null, namespaceId: RefrigeratorTag.Refrigerator.namespaceId, tag: RefrigeratorTag.Refrigerator.tag, label: RefrigeratorTag.Refrigerator.label }] }, true);
+            refrigerator.log.logName = `Refrigerator (cabinet Refrigerator)`;
+            refrigerator.createDefaultIdentifyClusterServer();
+            Appliances.createLevelTemperatureControlClusterServer(refrigerator, 2, ['Level 1', 'Level 2', 'Level 3', 'Level 4', 'Level 5']);
+            refrigerator.createDefaultTemperatureMeasurementClusterServer(1000);
+            Appliances.createDefaultRefrigeratorAndTemperatureControlledCabinetModeClusterServer(refrigerator, 1);
+            const freezer = this.addChildDeviceType('Freezer', temperatureControlledCabinetCooler, { tagList: [{ mfgCode: null, namespaceId: RefrigeratorTag.Freezer.namespaceId, tag: RefrigeratorTag.Freezer.tag, label: RefrigeratorTag.Freezer.label }] }, true);
+            freezer.log.logName = `Refrigerator (cabinet Freezer)`;
+            freezer.createDefaultIdentifyClusterServer();
+            Appliances.createLevelTemperatureControlClusterServer(freezer, 2, ['Level 1', 'Level 2', 'Level 3', 'Level 4', 'Level 5']);
+            freezer.createDefaultTemperatureMeasurementClusterServer(-2000);
+            Appliances.createDefaultRefrigeratorAndTemperatureControlledCabinetModeClusterServer(freezer, 1);
+        }
+        else if (deviceType.name === oven.name) {
+            this.createDefaultIdentifyClusterServer();
+            this.createDefaultBasicInformationClusterServer(name, serial, 0xfff1, 'Matterbridge', 0x8000, 'Oven');
+            const cabinettop = this.addChildDeviceType('Oven (top)', temperatureControlledCabinetHeater, { tagList: [{ mfgCode: null, namespaceId: PositionTag.Top.namespaceId, tag: PositionTag.Top.tag, label: PositionTag.Top.label }] }, true);
+            cabinettop.log.logName = `Oven (top)`;
+            cabinettop.createDefaultIdentifyClusterServer();
+            Appliances.createLevelTemperatureControlClusterServer(cabinettop, 2, ['Defrost', '180°', '200°', '250°', '300°']);
+            cabinettop.createDefaultTemperatureMeasurementClusterServer(20000);
+            Appliances.createDefaultOvenModeClusterServer(cabinettop, 1);
+            const cabinetbottom = this.addChildDeviceType('Oven (bottom)', temperatureControlledCabinetHeater, { tagList: [{ mfgCode: null, namespaceId: PositionTag.Bottom.namespaceId, tag: PositionTag.Bottom.tag, label: PositionTag.Bottom.label }] }, true);
+            cabinetbottom.log.logName = `Oven (bottom)`;
+            cabinetbottom.createDefaultIdentifyClusterServer();
+            Appliances.createLevelTemperatureControlClusterServer(cabinetbottom, 2, ['Defrost', '180°', '200°', '250°', '300°']);
+            cabinetbottom.createDefaultTemperatureMeasurementClusterServer(30000);
+            Appliances.createDefaultOvenModeClusterServer(cabinetbottom, 1);
+        }
+        else if (deviceType.name === microwaveOven.name) {
+            this.createDefaultIdentifyClusterServer();
+            this.createDefaultBasicInformationClusterServer(name, serial, 0xfff1, 'Matterbridge', 0x8000, 'Microwave Oven');
+            this.createDefaultOperationalStateClusterServer(OperationalState.OperationalStateEnum.Stopped);
+            this.createDefaultMicrowaveOvenModeClusterServer();
+            this.createDefaultMicrowaveOvenControlClusterServer();
+        }
+        else if (deviceType.name === extractorHood.name) {
+            this.createDefaultIdentifyClusterServer();
+            this.createDefaultBasicInformationClusterServer(name, serial, 0xfff1, 'Matterbridge', 0x8000, 'Extractor Hood');
+            this.createBaseFanControlClusterServer();
+            this.createDefaultHepaFilterMonitoringClusterServer();
+            this.createDefaultActivatedCarbonFilterMonitoringClusterServer();
+        }
+        else if (deviceType.name === cooktop.name) {
+            this.createDefaultIdentifyClusterServer();
+            this.createDefaultBasicInformationClusterServer(name, serial, 0xfff1, 'Matterbridge', 0x8000, 'Cooktop');
+            this.createOffOnlyOnOffClusterServer(true);
+            const cookSurface1 = this.addChildDeviceType('Surface 1', cookSurface, { tagList: [{ mfgCode: null, namespaceId: PositionTag.Left.namespaceId, tag: PositionTag.Left.tag, label: PositionTag.Left.label }] }, true);
+            cookSurface1.log.logName = `Cook surface (right)`;
+            cookSurface1.createDefaultIdentifyClusterServer();
+            Appliances.createLevelTemperatureControlClusterServer(cookSurface1, 2, ['Level 1', 'Level 2', 'Level 3', 'Level 4', 'Level 5']);
+            cookSurface1.createDefaultTemperatureMeasurementClusterServer(10000);
+            cookSurface1.createOffOnlyOnOffClusterServer(true);
+            const cookSurface2 = this.addChildDeviceType('Surface 2', cookSurface, { tagList: [{ mfgCode: null, namespaceId: PositionTag.Right.namespaceId, tag: PositionTag.Right.tag, label: PositionTag.Right.label }] }, true);
+            cookSurface2.log.logName = `Cook surface (left)`;
+            cookSurface2.createDefaultIdentifyClusterServer();
+            Appliances.createLevelTemperatureControlClusterServer(cookSurface2, 3, ['Level 1', 'Level 2', 'Level 3', 'Level 4', 'Level 5']);
+            cookSurface2.createDefaultTemperatureMeasurementClusterServer(12000);
+            cookSurface2.createOffOnlyOnOffClusterServer(true);
+            this.eventsOf(MatterbridgeOnOffServer).onOff$Changed.on(async (value) => {
+                if (!value) {
+                    this.log.notice('Turning off all cook surfaces');
+                    await cookSurface1.setStateOf(MatterbridgeOnOffServer, { onOff: false });
+                    await cookSurface2.setStateOf(MatterbridgeOnOffServer, { onOff: false });
+                }
+            });
+        }
+    }
+    createDefaultOperationalStateClusterServer(operationalState = OperationalState.OperationalStateEnum.Stopped) {
+        this.behaviors.require(MatterbridgeOperationalStateServer, {
+            phaseList: [],
+            currentPhase: null,
+            operationalStateList: [
+                { operationalStateId: OperationalState.OperationalStateEnum.Stopped, operationalStateLabel: 'Stopped' },
+                { operationalStateId: OperationalState.OperationalStateEnum.Running, operationalStateLabel: 'Running' },
+                { operationalStateId: OperationalState.OperationalStateEnum.Paused, operationalStateLabel: 'Paused' },
+                { operationalStateId: OperationalState.OperationalStateEnum.Error, operationalStateLabel: 'Error' },
+            ],
+            operationalState,
+            operationalError: { errorStateId: OperationalState.ErrorState.NoError, errorStateLabel: 'No error', errorStateDetails: 'Fully operational' },
+        });
+        return this;
+    }
+    createDefaultOvenCavityOperationalStateClusterServer(operationalState = OperationalState.OperationalStateEnum.Stopped) {
+        this.behaviors.require(OvenCavityOperationalStateServer, {
+            phaseList: [],
+            currentPhase: null,
+            operationalStateList: [
+                { operationalStateId: OperationalState.OperationalStateEnum.Stopped, operationalStateLabel: 'Stopped' },
+                { operationalStateId: OperationalState.OperationalStateEnum.Running, operationalStateLabel: 'Running' },
+                { operationalStateId: OperationalState.OperationalStateEnum.Error, operationalStateLabel: 'Error' },
+            ],
+            operationalState,
+            operationalError: { errorStateId: OperationalState.ErrorState.NoError, errorStateLabel: 'No error', errorStateDetails: 'Fully operational' },
+        });
+        return this;
+    }
+    static createDefaultRefrigeratorAndTemperatureControlledCabinetModeClusterServer(endpoint, currentMode) {
+        endpoint.behaviors.require(RefrigeratorAndTemperatureControlledCabinetModeServer, {
+            supportedModes: [
+                { label: 'Auto', mode: 0, modeTags: [{ value: RefrigeratorAndTemperatureControlledCabinetMode.ModeTag.Auto }] },
+                { label: 'RapidCool', mode: 1, modeTags: [{ value: RefrigeratorAndTemperatureControlledCabinetMode.ModeTag.RapidCool }] },
+                { label: 'RapidFreeze', mode: 2, modeTags: [{ value: RefrigeratorAndTemperatureControlledCabinetMode.ModeTag.RapidFreeze }] },
+            ],
+            currentMode,
+        });
+        return endpoint;
+    }
+    static createDefaultOvenModeClusterServer(endpoint, currentMode) {
+        endpoint.behaviors.require(OvenModeServer, {
+            supportedModes: [
+                { label: 'Bake', mode: 1, modeTags: [{ value: OvenMode.ModeTag.Bake }] },
+                { label: 'Convection', mode: 2, modeTags: [{ value: OvenMode.ModeTag.Convection }] },
+                { label: 'Grill', mode: 3, modeTags: [{ value: OvenMode.ModeTag.Grill }] },
+                { label: 'Roast', mode: 4, modeTags: [{ value: OvenMode.ModeTag.Roast }] },
+                { label: 'Clean', mode: 5, modeTags: [{ value: OvenMode.ModeTag.Clean }] },
+                { label: 'Convection Bake', mode: 6, modeTags: [{ value: OvenMode.ModeTag.ConvectionBake }] },
+                { label: 'Convection Roast', mode: 7, modeTags: [{ value: OvenMode.ModeTag.ConvectionRoast }] },
+                { label: 'Warming', mode: 8, modeTags: [{ value: OvenMode.ModeTag.Warming }] },
+                { label: 'Proofing', mode: 9, modeTags: [{ value: OvenMode.ModeTag.Proofing }] },
+                { label: 'Steam', mode: 10, modeTags: [{ value: OvenMode.ModeTag.Steam }] },
+            ],
+            currentMode,
+        });
+        return endpoint;
+    }
+    createDefaultDishwasherModeClusterServer(currentMode) {
+        this.behaviors.require(DishwasherModeServer, {
+            supportedModes: [
+                { label: 'Light', mode: 1, modeTags: [{ value: DishwasherMode.ModeTag.Light }] },
+                { label: 'Normal', mode: 2, modeTags: [{ value: DishwasherMode.ModeTag.Normal }] },
+                { label: 'Heavy', mode: 3, modeTags: [{ value: DishwasherMode.ModeTag.Heavy }] },
+            ],
+            currentMode,
+        });
+        return this;
+    }
+    createDefaultLaundryWasherModeClusterServer(currentMode) {
+        this.behaviors.require(LaundryWasherModeServer, {
+            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 }] },
+            ],
+            currentMode,
+        });
+        return this;
+    }
+    createDefaultMicrowaveOvenModeClusterServer(currentMode, supportedModes) {
+        this.behaviors.require(MicrowaveOvenModeServer, {
+            supportedModes: supportedModes ?? [
+                { label: 'Auto', mode: 1, modeTags: [{ value: MicrowaveOvenMode.ModeTag.Auto }] },
+                { label: 'Quick', mode: 2, modeTags: [{ value: MicrowaveOvenMode.ModeTag.Quick }] },
+                { label: 'Quiet', mode: 3, modeTags: [{ value: MicrowaveOvenMode.ModeTag.Quiet }] },
+                { label: 'Min', mode: 4, modeTags: [{ value: MicrowaveOvenMode.ModeTag.Min }] },
+                { label: 'Max', mode: 5, modeTags: [{ value: MicrowaveOvenMode.ModeTag.Max }] },
+                { label: 'Normal', mode: 6, modeTags: [{ value: MicrowaveOvenMode.ModeTag.Normal }] },
+                { label: 'Defrost', mode: 7, modeTags: [{ value: MicrowaveOvenMode.ModeTag.Defrost }] },
+            ],
+            currentMode: currentMode ?? 1,
+        });
+        return this;
+    }
+    createDefaultMicrowaveOvenControlClusterServer(selectedWattIndex = 5, supportedWatts = [100, 200, 300, 400, 500, 600, 700, 800, 900, 1000], cookTime = 60, maxCookTime = 3600) {
+        this.behaviors.require(MatterbridgeMicrowaveOvenControlServer.with(MicrowaveOvenControl.Feature.PowerInWatts), {
+            supportedWatts,
+            selectedWattIndex,
+            cookTime,
+            maxCookTime,
+        });
+        return this;
+    }
+    createSpinLaundryWasherControlsClusterServer(spinSpeedCurrent, spinSpeeds) {
+        this.behaviors.require(LaundryWasherControlsServer.with(LaundryWasherControls.Feature.Spin), {
+            spinSpeeds: spinSpeeds ?? ['400', '800', '1200', '1600'],
+            spinSpeedCurrent,
+        });
+        return this;
+    }
+    createRinseLaundryWasherControlsClusterServer(numberOfRinses, supportedRinses) {
+        this.behaviors.require(LaundryWasherControlsServer.with(LaundryWasherControls.Feature.Rinse), {
+            supportedRinses: supportedRinses ?? [
+                LaundryWasherControls.NumberOfRinses.None,
+                LaundryWasherControls.NumberOfRinses.Normal,
+                LaundryWasherControls.NumberOfRinses.Extra,
+                LaundryWasherControls.NumberOfRinses.Max,
+            ],
+            numberOfRinses,
+        });
+        return this;
+    }
+    createDefaultLaundryDryerControlsClusterServer(selectedDrynessLevel, supportedDrynessLevels) {
+        this.behaviors.require(LaundryDryerControlsServer, {
+            supportedDrynessLevels: supportedDrynessLevels ?? [
+                LaundryDryerControls.DrynessLevel.Low,
+                LaundryDryerControls.DrynessLevel.Normal,
+                LaundryDryerControls.DrynessLevel.Extra,
+                LaundryDryerControls.DrynessLevel.Max,
+            ],
+            selectedDrynessLevel,
+        });
+        return this;
+    }
+    createDefaultDishwasherAlarmClusterServer() {
+        this.behaviors.require(DishwasherAlarmServer, {
+            mask: { inflowError: true, drainError: true, doorError: true, tempTooLow: true, tempTooHigh: true, waterLevelError: true },
+            state: { inflowError: false, drainError: false, doorError: false, tempTooLow: false, tempTooHigh: false, waterLevelError: false },
+            supported: { inflowError: true, drainError: true, doorError: true, tempTooLow: true, tempTooHigh: true, waterLevelError: true },
+        });
+        return this;
+    }
+    createLevelTemperatureControlClusterServer(selectedTemperatureLevel = 1, supportedTemperatureLevels = ['Cold', 'Warm', 'Hot']) {
+        this.behaviors.require(MatterbridgeLevelTemperatureControlServer.with(TemperatureControl.Feature.TemperatureLevel), {
+            selectedTemperatureLevel,
+            supportedTemperatureLevels,
+        });
+        return this;
+    }
+    static createLevelTemperatureControlClusterServer(endpoint, selectedTemperatureLevel = 1, supportedTemperatureLevels = ['Cold', 'Warm', 'Hot']) {
+        endpoint.behaviors.require(MatterbridgeLevelTemperatureControlServer.with(TemperatureControl.Feature.TemperatureLevel), {
+            selectedTemperatureLevel,
+            supportedTemperatureLevels,
+        });
+        return endpoint;
+    }
+    createNumberTemperatureControlClusterServer(temperatureSetpoint, minTemperature, maxTemperature, step = 1) {
+        this.behaviors.require(MatterbridgeNumberTemperatureControlServer.with(TemperatureControl.Feature.TemperatureNumber, TemperatureControl.Feature.TemperatureStep), {
+            temperatureSetpoint,
+            minTemperature,
+            maxTemperature,
+            step,
+        });
+        return this;
+    }
+    static createNumberTemperatureControlClusterServer(endpoint, temperatureSetpoint, minTemperature, maxTemperature, step = 1) {
+        endpoint.behaviors.require(MatterbridgeNumberTemperatureControlServer.with(TemperatureControl.Feature.TemperatureNumber, TemperatureControl.Feature.TemperatureStep), {
+            temperatureSetpoint,
+            minTemperature,
+            maxTemperature,
+            step,
+        });
+        return endpoint;
+    }
+}
+class MatterbridgeOperationalStateServer extends OperationalStateBehavior {
+    initialize() {
+        const device = this.endpoint.stateOf(MatterbridgeServer).deviceCommand;
+        device.log.info('MatterbridgeOperationalStateServer initialized: setting operational state to Stopped');
+        this.state.operationalState = OperationalState.OperationalStateEnum.Stopped;
+        this.state.operationalError = { errorStateId: OperationalState.ErrorState.NoError, errorStateLabel: 'No error', errorStateDetails: 'Fully operational' };
+    }
+    pause() {
+        const device = this.endpoint.stateOf(MatterbridgeServer).deviceCommand;
+        device.log.info('MatterbridgeOperationalStateServer: pause called setting operational state to Paused');
+        this.state.operationalState = OperationalState.OperationalStateEnum.Paused;
+        this.state.operationalError = { errorStateId: OperationalState.ErrorState.NoError, errorStateLabel: 'No error', errorStateDetails: 'Fully operational' };
+        return {
+            commandResponseState: { errorStateId: OperationalState.ErrorState.NoError, errorStateLabel: 'No error', errorStateDetails: 'Fully operational' },
+        };
+    }
+    stop() {
+        const device = this.endpoint.stateOf(MatterbridgeServer).deviceCommand;
+        device.log.info('MatterbridgeOperationalStateServer: stop called setting operational state to Stopped');
+        this.state.operationalState = OperationalState.OperationalStateEnum.Stopped;
+        this.state.operationalError = { errorStateId: OperationalState.ErrorState.NoError, errorStateLabel: 'No error', errorStateDetails: 'Fully operational' };
+        return {
+            commandResponseState: { errorStateId: OperationalState.ErrorState.NoError, errorStateLabel: 'No error', errorStateDetails: 'Fully operational' },
+        };
+    }
+    start() {
+        const device = this.endpoint.stateOf(MatterbridgeServer).deviceCommand;
+        device.log.info('MatterbridgeOperationalStateServer: start called setting operational state to Running');
+        this.state.operationalState = OperationalState.OperationalStateEnum.Running;
+        this.state.operationalError = { errorStateId: OperationalState.ErrorState.NoError, errorStateLabel: 'No error', errorStateDetails: 'Fully operational' };
+        return {
+            commandResponseState: { errorStateId: OperationalState.ErrorState.NoError, errorStateLabel: 'No error', errorStateDetails: 'Fully operational' },
+        };
+    }
+    resume() {
+        const device = this.endpoint.stateOf(MatterbridgeServer).deviceCommand;
+        device.log.info('MatterbridgeOperationalStateServer: resume called setting operational state to Running');
+        this.state.operationalState = OperationalState.OperationalStateEnum.Running;
+        this.state.operationalError = { errorStateId: OperationalState.ErrorState.NoError, errorStateLabel: 'No error', errorStateDetails: 'Fully operational' };
+        return {
+            commandResponseState: { errorStateId: OperationalState.ErrorState.NoError, errorStateLabel: 'No error', errorStateDetails: 'Fully operational' },
+        };
+    }
+}
+class MatterbridgeLevelTemperatureControlServer extends TemperatureControlBehavior.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 TemperatureControlBehavior.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 MatterbridgeMicrowaveOvenControlServer extends MicrowaveOvenControlBehavior.with(MicrowaveOvenControl.Feature.PowerInWatts) {
+    initialize() {
+        const device = this.endpoint.stateOf(MatterbridgeServer).deviceCommand;
+        device.log.info('MatterbridgeMicrowaveOvenControlServer initialized');
+    }
+    setCookingParameters(request) {
+        const device = this.endpoint.stateOf(MatterbridgeServer).deviceCommand;
+        if (request.cookMode !== undefined) {
+            device.log.info(`MatterbridgeMicrowaveOvenControlServer: setCookingParameters called setting cookMode to ${request.cookMode}`);
+            this.endpoint.setStateOf(MicrowaveOvenModeServer, { currentMode: request.cookMode });
+        }
+        else {
+            device.log.info(`MatterbridgeMicrowaveOvenControlServer: setCookingParameters called with no cookMode so set to Normal`);
+            this.endpoint.setStateOf(MicrowaveOvenModeServer, { currentMode: 6 });
+        }
+        if (request.cookTime !== undefined && request.cookTime >= 0 && request.cookTime <= this.state.maxCookTime) {
+            device.log.info(`MatterbridgeMicrowaveOvenControlServer: setCookingParameters called setting cookTime to ${request.cookTime}`);
+            this.state.cookTime = request.cookTime;
+        }
+        else {
+            device.log.info(`MatterbridgeMicrowaveOvenControlServer: setCookingParameters called with no cookTime so set to 30sec.`);
+            this.state.cookTime = 30;
+        }
+        if (request.wattSettingIndex !== undefined && request.wattSettingIndex >= 0 && request.wattSettingIndex < this.state.supportedWatts.length) {
+            device.log.info(`MatterbridgeMicrowaveOvenControlServer: setCookingParameters called setting selectedWattIndex to ${request.wattSettingIndex}`);
+            this.state.selectedWattIndex = request.wattSettingIndex;
+        }
+        else {
+            device.log.info(`MatterbridgeMicrowaveOvenControlServer: setCookingParameters called with no wattSettingIndex so set to the highest Watt setting for the selected CookMode`);
+            this.state.selectedWattIndex = this.state.supportedWatts.length - 1;
+        }
+    }
+    addMoreTime(request) {
+        const device = this.endpoint.stateOf(MatterbridgeServer).deviceCommand;
+        if (request.timeToAdd !== undefined && request.timeToAdd >= 0) {
+            device.log.info(`MatterbridgeMicrowaveOvenControlServer: addMoreTime called setting cookTime to ${this.state.cookTime + request.timeToAdd}`);
+            this.state.cookTime += request.timeToAdd;
+        }
+        else {
+            device.log.error(`MatterbridgeMicrowaveOvenControlServer: addMoreTime called with invalid cookTime ${request.timeToAdd}`);
+        }
+    }
+}
+export const OvenCavityOperationalStateBehavior = ClusterBehavior.withInterface().for(OvenCavityOperationalState.Cluster);
+export class OvenCavityOperationalStateServer extends OvenCavityOperationalStateBehavior {
+    initialize() {
+        const device = this.endpoint.stateOf(MatterbridgeServer).deviceCommand;
+        device.log.info('OvenCavityOperationalStateServer initialized: setting operational state to Stopped and operational error to No error');
+        this.state.operationalState = OperationalState.OperationalStateEnum.Stopped;
+        this.state.operationalError = { errorStateId: OperationalState.ErrorState.NoError, errorStateLabel: 'No error', errorStateDetails: 'Fully operational' };
+    }
+    stop() {
+        const device = this.endpoint.stateOf(MatterbridgeServer).deviceCommand;
+        device.log.info('OvenCavityOperationalStateServer: stop called setting operational state to Stopped and operational error to No error');
+        this.state.operationalState = OperationalState.OperationalStateEnum.Stopped;
+        this.state.operationalError = { errorStateId: OperationalState.ErrorState.NoError, errorStateLabel: 'No error', errorStateDetails: 'Fully operational' };
+        return {
+            commandResponseState: { errorStateId: OperationalState.ErrorState.NoError, errorStateLabel: 'No error', errorStateDetails: 'Fully operational' },
+        };
+    }
+    start() {
+        const device = this.endpoint.stateOf(MatterbridgeServer).deviceCommand;
+        device.log.info('OvenCavityOperationalStateServer: start called setting operational state to Running and operational error to No error');
+        this.state.operationalState = OperationalState.OperationalStateEnum.Running;
+        this.state.operationalError = { errorStateId: OperationalState.ErrorState.NoError, errorStateLabel: 'No error', errorStateDetails: 'Fully operational' };
+        return {
+            commandResponseState: { errorStateId: OperationalState.ErrorState.NoError, errorStateLabel: 'No error', errorStateDetails: 'Fully operational' },
+        };
+    }
+}
+export const RefrigeratorAndTemperatureControlledCabinetModeBehavior = ClusterBehavior.withInterface().for(RefrigeratorAndTemperatureControlledCabinetMode.Cluster);
+class RefrigeratorAndTemperatureControlledCabinetModeServer extends RefrigeratorAndTemperatureControlledCabinetModeBehavior {
+    initialize() {
+        const device = this.endpoint.stateOf(MatterbridgeServer).deviceCommand;
+        device.log.info('MatterbridgeRefrigeratorAndTemperatureControlledCabinetModeServer initialized: setting currentMode to 1');
+        this.state.currentMode = 1;
+    }
+    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(`MatterbridgeRefrigeratorAndTemperatureControlledCabinetModeServer: changeToMode called with mode ${supportedMode.mode} = ${supportedMode.label}`);
+            this.state.currentMode = request.newMode;
+            return { status: ModeBase.ModeChangeStatus.Success, statusText: 'Success' };
+        }
+        else {
+            device.log.info(`MatterbridgeRefrigeratorAndTemperatureControlledCabinetModeServer: changeToMode called with invalid mode ${request.newMode}`);
+            return { status: ModeBase.ModeChangeStatus.InvalidInMode, statusText: 'Invalid mode' };
+        }
+    }
+}
+export const OvenModeBehavior = ClusterBehavior.withInterface().for(OvenMode.Cluster);
+class OvenModeServer extends OvenModeBehavior {
+    initialize() {
+        const device = this.endpoint.stateOf(MatterbridgeServer).deviceCommand;
+        device.log.info('OvenModeServer initialized: setting currentMode to 3');
+        this.state.currentMode = 3;
+    }
+    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(`OvenModeServer: changeToMode called with mode ${supportedMode.mode} = ${supportedMode.label}`);
+            this.state.currentMode = request.newMode;
+            return { status: ModeBase.ModeChangeStatus.Success, statusText: 'Success' };
+        }
+        else {
+            device.log.info(`OvenModeServer: changeToMode called with invalid mode ${request.newMode}`);
+            return { status: ModeBase.ModeChangeStatus.InvalidInMode, statusText: 'Invalid mode' };
+        }
+    }
+}
+export const DishwasherModeBehavior = ClusterBehavior.withInterface().for(DishwasherMode.Cluster);
+class DishwasherModeServer extends DishwasherModeBehavior {
+    initialize() {
+        const device = this.endpoint.stateOf(MatterbridgeServer).deviceCommand;
+        device.log.info('DishwasherModeServer initialized: setting currentMode to 3');
+        this.state.currentMode = 2;
+        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.info('***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(`DishwasherModeServer: changeToMode called with mode ${supportedMode.mode} = ${supportedMode.label}`);
+            this.state.currentMode = request.newMode;
+            return { status: ModeBase.ModeChangeStatus.Success, statusText: 'Success' };
+        }
+        else {
+            device.log.error(`DishwasherModeServer: changeToMode called with invalid mode ${request.newMode}`);
+            return { status: ModeBase.ModeChangeStatus.InvalidInMode, statusText: 'Invalid mode' };
+        }
+    }
+}
+export const LaundryWasherModeBehavior = ClusterBehavior.withInterface().for(LaundryWasherMode.Cluster);
+class LaundryWasherModeServer extends LaundryWasherModeBehavior {
+    initialize() {
+        const device = this.endpoint.stateOf(MatterbridgeServer).deviceCommand;
+        device.log.info('LaundryWasherModeServer initialized: setting currentMode to 3');
+        this.state.currentMode = 2;
+        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/platform.js CHANGED Viewed

@@ -1,7 +1,9 @@
-import { MatterbridgeEndpoint, MatterbridgeDynamicPlatform, airConditioner, airQualitySensor, bridgedNode, colorTemperatureLight, coverDevice, dimmableLight, doorLockDevice, fanDevice, flowSensor, humiditySensor, onOffLight, onOffOutlet, onOffSwitch, powerSource, rainSensor, smokeCoAlarm, temperatureSensor, thermostatDevice, waterFreezeDetector, waterLeakDetector, airPurifier, pumpDevice, waterValve, genericSwitch, } from 'matterbridge';
+import { MatterbridgeEndpoint, MatterbridgeDynamicPlatform, airQualitySensor, bridgedNode, colorTemperatureLight, coverDevice, dimmableLight, doorLockDevice, fanDevice, flowSensor, humiditySensor, onOffLight, onOffOutlet, onOffSwitch, powerSource, rainSensor, smokeCoAlarm, temperatureSensor, thermostatDevice, waterFreezeDetector, waterLeakDetector, airPurifier, pumpDevice, waterValve, genericSwitch, airConditioner, laundryWasher, cooktop, extractorHood, microwaveOven, oven, refrigerator, dishwasher, laundryDryer, onOffMountedSwitch, dimmableMountedSwitch, extendedColorLight, } from 'matterbridge';
 import { isValidBoolean, isValidNumber } from 'matterbridge/utils';
 import { LocationTag } from 'matterbridge/matter';
 import { PowerSource, BooleanState, OnOff, LevelControl, AirQuality, CarbonDioxideConcentrationMeasurement, CarbonMonoxideConcentrationMeasurement, FlowMeasurement, ColorControl, DoorLock, FanControl, FormaldehydeConcentrationMeasurement, NitrogenDioxideConcentrationMeasurement, OzoneConcentrationMeasurement, Pm10ConcentrationMeasurement, Pm1ConcentrationMeasurement, Pm25ConcentrationMeasurement, RadonConcentrationMeasurement, RelativeHumidityMeasurement, RelativeHumidityMeasurementCluster, SmokeCoAlarm, TemperatureMeasurement, Thermostat, ThermostatCluster, TotalVolatileOrganicCompoundsConcentrationMeasurement, WindowCovering, } from 'matterbridge/matter/clusters';
+import { Appliances } from './appliances.js';
+import { Robot } from './robot.js';
 export class ExampleMatterbridgeDynamicPlatform extends MatterbridgeDynamicPlatform {
     switch;
     mountedOnOffSwitch;
@@ -48,6 +50,9 @@ export class ExampleMatterbridgeDynamicPlatform extends MatterbridgeDynamicPlatf
     airConditionerInterval;
     genericSwitchInterval;
     genericSwitchLastEvent = 'Release';
+    intervalOnOff = false;
+    intervalLevel = 0;
+    intervalColorTemperature = 147;
     bridgedDevices = new Map();
     fanModeLookup = ['Off', 'Low', 'Medium', 'High', 'On', 'Auto', 'Smart'];
     constructor(matterbridge, log, config) {
@@ -90,6 +95,65 @@ export class ExampleMatterbridgeDynamicPlatform extends MatterbridgeDynamicPlatf
             await this.switch?.setAttribute(OnOff.Cluster.id, 'onOff', false, this.switch.log);
             this.switch?.log.info('Command off called');
         });
+        this.mountedOnOffSwitch = new MatterbridgeEndpoint([onOffMountedSwitch, bridgedNode, powerSource], { uniqueStorageKey: 'OnOffMountedSwitch' }, this.config.debug)
+            .createDefaultIdentifyClusterServer()
+            .createDefaultGroupsClusterServer()
+            .createDefaultBridgedDeviceBasicInformationClusterServer('OnOff Mounted Switch', '0x298242164', 0xfff1, 'Matterbridge', 'Matterbridge OnOff Mounted Switch', parseInt(this.version.replace(/\D/g, '')), this.version === '' ? 'Unknown' : this.version, parseInt(this.matterbridge.matterbridgeVersion.replace(/\D/g, '')), this.matterbridge.matterbridgeVersion)
+            .createDefaultOnOffClusterServer()
+            .createDefaultPowerSourceRechargeableBatteryClusterServer(70);
+        this.setSelectDevice(this.mountedOnOffSwitch.serialNumber ?? '', this.mountedOnOffSwitch.deviceName ?? '', undefined, 'hub');
+        if (this.validateDevice(this.mountedOnOffSwitch.deviceName ?? '')) {
+            await this.registerDevice(this.mountedOnOffSwitch);
+            this.bridgedDevices.set(this.mountedOnOffSwitch.deviceName ?? '', this.mountedOnOffSwitch);
+        }
+        else {
+            this.mountedOnOffSwitch = undefined;
+        }
+        this.mountedOnOffSwitch?.addCommandHandler('identify', async ({ request: { identifyTime } }) => {
+            this.mountedOnOffSwitch?.log.info(`Command identify called identifyTime:${identifyTime}`);
+        });
+        this.mountedOnOffSwitch?.addCommandHandler('on', async () => {
+            await this.mountedOnOffSwitch?.setAttribute(OnOff.Cluster.id, 'onOff', true, this.mountedOnOffSwitch.log);
+            this.mountedOnOffSwitch?.log.info('Command on called');
+        });
+        this.mountedOnOffSwitch?.addCommandHandler('off', async () => {
+            await this.mountedOnOffSwitch?.setAttribute(OnOff.Cluster.id, 'onOff', false, this.mountedOnOffSwitch.log);
+            this.mountedOnOffSwitch?.log.info('Command off called');
+        });
+        this.mountedDimmerSwitch = new MatterbridgeEndpoint([dimmableMountedSwitch, bridgedNode, powerSource], { uniqueStorageKey: 'DimmerMountedSwitch' }, this.config.debug)
+            .createDefaultIdentifyClusterServer()
+            .createDefaultGroupsClusterServer()
+            .createDefaultBridgedDeviceBasicInformationClusterServer('Dimmer Mounted Switch', '0x22145578864', 0xfff1, 'Matterbridge', 'Matterbridge Dimmer Mounted Switch', parseInt(this.version.replace(/\D/g, '')), this.version === '' ? 'Unknown' : this.version, parseInt(this.matterbridge.matterbridgeVersion.replace(/\D/g, '')), this.matterbridge.matterbridgeVersion)
+            .createDefaultOnOffClusterServer()
+            .createDefaultLevelControlClusterServer()
+            .createDefaultPowerSourceRechargeableBatteryClusterServer(70);
+        this.setSelectDevice(this.mountedDimmerSwitch.serialNumber ?? '', this.mountedDimmerSwitch.deviceName ?? '', undefined, 'hub');
+        if (this.validateDevice(this.mountedDimmerSwitch.deviceName ?? '')) {
+            await this.registerDevice(this.mountedDimmerSwitch);
+            this.bridgedDevices.set(this.mountedDimmerSwitch.deviceName ?? '', this.mountedDimmerSwitch);
+        }
+        else {
+            this.mountedDimmerSwitch = undefined;
+        }
+        this.mountedDimmerSwitch?.addCommandHandler('identify', async ({ request: { identifyTime } }) => {
+            this.mountedDimmerSwitch?.log.info(`Command identify called identifyTime:${identifyTime}`);
+        });
+        this.mountedDimmerSwitch?.addCommandHandler('on', async () => {
+            await this.mountedDimmerSwitch?.setAttribute(OnOff.Cluster.id, 'onOff', true, this.mountedDimmerSwitch.log);
+            this.mountedDimmerSwitch?.log.info('Command on called');
+        });
+        this.mountedDimmerSwitch?.addCommandHandler('off', async () => {
+            await this.mountedDimmerSwitch?.setAttribute(OnOff.Cluster.id, 'onOff', false, this.mountedDimmerSwitch.log);
+            this.mountedDimmerSwitch?.log.info('Command off called');
+        });
+        this.mountedDimmerSwitch?.addCommandHandler('moveToLevel', async ({ request: { level } }) => {
+            await this.mountedDimmerSwitch?.setAttribute(LevelControl.Cluster.id, 'currentLevel', level, this.mountedDimmerSwitch.log);
+            this.mountedDimmerSwitch?.log.debug(`Command moveToLevel called request: ${level}`);
+        });
+        this.mountedDimmerSwitch?.addCommandHandler('moveToLevelWithOnOff', async ({ request: { level } }) => {
+            await this.mountedDimmerSwitch?.setAttribute(LevelControl.Cluster.id, 'currentLevel', level, this.mountedDimmerSwitch.log);
+            this.mountedDimmerSwitch?.log.debug(`Command moveToLevelWithOnOff called request: ${level}`);
+        });
         this.lightOnOff = new MatterbridgeEndpoint([onOffLight, bridgedNode, powerSource], { uniqueStorageKey: 'Light (on/off)' }, this.config.debug)
             .createDefaultIdentifyClusterServer()
             .createDefaultGroupsClusterServer()
@@ -121,7 +185,7 @@ export class ExampleMatterbridgeDynamicPlatform extends MatterbridgeDynamicPlatf
             .createDefaultBridgedDeviceBasicInformationClusterServer('Dimmer', '0x234554564', 0xfff1, 'Matterbridge', 'Matterbridge Dimmer', parseInt(this.version.replace(/\D/g, '')), this.version === '' ? 'Unknown' : this.version, parseInt(this.matterbridge.matterbridgeVersion.replace(/\D/g, '')), this.matterbridge.matterbridgeVersion)
             .createDefaultOnOffClusterServer()
             .createDefaultLevelControlClusterServer()
-            .createDefaultPowerSourceReplaceableBatteryClusterServer(70);
+            .createDefaultPowerSourceReplaceableBatteryClusterServer(70, PowerSource.BatChargeLevel.Ok, 2990, '2 x AA', 2);
         this.setSelectDevice(this.dimmer.serialNumber ?? '', this.dimmer.deviceName ?? '', undefined, 'hub');
         if (this.validateDevice(this.dimmer.deviceName ?? '')) {
             await this.registerDevice(this.dimmer);
@@ -149,7 +213,7 @@ export class ExampleMatterbridgeDynamicPlatform extends MatterbridgeDynamicPlatf
             await this.dimmer?.setAttribute(LevelControl.Cluster.id, 'currentLevel', level, this.dimmer.log);
             this.dimmer?.log.debug(`Command moveToLevelWithOnOff called request: ${level}`);
         });
-        this.light = new MatterbridgeEndpoint([colorTemperatureLight, bridgedNode, powerSource], { uniqueStorageKey: 'Light (XY, HS and CT)' }, this.config.debug)
+        this.light = new MatterbridgeEndpoint([extendedColorLight, bridgedNode, powerSource], { uniqueStorageKey: 'Light (XY, HS and CT)' }, this.config.debug)
             .createDefaultIdentifyClusterServer()
             .createDefaultGroupsClusterServer()
             .createDefaultBridgedDeviceBasicInformationClusterServer('Light (XY, HS and CT)', '0x23480564', 0xfff1, 'Matterbridge', 'Matterbridge Light', parseInt(this.version.replace(/\D/g, '')), this.version === '' ? 'Unknown' : this.version, parseInt(this.matterbridge.matterbridgeVersion.replace(/\D/g, '')), this.matterbridge.matterbridgeVersion)
@@ -258,7 +322,7 @@ export class ExampleMatterbridgeDynamicPlatform extends MatterbridgeDynamicPlatf
             await this.lightHS?.setAttribute(ColorControl.Cluster.id, 'colorTemperatureMireds', colorTemperatureMireds, this.lightHS?.log);
             this.lightHS?.log.debug(`Command moveToColorTemperature called request: ${colorTemperatureMireds}`);
         });
-        this.lightXY = new MatterbridgeEndpoint([colorTemperatureLight, bridgedNode, powerSource], { uniqueStorageKey: 'Light (XY, CT)' }, this.config.debug)
+        this.lightXY = new MatterbridgeEndpoint([extendedColorLight, bridgedNode, powerSource], { uniqueStorageKey: 'Light (XY, CT)' }, this.config.debug)
             .createDefaultIdentifyClusterServer()
             .createDefaultGroupsClusterServer()
             .createDefaultBridgedDeviceBasicInformationClusterServer('Light (XY, CT)', '0x23497564', 0xfff1, 'Matterbridge', 'Matterbridge Light', parseInt(this.version.replace(/\D/g, '')), this.version === '' ? 'Unknown' : this.version, parseInt(this.matterbridge.matterbridgeVersion.replace(/\D/g, '')), this.matterbridge.matterbridgeVersion)
@@ -554,7 +618,9 @@ export class ExampleMatterbridgeDynamicPlatform extends MatterbridgeDynamicPlatf
             .createDefaultFanControlClusterServer()
             .createDefaultTemperatureMeasurementClusterServer(20 * 100)
             .createDefaultRelativeHumidityMeasurementClusterServer(50 * 100)
-            .createDefaultPowerSourceWiredClusterServer();
+            .createDefaultPowerSourceWiredClusterServer()
+            .createDefaultActivatedCarbonFilterMonitoringClusterServer()
+            .createDefaultHepaFilterMonitoringClusterServer();
         this.setSelectDevice(this.airPurifier.serialNumber ?? '', this.airPurifier.deviceName ?? '', undefined, 'hub');
         if (this.validateDevice(this.airPurifier.deviceName ?? '')) {
             await this.registerDevice(this.airPurifier);
@@ -592,11 +658,12 @@ export class ExampleMatterbridgeDynamicPlatform extends MatterbridgeDynamicPlatf
             if (isValidNumber(newValue, 0, 100))
                 await this.airPurifier?.setAttribute(FanControl.Cluster.id, 'percentCurrent', newValue, this.airPurifier?.log);
         }, this.airPurifier.log);
-        this.airConditioner = new MatterbridgeEndpoint([airConditioner, bridgedNode, powerSource], { uniqueStorageKey: 'Air conditioner' }, this.config.debug)
-            .createDefaultBridgedDeviceBasicInformationClusterServer('Air conditioner', '0x96382864AC', 0xfff1, 'Matterbridge', 'Matterbridge Air conditioner', parseInt(this.version.replace(/\D/g, '')), this.version === '' ? 'Unknown' : this.version, parseInt(this.matterbridge.matterbridgeVersion.replace(/\D/g, '')), this.matterbridge.matterbridgeVersion)
+        this.airConditioner = new MatterbridgeEndpoint([airConditioner, bridgedNode, powerSource], { uniqueStorageKey: 'Air Conditioner' }, this.config.debug)
+            .createDefaultBridgedDeviceBasicInformationClusterServer('Air Conditioner', '0x96382864AC', 0xfff1, 'Matterbridge', 'Matterbridge Air Conditioner', parseInt(this.version.replace(/\D/g, '')), this.version === '' ? 'Unknown' : this.version, parseInt(this.matterbridge.matterbridgeVersion.replace(/\D/g, '')), this.matterbridge.matterbridgeVersion)
             .createDefaultIdentifyClusterServer()
             .createDeadFrontOnOffClusterServer(true)
             .createDefaultThermostatClusterServer(20, 18, 22)
+            .createDefaultThermostatUserInterfaceConfigurationClusterServer()
             .createDefaultFanControlClusterServer(FanControl.FanMode.Auto)
             .createDefaultTemperatureMeasurementClusterServer(20 * 100)
             .createDefaultRelativeHumidityMeasurementClusterServer(50 * 100)
@@ -615,8 +682,6 @@ export class ExampleMatterbridgeDynamicPlatform extends MatterbridgeDynamicPlatf
         });
         this.airConditioner?.addCommandHandler('on', async () => {
             this.airConditioner?.log.info('Command on called');
-            await this.airConditioner?.setAttribute(OnOff.Cluster.id, 'onOff', true, this.airConditioner?.log);
-            await this.airConditioner?.setAttribute(OnOff.Cluster.id, 'onOff', true, this.airConditioner?.log);
             await this.airConditioner?.setAttribute(ThermostatCluster.id, 'localTemperature', 20 * 100, this.airConditioner?.log);
             await this.airConditioner?.setAttribute(TemperatureMeasurement.Cluster.id, 'measuredValue', 20 * 100, this.airConditioner?.log);
             await this.airConditioner?.setAttribute(RelativeHumidityMeasurementCluster.id, 'measuredValue', 50 * 100, this.airConditioner?.log);
@@ -625,7 +690,6 @@ export class ExampleMatterbridgeDynamicPlatform extends MatterbridgeDynamicPlatf
         });
         this.airConditioner?.addCommandHandler('off', async () => {
             this.airConditioner?.log.info('Command off called');
-            await this.airConditioner?.setAttribute(OnOff.Cluster.id, 'onOff', false, this.airConditioner?.log);
             await this.airConditioner?.setAttribute(ThermostatCluster.id, 'localTemperature', null, this.airConditioner?.log);
             await this.airConditioner?.setAttribute(TemperatureMeasurement.Cluster.id, 'measuredValue', null, this.airConditioner?.log);
             await this.airConditioner?.setAttribute(RelativeHumidityMeasurementCluster.id, 'measuredValue', null, this.airConditioner?.log);
@@ -635,7 +699,8 @@ export class ExampleMatterbridgeDynamicPlatform extends MatterbridgeDynamicPlatf
         this.pump = new MatterbridgeEndpoint([pumpDevice, bridgedNode, powerSource], { uniqueStorageKey: 'Pump' }, this.config.debug)
             .createDefaultBridgedDeviceBasicInformationClusterServer('Pump', '0x96382864PUMP', 0xfff1, 'Matterbridge', 'Matterbridge Pump', parseInt(this.version.replace(/\D/g, '')), this.version === '' ? 'Unknown' : this.version, parseInt(this.matterbridge.matterbridgeVersion.replace(/\D/g, '')), this.matterbridge.matterbridgeVersion)
             .createDefaultIdentifyClusterServer()
-            .createDefaultOnOffClusterServer(true)
+            .createOnOffClusterServer()
+            .createLevelControlClusterServer()
             .createDefaultPumpConfigurationAndControlClusterServer()
             .createDefaultPowerSourceWiredClusterServer();
         this.setSelectDevice(this.pump.serialNumber ?? '', this.pump.deviceName ?? '', undefined, 'hub');
@@ -850,25 +915,82 @@ export class ExampleMatterbridgeDynamicPlatform extends MatterbridgeDynamicPlatf
         else {
             this.latchingSwitch = undefined;
         }
+        const robot = new Robot('Robot Vacuum', '1238777820');
+        this.setSelectDevice(robot.serialNumber ?? '', robot.deviceName ?? '', undefined, 'hub');
+        if (this.validateDevice(robot.deviceName ?? '')) {
+            await this.registerDevice(robot);
+            this.bridgedDevices.set(robot.deviceName ?? '', robot);
+        }
+        const laundryWasherDevice = new Appliances(laundryWasher, 'Laundry Washer', '1234567890');
+        this.setSelectDevice(laundryWasherDevice.serialNumber ?? '', laundryWasherDevice.deviceName ?? '', undefined, 'hub');
+        if (this.validateDevice(laundryWasherDevice.deviceName ?? '')) {
+            await this.registerDevice(laundryWasherDevice);
+            this.bridgedDevices.set(laundryWasherDevice.deviceName ?? '', laundryWasherDevice);
+        }
+        const laundryDryerDevice = new Appliances(laundryDryer, 'Laundry Dryer', '1235227890');
+        this.setSelectDevice(laundryDryerDevice.serialNumber ?? '', laundryDryerDevice.deviceName ?? '', undefined, 'hub');
+        if (this.validateDevice(laundryDryerDevice.deviceName ?? '')) {
+            await this.registerDevice(laundryDryerDevice);
+            this.bridgedDevices.set(laundryDryerDevice.deviceName ?? '', laundryDryerDevice);
+        }
+        const dishwasherDevice = new Appliances(dishwasher, 'Dishwasher', '0987654321');
+        this.setSelectDevice(dishwasherDevice.serialNumber ?? '', dishwasherDevice.deviceName ?? '', undefined, 'hub');
+        if (this.validateDevice(dishwasherDevice.deviceName ?? '')) {
+            await this.registerDevice(dishwasherDevice);
+            this.bridgedDevices.set(dishwasherDevice.deviceName ?? '', dishwasherDevice);
+        }
+        const refrigeratorDevice = new Appliances(refrigerator, 'Refrigerator', '9987654322');
+        this.setSelectDevice(refrigeratorDevice.serialNumber ?? '', refrigeratorDevice.deviceName ?? '', undefined, 'hub');
+        if (this.validateDevice(refrigeratorDevice.deviceName ?? '')) {
+            await this.registerDevice(refrigeratorDevice);
+            this.bridgedDevices.set(refrigeratorDevice.deviceName ?? '', refrigeratorDevice);
+        }
+        const ovenDevice = new Appliances(oven, 'Oven', '1298867891');
+        this.setSelectDevice(ovenDevice.serialNumber ?? '', ovenDevice.deviceName ?? '', undefined, 'hub');
+        if (this.validateDevice(ovenDevice.deviceName ?? '')) {
+            await this.registerDevice(ovenDevice);
+            this.bridgedDevices.set(ovenDevice.deviceName ?? '', ovenDevice);
+        }
+        const microwaveOvenDevice = new Appliances(microwaveOven, 'Microwave Oven', '1234567892');
+        this.setSelectDevice(microwaveOvenDevice.serialNumber ?? '', microwaveOvenDevice.deviceName ?? '', undefined, 'hub');
+        if (this.validateDevice(microwaveOvenDevice.deviceName ?? '')) {
+            await this.registerDevice(microwaveOvenDevice);
+            this.bridgedDevices.set(microwaveOvenDevice.deviceName ?? '', microwaveOvenDevice);
+        }
+        const extractorHoodDevice = new Appliances(extractorHood, 'Extractor Hood', '1234567893');
+        this.setSelectDevice(extractorHoodDevice.serialNumber ?? '', extractorHoodDevice.deviceName ?? '', undefined, 'hub');
+        if (this.validateDevice(extractorHoodDevice.deviceName ?? '')) {
+            await this.registerDevice(extractorHoodDevice);
+            this.bridgedDevices.set(extractorHoodDevice.deviceName ?? '', extractorHoodDevice);
+        }
+        const cooktopDevice = new Appliances(cooktop, 'Cooktop', '1255887894');
+        this.setSelectDevice(cooktopDevice.serialNumber ?? '', cooktopDevice.deviceName ?? '', undefined, 'hub');
+        if (this.validateDevice(cooktopDevice.deviceName ?? '')) {
+            await this.registerDevice(cooktopDevice);
+            this.bridgedDevices.set(cooktopDevice.deviceName ?? '', cooktopDevice);
+        }
     }
     async onConfigure() {
         await super.onConfigure();
         this.log.info('onConfigure called');
-        await this.switch?.setAttribute(OnOff.Cluster.id, 'onOff', false, this.switch.log);
-        this.switch?.log.info('Set switch initial onOff to false');
+        this.log.notice('<iframe width="500" height="500" src="https://www.youtube.com/embed/DLzxrzFCyOs?hl=en_US&version=3&rel=0&autoplay=1" frameborder="1" allowfullscreen></iframe>');
+        await this.switch?.setAttribute(OnOff.Cluster.id, 'onOff', this.intervalOnOff, this.switch.log);
+        await this.mountedOnOffSwitch?.setAttribute(OnOff.Cluster.id, 'onOff', this.intervalOnOff, this.mountedOnOffSwitch.log);
+        this.switch?.log.info(`Set switch initial onOff to ${this.intervalOnOff}`);
         if (this.config.useInterval) {
             this.switchInterval = setInterval(async () => {
-                const status = this.switch?.getAttribute(OnOff.Cluster.id, 'onOff', this.switch.log);
-                if (isValidBoolean(status)) {
-                    await this.switch?.setAttribute(OnOff.Cluster.id, 'onOff', !status, this.switch.log);
-                    this.switch?.log.info(`Set switch onOff to ${!status}`);
-                }
+                await this.switch?.setAttribute(OnOff.Cluster.id, 'onOff', this.intervalOnOff, this.switch.log);
+                await this.mountedOnOffSwitch?.setAttribute(OnOff.Cluster.id, 'onOff', this.intervalOnOff, this.mountedOnOffSwitch.log);
+                this.log.info(`Set switches onOff to ${this.intervalOnOff}`);
+                this.intervalOnOff = !this.intervalOnOff;
             }, 60 * 1000 + 100);
         }
         await this.lightOnOff?.setAttribute(OnOff.Cluster.id, 'onOff', false, this.lightOnOff.log);
         this.lightOnOff?.log.info('Set light initial onOff to false.');
         await this.dimmer?.setAttribute(OnOff.Cluster.id, 'onOff', false, this.dimmer.log);
         await this.dimmer?.setAttribute(LevelControl.Cluster.id, 'currentLevel', 1, this.dimmer.log);
+        await this.mountedDimmerSwitch?.setAttribute(OnOff.Cluster.id, 'onOff', false, this.mountedDimmerSwitch.log);
+        await this.mountedDimmerSwitch?.setAttribute(LevelControl.Cluster.id, 'currentLevel', 1, this.mountedDimmerSwitch.log);
         this.dimmer?.log.info(`Set dimmer initial onOff to false, currentLevel to 1.`);
         await this.light?.setAttribute(OnOff.Cluster.id, 'onOff', false, this.light.log);
         await this.light?.setAttribute(LevelControl.Cluster.id, 'currentLevel', 200, this.light.log);
@@ -895,42 +1017,48 @@ export class ExampleMatterbridgeDynamicPlatform extends MatterbridgeDynamicPlatf
         this.lightCT?.log.info('Set light CT initial onOff to true, currentLevel to 128, colorTemperatureMireds to 250.');
         if (this.config.useInterval) {
             this.lightInterval = setInterval(async () => {
-                const state = this.light?.getAttribute(OnOff.Cluster.id, 'onOff', this.light.log);
-                let level = this.light?.getAttribute(LevelControl.Cluster.id, 'currentLevel', this.light.log);
-                if (isValidBoolean(state) && isValidNumber(level, 0, 254)) {
-                    level += 10;
-                    if (level >= 250) {
-                        level = 1;
-                        await this.lightOnOff?.setAttribute(OnOff.Cluster.id, 'onOff', false, this.lightOnOff.log);
-                        await this.dimmer?.setAttribute(OnOff.Cluster.id, 'onOff', false, this.dimmer.log);
-                        await this.light?.setAttribute(OnOff.Cluster.id, 'onOff', false, this.light.log);
-                        await this.lightXY?.setAttribute(OnOff.Cluster.id, 'onOff', false, this.lightXY.log);
-                        await this.lightHS?.setAttribute(OnOff.Cluster.id, 'onOff', false, this.lightHS.log);
-                        await this.lightCT?.setAttribute(OnOff.Cluster.id, 'onOff', false, this.lightCT.log);
-                        this.log.info('Set lights onOff to false');
-                        await this.dimmer?.setAttribute(LevelControl.Cluster.id, 'currentLevel', level, this.dimmer.log);
-                        await this.light?.setAttribute(LevelControl.Cluster.id, 'currentLevel', level, this.light.log);
-                        await this.lightXY?.setAttribute(LevelControl.Cluster.id, 'currentLevel', level, this.lightXY.log);
-                        await this.lightHS?.setAttribute(LevelControl.Cluster.id, 'currentLevel', level, this.lightHS.log);
-                        await this.lightCT?.setAttribute(LevelControl.Cluster.id, 'currentLevel', level, this.lightCT.log);
-                        this.log.info(`Set lights currentLevel to ${level}`);
-                    }
-                    else {
-                        await this.lightOnOff?.setAttribute(OnOff.Cluster.id, 'onOff', true, this.lightOnOff?.log);
-                        await this.dimmer?.setAttribute(OnOff.Cluster.id, 'onOff', true, this.dimmer.log);
-                        await this.light?.setAttribute(OnOff.Cluster.id, 'onOff', true, this.light.log);
-                        await this.lightXY?.setAttribute(OnOff.Cluster.id, 'onOff', true, this.lightXY.log);
-                        await this.lightHS?.setAttribute(OnOff.Cluster.id, 'onOff', true, this.lightHS.log);
-                        await this.lightCT?.setAttribute(OnOff.Cluster.id, 'onOff', true, this.lightCT.log);
-                        this.log.info('Set lights onOff to true');
-                        await this.dimmer?.setAttribute(LevelControl.Cluster.id, 'currentLevel', level, this.dimmer.log);
-                        await this.light?.setAttribute(LevelControl.Cluster.id, 'currentLevel', level, this.light.log);
-                        await this.lightXY?.setAttribute(LevelControl.Cluster.id, 'currentLevel', level, this.lightXY.log);
-                        await this.lightHS?.setAttribute(LevelControl.Cluster.id, 'currentLevel', level, this.lightHS.log);
-                        await this.lightCT?.setAttribute(LevelControl.Cluster.id, 'currentLevel', level, this.lightCT.log);
-                        this.log.info(`Set lights currentLevel to ${level}`);
-                    }
+                this.intervalLevel += 10;
+                if (this.intervalLevel >= 250) {
+                    this.intervalLevel = 0;
+                    await this.lightOnOff?.setAttribute(OnOff.Cluster.id, 'onOff', false, this.lightOnOff.log);
+                    await this.dimmer?.setAttribute(OnOff.Cluster.id, 'onOff', false, this.dimmer.log);
+                    await this.mountedDimmerSwitch?.setAttribute(OnOff.Cluster.id, 'onOff', false, this.mountedDimmerSwitch.log);
+                    await this.light?.setAttribute(OnOff.Cluster.id, 'onOff', false, this.light.log);
+                    await this.lightXY?.setAttribute(OnOff.Cluster.id, 'onOff', false, this.lightXY.log);
+                    await this.lightHS?.setAttribute(OnOff.Cluster.id, 'onOff', false, this.lightHS.log);
+                    await this.lightCT?.setAttribute(OnOff.Cluster.id, 'onOff', false, this.lightCT.log);
+                    this.log.info('Set lights onOff to false');
+                }
+                else {
+                    await this.lightOnOff?.setAttribute(OnOff.Cluster.id, 'onOff', true, this.lightOnOff?.log);
+                    await this.dimmer?.setAttribute(OnOff.Cluster.id, 'onOff', true, this.dimmer.log);
+                    await this.mountedDimmerSwitch?.setAttribute(OnOff.Cluster.id, 'onOff', true, this.mountedDimmerSwitch.log);
+                    await this.light?.setAttribute(OnOff.Cluster.id, 'onOff', true, this.light.log);
+                    await this.lightXY?.setAttribute(OnOff.Cluster.id, 'onOff', true, this.lightXY.log);
+                    await this.lightHS?.setAttribute(OnOff.Cluster.id, 'onOff', true, this.lightHS.log);
+                    await this.lightCT?.setAttribute(OnOff.Cluster.id, 'onOff', true, this.lightCT.log);
+                    this.log.info('Set lights onOff to true');
+                    await this.dimmer?.setAttribute(LevelControl.Cluster.id, 'currentLevel', this.intervalLevel, this.dimmer.log);
+                    await this.mountedDimmerSwitch?.setAttribute(LevelControl.Cluster.id, 'currentLevel', this.intervalLevel, this.mountedDimmerSwitch.log);
+                    await this.light?.setAttribute(LevelControl.Cluster.id, 'currentLevel', this.intervalLevel, this.light.log);
+                    await this.lightXY?.setAttribute(LevelControl.Cluster.id, 'currentLevel', this.intervalLevel, this.lightXY.log);
+                    await this.lightHS?.setAttribute(LevelControl.Cluster.id, 'currentLevel', this.intervalLevel, this.lightHS.log);
+                    await this.lightCT?.setAttribute(LevelControl.Cluster.id, 'currentLevel', this.intervalLevel, this.lightCT.log);
+                    this.log.info(`Set lights currentLevel to ${this.intervalLevel}`);
+                }
+                this.intervalColorTemperature += 50;
+                if (this.intervalColorTemperature > 500) {
+                    this.intervalColorTemperature = 147;
                 }
+                await this.light?.setAttribute(ColorControl.Cluster.id, 'colorTemperatureMireds', this.intervalColorTemperature, this.light.log);
+                await this.lightHS?.setAttribute(ColorControl.Cluster.id, 'colorTemperatureMireds', this.intervalColorTemperature, this.lightHS.log);
+                await this.lightXY?.setAttribute(ColorControl.Cluster.id, 'colorTemperatureMireds', this.intervalColorTemperature, this.lightXY.log);
+                await this.lightCT?.setAttribute(ColorControl.Cluster.id, 'colorTemperatureMireds', this.intervalColorTemperature, this.lightCT.log);
+                await this.light?.configureColorControlMode(ColorControl.ColorMode.ColorTemperatureMireds);
+                await this.lightHS?.configureColorControlMode(ColorControl.ColorMode.ColorTemperatureMireds);
+                await this.lightXY?.configureColorControlMode(ColorControl.ColorMode.ColorTemperatureMireds);
+                await this.lightCT?.configureColorControlMode(ColorControl.ColorMode.ColorTemperatureMireds);
+                this.log.info(`Set lights colorTemperatureMireds to ${this.intervalColorTemperature}`);
             }, 60 * 1000 + 200);
         }
         await this.outlet?.setAttribute(OnOff.Cluster.id, 'onOff', false, this.outlet.log);
@@ -1110,6 +1238,24 @@ export class ExampleMatterbridgeDynamicPlatform extends MatterbridgeDynamicPlatf
                 }
             }, 60 * 1000 + 1100);
         }
+        const airConditionerDevice = this.bridgedDevices.get('Air Conditioner');
+        await airConditionerDevice?.setAttribute(OnOff.Cluster.id, 'onOff', true, airConditionerDevice.log);
+        const laundryWasherDevice = this.bridgedDevices.get('Laundry Washer');
+        await laundryWasherDevice?.setAttribute(OnOff.Cluster.id, 'onOff', true, laundryWasherDevice.log);
+        const laundryDryerDevice = this.bridgedDevices.get('Laundry Dryer');
+        await laundryDryerDevice?.setAttribute(OnOff.Cluster.id, 'onOff', true, laundryDryerDevice.log);
+        const dishwasherDevice = this.bridgedDevices.get('Dishwasher');
+        await dishwasherDevice?.setAttribute(OnOff.Cluster.id, 'onOff', true, dishwasherDevice.log);
+        this.log.info(`Set appliances dead front OnOff to on`);
+        const cooktopDevice = this.bridgedDevices.get('Cooktop');
+        await cooktopDevice?.setAttribute(OnOff.Cluster.id, 'onOff', true, cooktopDevice.log);
+        cooktopDevice?.log.info(`Set Cooktop onOff only OnOff to on`);
+        const surface1 = cooktopDevice?.getChildEndpointByName('Surface1');
+        await surface1?.setAttribute(OnOff.Cluster.id, 'onOff', true, surface1.log);
+        surface1?.log.info(`Set Surface 1 onOff only OnOff to on`);
+        const surface2 = cooktopDevice?.getChildEndpointByName('Surface2');
+        await surface2?.setAttribute(OnOff.Cluster.id, 'onOff', true, surface2.log);
+        surface2?.log.info(`Set Surface 2 onOff only OnOff to on`);
         if (this.config.useInterval) {
             this.genericSwitchInterval = setInterval(async () => {
                 if (this.genericSwitchLastEvent === 'Release') {
@@ -1153,6 +1299,6 @@ export class ExampleMatterbridgeDynamicPlatform extends MatterbridgeDynamicPlatf
         await super.onShutdown(reason);
         this.log.info('onShutdown called with reason:', reason ?? 'none');
         if (this.config.unregisterOnShutdown === true)
-            await this.unregisterAllDevices();
+            await this.unregisterAllDevices(500);
     }
 }

package/dist/robot.js ADDED Viewed

@@ -0,0 +1,215 @@
+import { Matterbridge, MatterbridgeServer, MatterbridgeEndpoint, roboticVacuumCleaner, dishwasher } from 'matterbridge';
+import { LogLevel as MatterLogLevel, LogFormat as MatterLogFormat, EndpointServer, logEndpoint, DeviceTypeId, VendorId, } from 'matterbridge/matter';
+import { ModeBase, OperationalState, PowerSource, RvcRunMode, RvcCleanMode, RvcOperationalState, ServiceArea } from 'matterbridge/matter/clusters';
+import { ActionsServer, RvcCleanModeBehavior, RvcOperationalStateBehavior, RvcRunModeBehavior, ServiceAreaBehavior } from 'matterbridge/matter/behaviors';
+import { AnsiLogger } from 'matterbridge/logger';
+import { Appliances } from './appliances.js';
+export class Robot extends MatterbridgeEndpoint {
+    constructor(name, serial) {
+        super(roboticVacuumCleaner, { uniqueStorageKey: `${name}-${serial}` }, true);
+        this.createDefaultIdentifyClusterServer()
+            .createDefaultBasicInformationClusterServer(name, serial, 0xfff1, 'Matterbridge', 0x8000, 'Matterbridge Robot Vacuum Cleaner')
+            .createDefaultRvcRunModeClusterServer()
+            .createDefaultRvcOperationalStateClusterServer()
+            .createDefaultRvcCleanModeClusterServer()
+            .createDefaultServiceAreaClusterServer()
+            .createDefaultPowerSourceRechargeableBatteryClusterServer(80, PowerSource.BatChargeLevel.Ok, 5900);
+    }
+    createDefaultRvcRunModeClusterServer(currentMode, supportedModes) {
+        this.behaviors.require(MatterbridgeRvcRunModeServer, {
+            supportedModes: supportedModes ?? [
+                { label: 'Idle', mode: 1, modeTags: [{ value: RvcRunMode.ModeTag.Idle }] },
+                { label: 'Cleaning', mode: 2, modeTags: [{ value: RvcRunMode.ModeTag.Cleaning }] },
+                { label: 'Mapping', mode: 3, modeTags: [{ value: RvcRunMode.ModeTag.Mapping }] },
+                { label: 'SpotCleaning', mode: 4, modeTags: [{ value: RvcRunMode.ModeTag.Cleaning }, { value: RvcRunMode.ModeTag.Max }] },
+            ],
+            currentMode: currentMode ?? 1,
+        });
+        return this;
+    }
+    createDefaultRvcCleanModeClusterServer(currentMode, supportedModes) {
+        this.behaviors.require(MatterbridgeRvcCleanModeServer, {
+            supportedModes: supportedModes ?? [
+                { label: 'Vacuum', mode: 1, modeTags: [{ value: RvcCleanMode.ModeTag.Vacuum }] },
+                { label: 'Mop', mode: 2, modeTags: [{ value: RvcCleanMode.ModeTag.Mop }] },
+                { label: 'Clean', mode: 3, modeTags: [{ value: RvcCleanMode.ModeTag.DeepClean }] },
+            ],
+            currentMode: currentMode ?? 1,
+        });
+        return this;
+    }
+    createDefaultServiceAreaClusterServer(supportedAreas, selectedAreas) {
+        this.behaviors.require(MatterbridgeServiceAreaServer, {
+            supportedAreas: supportedAreas ?? [
+                {
+                    areaId: 1,
+                    mapId: null,
+                    areaInfo: { locationInfo: { locationName: 'Living', floorNumber: null, areaType: null }, landmarkInfo: null },
+                },
+                {
+                    areaId: 2,
+                    mapId: null,
+                    areaInfo: { locationInfo: { locationName: 'Kitchen', floorNumber: null, areaType: null }, landmarkInfo: null },
+                },
+                {
+                    areaId: 3,
+                    mapId: null,
+                    areaInfo: { locationInfo: { locationName: 'Bedroom', floorNumber: null, areaType: null }, landmarkInfo: null },
+                },
+                {
+                    areaId: 4,
+                    mapId: null,
+                    areaInfo: { locationInfo: { locationName: 'Bathroom', floorNumber: null, areaType: null }, landmarkInfo: null },
+                },
+            ],
+            selectedAreas: selectedAreas ?? [],
+            currentArea: 1,
+            estimatedEndTime: null,
+        });
+        return this;
+    }
+    createDefaultRvcOperationalStateClusterServer(phaseList = null, currentPhase = null, operationalStateList, operationalState, operationalError) {
+        this.behaviors.require(MatterbridgeRvcOperationalStateServer, {
+            phaseList,
+            currentPhase,
+            operationalStateList: operationalStateList ?? [
+                { operationalStateId: RvcOperationalState.OperationalState.Stopped, operationalStateLabel: 'Stopped' },
+                { operationalStateId: RvcOperationalState.OperationalState.Running, operationalStateLabel: 'Running' },
+                { operationalStateId: RvcOperationalState.OperationalState.Paused, operationalStateLabel: 'Paused' },
+                { operationalStateId: RvcOperationalState.OperationalState.Error, operationalStateLabel: 'Error' },
+                { operationalStateId: RvcOperationalState.OperationalState.SeekingCharger, operationalStateLabel: 'SeekingCharger' },
+                { operationalStateId: RvcOperationalState.OperationalState.Charging, operationalStateLabel: 'Charging' },
+                { operationalStateId: RvcOperationalState.OperationalState.Docked, operationalStateLabel: 'Docked' },
+            ],
+            operationalState: operationalState ?? RvcOperationalState.OperationalState.Docked,
+            operationalError: operationalError ?? { errorStateId: RvcOperationalState.ErrorState.NoError, errorStateLabel: 'No Error', errorStateDetails: 'Fully operational' },
+        });
+        return this;
+    }
+}
+export class MatterbridgeServiceAreaServer extends ServiceAreaBehavior {
+    initialize() {
+    }
+    selectAreas({ newAreas }) {
+        const device = this.endpoint.stateOf(MatterbridgeServer).deviceCommand;
+        for (const area of newAreas) {
+            const supportedArea = this.state.supportedAreas.find((supportedArea) => supportedArea.areaId === area);
+            if (!supportedArea) {
+                device.log.error('MatterbridgeServiceAreaServer selectAreas called with unsupported area:', area);
+                return { status: ServiceArea.SelectAreasStatus.UnsupportedArea, statusText: 'Unsupported areas' };
+            }
+        }
+        this.state.selectedAreas = newAreas;
+        this.state.currentArea = newAreas[0];
+        device.log.info(`***MatterbridgeServiceAreaServer selectAreas called with: ${newAreas.map((area) => area.toString()).join(', ')}`);
+        return { status: ServiceArea.SelectAreasStatus.Success, statusText: 'Succesfully selected new areas' };
+    }
+}
+export class MatterbridgeRvcRunModeServer extends RvcRunModeBehavior {
+    initialize() {
+        this.state.currentMode = 1;
+    }
+    changeToMode({ newMode }) {
+        const device = this.endpoint.stateOf(MatterbridgeServer).deviceCommand;
+        const changedMode = this.state.supportedModes.find((mode) => mode.mode === newMode);
+        if (!changedMode) {
+            device.log.error('MatterbridgeRvcRunModeServer changeToMode called with unsupported newMode:', newMode);
+            return { status: ModeBase.ModeChangeStatus.InvalidInMode, statusText: 'Invalid mode' };
+        }
+        device.changeToMode({ newMode });
+        this.state.currentMode = newMode;
+        if (changedMode.modeTags.find((tag) => tag.value === RvcRunMode.ModeTag.Cleaning)) {
+            device.log.info('***MatterbridgeRvcRunModeServer changeToMode called with newMode Cleaning => Running');
+            this.agent.get(MatterbridgeRvcOperationalStateServer).state.operationalState = RvcOperationalState.OperationalState.Running;
+            return { status: ModeBase.ModeChangeStatus.Success, statusText: 'Running' };
+        }
+        else if (changedMode.modeTags.find((tag) => tag.value === RvcRunMode.ModeTag.Idle)) {
+            device.log.info('***MatterbridgeRvcRunModeServer changeToMode called with newMode Idle => Docked');
+            this.agent.get(MatterbridgeRvcOperationalStateServer).state.operationalState = RvcOperationalState.OperationalState.Docked;
+            return { status: ModeBase.ModeChangeStatus.Success, statusText: 'Docked' };
+        }
+        device.log.info(`***MatterbridgeRvcRunModeServer changeToMode called with newMode ${newMode} => ${changedMode.label}`);
+        this.agent.get(MatterbridgeRvcOperationalStateServer).state.operationalState = RvcOperationalState.OperationalState.Running;
+        return { status: ModeBase.ModeChangeStatus.Success, statusText: 'Success' };
+    }
+}
+export class MatterbridgeRvcCleanModeServer extends RvcCleanModeBehavior {
+    initialize() {
+        this.state.currentMode = 1;
+    }
+    changeToMode({ newMode }) {
+        const device = this.endpoint.stateOf(MatterbridgeServer).deviceCommand;
+        const supported = this.state.supportedModes.find((mode) => mode.mode === newMode);
+        if (!supported) {
+            device.log.error('***MatterbridgeRvcCleanModeServer changeToMode called with unsupported newMode:', newMode);
+            return { status: ModeBase.ModeChangeStatus.InvalidInMode, statusText: 'Invalid mode' };
+        }
+        device.changeToMode({ newMode });
+        this.state.currentMode = newMode;
+        device.log.info(`***MatterbridgeRvcCleanModeServer changeToMode called with newMode ${newMode} => ${supported.label}`);
+        return { status: ModeBase.ModeChangeStatus.Success, statusText: 'Success' };
+    }
+}
+export class MatterbridgeRvcOperationalStateServer extends RvcOperationalStateBehavior {
+    initialize() {
+        const device = this.endpoint.stateOf(MatterbridgeServer).deviceCommand;
+        device.log.info('***MatterbridgeRvcOperationalStateServer initialized: setting operational state to Docked');
+        this.state.operationalState = RvcOperationalState.OperationalState.Docked;
+        this.state.operationalError = { errorStateId: RvcOperationalState.ErrorState.NoError, errorStateLabel: 'No Error', errorStateDetails: 'Fully operational' };
+    }
+    pause() {
+        const device = this.endpoint.stateOf(MatterbridgeServer).deviceCommand;
+        device.log.info('MatterbridgeRvcOperationalStateServer: pause called setting operational state to Paused and currentMode to Idle');
+        this.agent.get(MatterbridgeRvcRunModeServer).state.currentMode = 1;
+        this.state.operationalState = RvcOperationalState.OperationalState.Paused;
+        this.state.operationalError = { errorStateId: RvcOperationalState.ErrorState.NoError, errorStateLabel: 'No Error', errorStateDetails: 'Fully operational' };
+        return {
+            commandResponseState: { errorStateId: OperationalState.ErrorState.NoError, errorStateLabel: 'No error', errorStateDetails: 'Fully operational' },
+        };
+    }
+    resume() {
+        const device = this.endpoint.stateOf(MatterbridgeServer).deviceCommand;
+        device.log.info('MatterbridgeRvcOperationalStateServer: resume called setting operational state to Running and currentMode to Cleaning');
+        this.agent.get(MatterbridgeRvcRunModeServer).state.currentMode = 2;
+        this.state.operationalState = RvcOperationalState.OperationalState.Running;
+        this.state.operationalError = { errorStateId: RvcOperationalState.ErrorState.NoError, errorStateLabel: 'No Error', errorStateDetails: 'Fully operational' };
+        return {
+            commandResponseState: { errorStateId: OperationalState.ErrorState.NoError, errorStateLabel: 'No error', errorStateDetails: 'Fully operational' },
+        };
+    }
+    goHome() {
+        const device = this.endpoint.stateOf(MatterbridgeServer).deviceCommand;
+        device.log.info('MatterbridgeRvcOperationalStateServer: goHome called setting operational state to Docked and currentMode to Idle');
+        this.agent.get(MatterbridgeRvcRunModeServer).state.currentMode = 1;
+        this.state.operationalState = RvcOperationalState.OperationalState.Docked;
+        this.state.operationalError = { errorStateId: RvcOperationalState.ErrorState.NoError, errorStateLabel: 'No Error', errorStateDetails: 'Fully operational' };
+        return {
+            commandResponseState: { errorStateId: OperationalState.ErrorState.NoError, errorStateLabel: 'No error', errorStateDetails: 'Fully operational' },
+        };
+    }
+}
+function createEndpointActionsClusterServer(endpoint, endpointLists) {
+    endpoint.behaviors.require(ActionsServer, {
+        actionList: [],
+        endpointLists,
+    });
+    return endpoint;
+}
+if (process.argv.includes('-testRobot')) {
+    const matterbridge = await Matterbridge.loadInstance(false);
+    matterbridge.log = new AnsiLogger({ logName: 'Matterbridge', logTimestampFormat: 4, logLevel: "debug" });
+    matterbridge.environment.vars.set('log.level', MatterLogLevel.DEBUG);
+    matterbridge.environment.vars.set('log.format', MatterLogFormat.ANSI);
+    matterbridge.environment.vars.set('path.root', 'matterstorage');
+    matterbridge.environment.vars.set('runtime.signals', true);
+    matterbridge.environment.vars.set('runtime.exitcode', true);
+    matterbridge.environment.vars.set('mdns.networkInterface', 'Wi-Fi');
+    await matterbridge.startMatterStorage();
+    const deviceType = dishwasher;
+    const context = await matterbridge.createServerNodeContext('Matterbridge', deviceType.name, DeviceTypeId(deviceType.code), VendorId(0xfff1), 'Matterbridge', 0x8000, 'Matterbridge device');
+    const server = (await matterbridge.createServerNode(context));
+    const device = new Appliances(deviceType, 'Dish Washer', '97754248654');
+    await server.add(device);
+    await matterbridge.startServerNode(server);
+    logEndpoint(EndpointServer.forEndpoint(server));
+}

package/npm-shrinkwrap.json CHANGED Viewed

@@ -1,12 +1,12 @@
 {
   "name": "matterbridge-example-dynamic-platform",
-  "version": "1.1.9",
+  "version": "1.2.0-edge.10",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "matterbridge-example-dynamic-platform",
-      "version": "1.1.9",
+      "version": "1.2.0-edge.10",
       "license": "MIT",
       "dependencies": {
         "node-ansi-logger": "3.0.1",

package/package.json CHANGED Viewed

@@ -1,6 +1,6 @@
 {
   "name": "matterbridge-example-dynamic-platform",
-  "version": "1.1.9",
+  "version": "1.2.0-edge.10",
   "description": "Matterbridge dynamic plugin",
   "author": "https://github.com/Luligu",
   "license": "MIT",

package/tsconfig.jest.json ADDED Viewed

@@ -0,0 +1,8 @@
+{
+  "extends": "./tsconfig.json",
+  "compilerOptions": {
+    // enable isolatedModules just for ts-jest
+    "isolatedModules": true
+  },
+  "include": ["**/*.spec.ts", "**/*.test.ts", "**/__test__/*"]
+}