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

package/dist/robot.js

@@ -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/matterbridge-example-dynamic-platform.schema.json

@@ -40,7 +40,7 @@
       "default": true
     },
     "enableConcentrationMeasurements": {
-      "description": "Enable the ConcentrationMeasurements in the Air Quality device and SmokeCoSensor devices (Apple Home 18.4 will discard these devices when enabled)",
+      "description": "Enable the ConcentrationMeasurements in the Air Quality device and SmokeCoSensor device (Apple Home 18.4 will discard these devices when enabled)",
       "type": "boolean",
       "default": true
     },

package/npm-shrinkwrap.json

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

package/package.json

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

package/tsconfig.jest.json

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