isy-nodejs 0.5.0-beta.9 → 1.0.1-alpha.1

package/src/Devices/Elk/ElkAlarmPanelDevice.ts

@@ -1,27 +1,47 @@
-import { Family } from '../../Families';
-import { ISYDevice } from '../ISYDevice';
-import { ISY } from '../../ISY';
+import { timingSafeEqual } from 'crypto';
+import { Family } from '../../Definitions/Global/Families.js';
+import { ISY } from '../../ISY.js';
+import { ISYDeviceNode } from '../ISYDeviceNode.js';
+import { ElkAlarmSensorDevice } from './ElkAlarmSensorDevice.js';
 
 /////////////////////////////
 // ELKAlarmPanelDevice
 
 //
-export class ELKAlarmPanelDevice extends ISYDevice<Family.Elk> {
+export class ELKAlarmPanelDevice extends ISYDeviceNode<Family.Global,any,any> {
+	[x: string]: any;
+	setFromAreaUpdate(nodes: any) {
+		throw new Error('Method not implemented.');
+	}
+
+	public alarmTripState: AlarmTripState;
+	public alarmState: AlarmState;
+	public alarmMode: AlarmMode;
+	public area: number;
 
-	 public alarmTripState: AlarmTripState;
-	 public alarmState: AlarmState;
-	 public alarmMode: AlarmMode;
+	public deviceFriendlyName: string;
+	public deviceType: any;
+	public connectionType: string;
+	public batteryOperated: boolean;
+	public voltage: number;
 
 	constructor(isy: ISY, area: number) {
 
-		super(isy, { family: Family.Elk, type: '0.0.0.0', enabled: true, address: 'ElkAlarmPanel' + area, name: 'Elk Alarm Panel ' + area });
+		super(isy, {
+			family: Family.Global, type: '0.0.0.0', enabled: true, address: `ElkAlarmPanel_${area}`, name: `Elk Alarm Panel ${area}`,
+			pnode: undefined,
+			startDelay: 0,
+			hint: '',
+			endDelay: 0,
+			wattage: 0,
+			dcPeriod: 0
+		});
 
 		this.area = area;
 		this.alarmTripState = AlarmTripState.DISARMED;
 		this.alarmState = AlarmState.NOT_READY_TO_ARM;
 		this.alarmMode = AlarmMode.DISARMED;
 
-
 		this.deviceFriendlyName = 'Elk Alarm Panel ' + area;
 
 		this.connectionType = 'Elk Network Module';
@@ -31,17 +51,17 @@ export class ELKAlarmPanelDevice extends ISYDevice<Family.Elk> {
 			.lastChanged = new Date();
 	}
 
-	public async sendCommand(command): Promise<any> {
+	public override async sendCommand(command: string): Promise<any> {
 
 		return this.isy.sendISYCommand(`elk/area/${this.area}/cmd/${command}`);
 
 	}
 
-	public async sendSetAlarmModeCommand(alarmState) {
-		if (alarmState === 'disarm') {
+	public async sendSetAlarmModeCommand(alarmMode: string) {
+		if (alarmMode === 'disarm') {
 			return this.sendCommand('disarm');
 		} else {
-			return this.sendCommand(`arm?armType=${alarmState}`);
+			return this.sendCommand(`arm?armType=${alarmMode}`);
 		}
 	}
 	public async clearAllBypasses() {
@@ -59,29 +79,32 @@ export class ELKAlarmPanelDevice extends ISYDevice<Family.Elk> {
 	public getAlarmMode() {
 		return this.alarmMode;
 	}
-	public handleEvent(event) {
+	public override handleEvent(event: { control?: string; data?: any; node?: any; eventInfo?: any; }) {
 		const areaUpdate = event.eventInfo.ae;
 		const areaId = areaUpdate.attr.area;
 		const updateType = areaUpdate.attr.type;
 		const valueToSet = Number(areaUpdate.attr.val);
 		let valueChanged = false;
-		if (areaId == this.area) {
-			if (updateType == AlarmPanelProperty.AlarmTripState) {
-				if (this.alarmTripState != valueToSet) {
+		if (areaId === this.area) {
+			if (updateType === AlarmPanelProperty.AlarmTripState) {
+				if (this.alarmTripState !== valueToSet) {
+					const oldVal = this.alarmTripState;
 					this.alarmTripState = valueToSet;
-					this.propertyChanged?.emit('', 'alarmTripState', valueToSet);
+					this.emit('PropertyChanged', 'alarmTripState', this.alarmTripState, oldVal, AlarmTripState[this.alarmTripState]);
 					valueChanged = true;
 				}
-			} else if (updateType == AlarmPanelProperty.AlarmState) {
-				if (this.alarmState != valueToSet) {
+			} else if (updateType === AlarmPanelProperty.AlarmState) {
+				if (this.alarmState !== valueToSet) {
+					const oldVal = this.alarmState;
 					this.alarmState = valueToSet;
-					this.propertyChanged?.emit('', 'alarmState', valueToSet);
+					this.emit('PropertyChanged', 'alarmState', this.alarmState, oldVal, AlarmState[this.alarmState]);
 					valueChanged = true;
 				}
-			} else if (updateType == AlarmPanelProperty.AlarmMode) {
-				if (this.alarmMode != valueToSet) {
+			} else if (updateType === AlarmPanelProperty.AlarmMode) {
+				if (this.alarmMode !== valueToSet) {
+					const oldVal = this.alarmMode;
 					this.alarmMode = valueToSet;
-					this.propertyChanged?.emit('', 'alarmMode', valueToSet);
+					this.emit('PropertyChanged', 'alarmMode', this.alarmState, oldVal, AlarmMode[this.alarmMode]);
 					valueChanged = true;
 				}
 			}
@@ -101,7 +124,7 @@ export enum AlarmPanelProperty {
 	AlarmTripState = 1
 }
 
-export  enum AlarmMode {
+export enum AlarmMode {
 	DISARMED = 0,
 	AWAY = 1,
 	STAY = 2,
@@ -152,94 +175,26 @@ ELKAlarmPanelDevice.prototype.ALARM_STATE_ARMED_FULLY = 4;
 ELKAlarmPanelDevice.prototype.ALARM_STATE_FORCE_ARMED_VIOLATION = 5;
 ELKAlarmPanelDevice.prototype.ALARM_STATE_ARMED_WITH_BYPASS = 6;
 
-/////////////////////////////
-// ELKAlarmSensor
-//
-export class ElkAlarmSensorDevice extends ISYDevice<Family.Elk> {
-	constructor(isy, name, area, zone) {
-		super(isy, {family: Family.Elk, name, address: `ElkZone${zone}`, enabled: true});
-
-		this.area = area;
-		this.zone = zone;
-		// this.name = name;
-		// this.address = "ElkZone" + zone;
-		this.displayName = 'Elk Connected Sensor ' + zone;
-
-		this.deviceFriendlyName = 'Elk Connected Sensor ' + zone;
-
-		this.connectionType = 'Elk Network';
-		this.batteryOperated = false;
-		this.physicalState = this.SENSOR_STATE_PHYSICAL_NOT_CONFIGURED;
-		this.logicalState = this.SENSOR_STATE_LOGICAL_NORMAL;
-		this.lastChanged = new Date();
-	}
-
-	public async sendBypassToggleCommand() {
-		return this.isy.sendISYCommand('elk/zone/' + this.zone + '/cmd/toggle/bypass');
-	}
-	public getPhysicalState() {
-		return this.physicalState;
-	}
-	public isBypassed() {
-		return (this.logicalState === 3);
-	}
-	public getLogicalState() {
-		return this.logicalState;
-	}
-	public getCurrentDoorWindowState() {
-		return (this.physicalState == this.SENSOR_STATE_PHYSICAL_OPEN || this.logicalState == this.SENSOR_STATE_LOGICAL_VIOLATED);
-	}
-	public getSensorStatus() {
-		return 'PS [' + this.physicalState + '] LS [' + this.logicatState + ']';
-	}
-	public isPresent() {
-		if (this.voltage < 65 || this.voltage > 80) {
-			return true;
-		} else {
-			return false;
-		}
-	}
-	public handleEvent(event) {
-		const zoneUpdate = event.eventInfo.ze;
-		const zone = zoneUpdate.attr.zone;
-		const updateType = zoneUpdate.attr.type;
-		const valueToSet = zoneUpdate.attr.val;
-		let valueChanged = false;
-		if (zone == this.zone) {
-			if (updateType == 51) {
-				if (this.logicalState != valueToSet) {
-					this.logicalState = valueToSet;
-					this.propertyChanged?.emit('', 'logicalState', valueToSet);
-					// Not triggering change update on logical state because physical always follows and don't want double notify.
-					// valueChanged = true;
-				}
-			} else if (updateType == 52) {
-				if (this.physicalState != valueToSet) {
-					this.physicalState = valueToSet;
-					this.propertyChanged?.emit('', 'physicalState', valueToSet);
-					valueChanged = true;
-				}
-			} else if (updateType == 53) {
-				if (this.voltage != valueToSet) {
-					this.voltage = valueToSet;
-					this.propertyChanged?.emit('', 'voltage', valueToSet);
-					valueChanged = true;
-				}
-			}
-		}
-		if (valueChanged) {
-			this.lastChanged = new Date();
-		}
-		return valueChanged;
-	}
+// Logical Status for sensors
+export enum AlarmSensorPhysicalState {
+	NOT_CONFIGURED = 0,
+	OPEN = 1,
+	EOL = 2,
+	SHORT = 3
 }
 
-// Logical Status for sensors
 ElkAlarmSensorDevice.prototype.SENSOR_STATE_PHYSICAL_NOT_CONFIGURED = 0;
 ElkAlarmSensorDevice.prototype.SENSOR_STATE_PHYSICAL_OPEN = 1;
 ElkAlarmSensorDevice.prototype.SENSOR_STATE_PHYSICAL_EOL = 2;
 ElkAlarmSensorDevice.prototype.SENSOR_STATE_PHYSICAL_SHORT = 3;
 
+export enum AlarmSensorLogicalState {
+	NORMAL = 0,
+	TROUBLE = 1,
+	VIOLATED = 2,
+	BYPASSED = 3
+}
+
 // Physical status for sensors
 ElkAlarmSensorDevice.prototype.SENSOR_STATE_LOGICAL_NORMAL = 0;
 ElkAlarmSensorDevice.prototype.SENSOR_STATE_LOGICAL_TROUBLE = 1;

package/src/Devices/Elk/ElkAlarmSensorDevice.ts

@@ -0,0 +1,114 @@
+
+import { Family } from '../../Definitions/Global/Families.js';
+import { ISY } from '../../ISY.js';
+import { ISYDeviceNode } from '../ISYDeviceNode.js';
+import { AlarmSensorPhysicalState, AlarmSensorLogicalState } from './ElkAlarmPanelDevice.js';
+/////////////////////////////
+// ELKAlarmSensor
+//
+export class ElkAlarmSensorDevice extends ISYDeviceNode<Family.Global,any,any> {
+	[x: string]: any;
+	public area: number;
+	public zone: string;
+	public deviceFriendlyName: string;
+	public deviceType: any;
+	public connectionType: string;
+	public batteryOperated: boolean;
+	public physicalState: AlarmSensorPhysicalState;
+	public logicalState: AlarmSensorLogicalState;
+	public voltage: number;
+	constructor (isy: ISY, name: string, area: number, zone: string) {
+		super(isy, {
+			family: Family.Global, name, address: `ElkZone_${zone}`, enabled: true,
+			pnode: undefined,
+			startDelay: 0,
+			hint: '',
+			endDelay: 0,
+			wattage: 0,
+			dcPeriod: 0
+		});
+		this.area = area;
+		this.zone = zone;
+		// this.name = name;
+		// this.address = "ElkZone" + zone;
+		this.label = `Elk Connected Sensor ${zone}`;
+		this.deviceFriendlyName = `Elk Connected Sensor ${zone}`;
+		this.connectionType = 'Elk Network';
+		this.batteryOperated = false;
+		this.physicalState = AlarmSensorPhysicalState.NOT_CONFIGURED;
+		this.logicalState = AlarmSensorLogicalState.NORMAL;
+		this.lastChanged = new Date();
+	}
+	public override async sendCommand(command: string): Promise<any> {
+		return this.isy.sendISYCommand(`elk/zone/${this.zone}/cmd/${command}`);
+	}
+	public async sendBypassToggleCommand() {
+		return this.sendCommand(`toggle/bypass`);
+	}
+	public getPhysicalState() {
+		return this.physicalState;
+	}
+	public isBypassed() {
+		return (this.logicalState === 3);
+	}
+	public getLogicalState() {
+		return this.logicalState;
+	}
+	public getCurrentDoorWindowState() {
+		return (this.physicalState === this.SENSOR_STATE_PHYSICAL_OPEN || this.logicalState === this.SENSOR_STATE_LOGICAL_VIOLATED);
+	}
+	public getSensorStatus() {
+		return 'PS [' + this.physicalState + '] LS [' + this.logicatState + ']';
+	}
+	public isPresent() {
+		if (this.voltage < 65 || this.voltage > 80) {
+			return true;
+		}
+		else {
+			return false;
+		}
+	}
+	public override handleEvent(event: {
+		control?: string;
+		data?: any;
+		node?: any;
+		eventInfo?: any;
+	}) {
+		const zoneUpdate = event.eventInfo.ze;
+		const zone = zoneUpdate.attr.zone;
+		const updateType = zoneUpdate.attr.type;
+		const valueToSet = zoneUpdate.attr.val;
+		let valueChanged = false;
+		if (zone === this.zone) {
+			if (updateType === 51) {
+				if (this.logicalState !== valueToSet) {
+					const temp = this.logicalState;
+					this.logicalState = valueToSet;
+					this.emit('PropertyChanged', 'logicalState', this.logicalState, temp, this.voltage.toString());
+					// Not triggering change update on logical state because physical always follows and don't want double notify.
+					// valueChanged = true;
+				}
+			}
+			else if (updateType === 52) {
+				if (this.physicalState !== valueToSet) {
+					const temp = this.physicalState;
+					this.physicalState = valueToSet;
+					this.emit('PropertyChanged', 'physicalState', this.physicalState, temp, this.voltage.toString());
+					valueChanged = true;
+				}
+			}
+			else if (updateType === 53) {
+				if (this.voltage !== valueToSet) {
+					const temp = this.voltage;
+					this.voltage = valueToSet;
+					this.emit('PropertyChanged', 'voltage', this.voltage, temp, this.voltage.toString());
+					valueChanged = true;
+				}
+			}
+		}
+		if (valueChanged) {
+			this.lastChanged = new Date();
+		}
+		return valueChanged;
+	}
+}

package/src/Devices/EndpointFor.ts

@@ -0,0 +1,95 @@
+import { Endpoint } from '@project-chip/matter.js/endpoint';
+import { SupportedBehaviors } from '@project-chip/matter.js/endpoint/properties';
+import { Behavior } from '@project-chip/matter.js/behavior';
+import { MutableEndpoint, EndpointType } from '@project-chip/matter.js/endpoint/type';
+import type { ClusterBehavior } from '@project-chip/matter.js/behavior/cluster';
+import { type ClusterType } from '@project-chip/matter.js/cluster';
+import type { Constructor } from './Constructor.js';
+import type { ISYDeviceNode } from '../Devices/ISYDeviceNode.js';
+
+import { BridgedDeviceBasicInformationBehavior, BridgedDeviceBasicInformationServer } from '@project-chip/matter.js/behaviors/bridged-device-basic-information';
+
+
+export type RelaxTypes<V> = V extends number
+        ? number
+        : V extends bigint
+          ? bigint
+          : V extends object
+            ? V extends (...args: any[]) => any
+                ? V
+                : {
+                      [K in keyof V]: RelaxTypes<V[K]>;
+                  }
+            : V;
+
+export type RelaxedClusterType = RelaxTypes<ClusterType>
+
+export type EndpointFor<K extends Behavior.Type, K1 extends Behavior.Type = K, K2 extends Behavior.Type = K, K3 extends Behavior.Type = K> = { events: SupportedBehaviors.EventsOf<SupportedBehaviors.MapOf<[K, K1, K2, K3]>>} & MutableEndpoint.With<EndpointType.Empty, SupportedBehaviors.MapOf<[K, K1, K2, K3]>>
+
+/*set: (values: SupportedBehaviors.StatePatchOf<SupportedBehaviors.MapOf<[K, K1, K2]>>) => void; }*/
+export type BehaviorsOf <K extends ClusterType.Of<ClusterType.Options<{}>>, K1 extends ClusterType = K, K2 extends ClusterType = K, K3 extends ClusterType = K> = [ClusterBehavior.Type<K>,ClusterBehavior.Type<K1>,ClusterBehavior.Type<K2>,ClusterBehavior.Type<K3>]
+
+export type SupportedBehaviorsOf <K extends ClusterType.Of<ClusterType.Options<{}>>, K1 extends ClusterType = K, K2 extends ClusterType = K, K3 extends ClusterType = K> =
+SupportedBehaviors.MapOf<BehaviorsOf<K, K1,K2,K3>>
+
+export type EndpointForCluster<K extends ClusterType.Of<ClusterType.Options<{}>>, K1 extends ClusterType = K, K2 extends ClusterType = K, K3 extends ClusterType = K> = { events: SupportedBehaviors.EventsOf<SupportedBehaviorsOf<K,K1,K2,K3>>; set: (values: SupportedBehaviors.StatePatchOf<SupportedBehaviorsOf<K, K1, K2,K3>>) => void; }
+
+export const MatterEndpoint= <P extends EndpointType & MutableEndpoint, T extends Constructor<ISYDeviceNode<any,any,any>>>(base: T, endpointType: P) =>
+{
+
+
+	return class extends base
+	{
+
+		endpointType: P = endpointType;
+
+
+
+		createEndpoint<K extends SupportedBehaviors>() : Endpoint {
+
+			var p = this.endpointType.with(BridgedDeviceBasicInformationServer);
+
+		 	const id = this.address.replaceAll(' ', '_').replaceAll('.', ' ');
+
+			return new Endpoint(p,{id: id, address: this.address, bridgedDeviceBasicInformation: {
+
+				nodeLabel: this.label.rightWithToken(32,' '),
+                productName: this.productName.rightWithToken(32,' '),
+                productLabel: this.model.leftWithToken(64,' '),
+                serialNumber: id,
+                reachable: this.enabled,
+            }});
+
+
+
+		}
+
+
+
+}
+}
+
+ // @ts-ignore
+   const BISY = BridgedDeviceBasicInformationBehavior.alter({attributes: {address: {optional: false}, ...BridgedDeviceBasicInformationServer.cluster.attributes}});
+
+
+  export class BridgedISYNodeInformationServer extends BridgedDeviceBasicInformationServer
+  {
+
+    override async initialize(): Promise<void> {
+
+
+
+        return super.initialize();
+
+
+
+    }
+  }
+
+  export namespace BridgedISYNodeInformationServer {
+    export class State extends BridgedDeviceBasicInformationServer.State {
+        // Assume Device is online when it is added, but developers should set correctly if needed
+        declare address: string;
+    }
+}