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

package/src/ISYScene.ts

@@ -1,29 +1,47 @@
-import { InsteonDimmableDevice } from './Devices/Insteon/InsteonDimmableDevice';
-import { Family } from './Families';
-import { InsteonRelayDevice, ISY, ISYDevice } from './ISY';
-import { Commands, DeviceTypes } from './ISYConstants';
-import { ISYNode } from './ISYNode';
+import { Insteon } from './Devices/Insteon/index.js';
+import { Family } from './Definitions/Global/Families.js';
+import { Commands, LinkType } from './ISYConstants.js';
+import { ISYNode } from './ISYNode.js';
+import {  ISYDevice } from './ISYDevice.js';
+import type { ISY } from './ISY.js';
+import type { Driver } from './Definitions/Global/Drivers.js';
+import type { Command } from './Definitions/Global/Commands.js';
+import type { NodeInfo, StaticNodeInfo } from './Model/NodeInfo.js';
+
+interface SceneInfo extends StaticNodeInfo
+ {
+	members?: {
+		link: any;
+	};
+	flag?: any;
+	nodeDefId?: string;
+	address: string;
+	name: string;
+	family?: Family;
+	parent?: any;
+	enabled: boolean;
+	startDelay: number;
+}
+
+export class ISYScene extends ISYNode<Family.Scene, Driver.Signatures<'ST'>,Command.Signatures<'DON' | 'DOF'>> {
 
-export class ISYScene extends ISYNode {
-	public type: string;
 	public connectionType: string;
 	public batteryOperated: boolean;
 	public deviceType: any;
 	public deviceFriendlyName: string;
-	public childDevices: ISYDevice<any>[];
-	public isDimmable: boolean;
+	public members: ISYDevice<any,any,any>[];
 	public typeCode: string;
-	constructor(isy: ISY, scene: { members?: any; flag?: any; nodeDefId?: string; address?: string; name?: string; family?: Family; parent?: any; enabled: boolean; ELK_ID?: string; }) {
-		super(isy, scene);
+	constructor(isy: ISY, scene: SceneInfo) {
+		super(isy, scene as SceneInfo);
 		// this.logger(JSON.stringify(scene));
 		this.typeCode = '';
 		this.connectionType = 'Insteon Wired';
 		this.batteryOperated = false;
-		this.deviceType = DeviceTypes.scene;
+
 		this.deviceFriendlyName = 'ISY Scene';
-		this.childDevices = [];
+		this.members = [];
 		this.isDimmable = false;
-		if (Array.isArray(scene.members.link)) {
+		if (Array.isArray(scene.members?.link)) {
 			for (const node of scene.members.link) {
 				if ('_' in node) {
 					// childDevices.push(node._);
@@ -32,21 +50,24 @@ export class ISYScene extends ISYNode {
 					const d = isy.getDevice(s);
 
 					if (d !== null && d !== undefined) { d.addLink(this); }
-					if (d instanceof InsteonDimmableDevice && node.type !== '16') { this.isDimmable = true; }
-					this.childDevices[s] = d;
+
+					if (d instanceof Insteon.Dimmer && node.type !== LinkType.Controller) { this.isDimmable = true; }
+					this.members.push(d);
 				}
 			}
-		} else if (scene.members.link !== undefined) {
+		} else if (scene.members?.link) {
 			if ('_' in scene.members.link) {
-				const node = scene.members.link;
+				const node = scene.members.link._;
 				this.logger(JSON.stringify(node));
 				// childDevices.push(node._);
 				// childDevices.push(object)
 				const s = scene.members.link._;
 				const d = isy.getDevice(s);
-				if (d !== null && d !== undefined) { d.addLink(this); }
-				if ((d.isDimmable && node.type !== '16') || this.isDimmable) { this.isDimmable = true; }
-				this.childDevices[s] = d;
+				if (d) { d.addLink(this);
+				// tslint:disable-next-line: triple-equals
+				if ((d.isDimmable && node.type != LinkType.Controller) || this.isDimmable) { this.isDimmable = true; }
+				this.members.push(d);
+				}
 			}
 		}
 		// check dimmability this.dimmable = Array.apply(p => p.dimmable);
@@ -54,25 +75,26 @@ export class ISYScene extends ISYNode {
 	}
 	// Get the current light state
 	get isOn() {
-		for (const device of this.childDevices) {
-			if (device instanceof InsteonRelayDevice) {
-				if (device.isOn) {
+		for (const device of this.members) {
+			if (device instanceof Insteon.Relay)  {
+				if (device.drivers.ST?.value === 1) {
 					return true;
 				}
 			}
 		}
 		return false;
 	}
+
 	get brightnessLevel() {
 		let lightDeviceCount = 0;
 		let blevel = 0;
-		for (const device of this.childDevices) {
-			if (device instanceof InsteonDimmableDevice) {
+		for (const device of this.members) {
+			if (device instanceof Insteon.Dimmer) {
 				lightDeviceCount++;
-				blevel += device.brightnessLevel;
-			} else if (device instanceof InsteonRelayDevice) {
+				//blevel += device.brightnessLevel;
+			} else if (device instanceof Insteon.Relay) {
 				lightDeviceCount++;
-				blevel += device.isOn ? 100 : 0;
+				blevel += device.drivers.ST ? 100 : 0;
 			}
 		}
 		if (lightDeviceCount > 0) {
@@ -88,27 +110,29 @@ export class ISYScene extends ISYNode {
 	}
 	public markAsChanged() {
 		this.lastChanged = new Date();
-		this.propertyChanged.emit('isOn', 'isOn', this.isOn, this.isOn ? 'on' : 'off');
-		this.propertyChanged.emit('', 'isOn', this.isOn, this.isOn ? 'on' : 'off');
+		this.emit('PropertyChanged', 'isOn', this.isOn, this.isOn, this.isOn ? 'on' : 'off');
+
 		if (this.isDimmable) {
-			this.propertyChanged.emit('brightnessLevel', 'brightnesslevel', this.brightnessLevel, this.brightnessLevel);
-			this.propertyChanged.emit('', 'brightnessLevel', this.brightnessLevel, this.brightnessLevel);
+			this.emit('PropertyChanged', 'brightnesslevel', this.brightnessLevel, this.brightnessLevel, this.brightnessLevel + '%');
+
 		}
 	}
-	public updateIsOn(lightState) {
+	public async updateIsOn(lightState: boolean) {
 		return this.isy.sendNodeCommand(this, lightState ? Commands.On : Commands.Off);
 	}
-	public updateBrightnessLevel(level) {
+	public async updateBrightnessLevel(level) {
 		return this.isy.sendNodeCommand(this, level > 0 ? Commands.On : Commands.Off, level);
 	}
 	public getAreAllLightsInSpecifiedState(state) {
-		for (const device of this.childDevices) {
-			if (device instanceof InsteonRelayDevice) {
-				if (device.isOn !== state) {
+		for (const device of this.members) {
+			if (device instanceof Insteon.Relay) {
+				if (device.drivers.ST !== state) {
 					return false;
 				}
 			}
 		}
 		return true;
 	}
+
+
 }

package/src/ISYVariable.ts

@@ -1,27 +1,31 @@
 import { EventEmitter } from 'events';
-import { ISY } from './ISY';
-import { VariableType } from './ISYConstants';
+import { ISY } from './ISY.js';
+import { VariableType } from './ISYConstants.js';
 
-export class ISYVariable extends EventEmitter {
+const varT = (t: typeof VariableType) => VariableType.Integer ? typeof Number : typeof String;
+
+type Variable<T extends VariableType> = T extends VariableType.Integer ? Number : String;
+
+export class ISYVariable<P extends VariableType> extends EventEmitter {
 	public isy: ISY;
 	public id: number;
 	public name: string;
 	public value: any;
 	public init: any;
-	public type: VariableType;
+	public type: P;
 	public lastChanged: Date;
-	constructor(isy: ISY, id: number, name: string, type: any) {
+	constructor(isy: ISY, id: number, name: string, type: VariableType) {
 		super();
 		this.isy = isy;
 		this.id = id;
 		this.name = name;
 		this.value = undefined;
 		this.init = undefined;
-		this.type = type;
+
 		this.lastChanged = new Date();
 	}
 
-	public handleEvent(event: any)
+	public handleEvent(event: { eventInfo: { var: any }; })
 	{
 		const varNode = event.eventInfo.var;
 		if (varNode !== null) {
@@ -37,20 +41,11 @@ export class ISYVariable extends EventEmitter {
 			const sec = parseInt(varNode.ts.substr(15, 2));
 			 this.lastChanged = new Date(year, month, day, hour, min, sec);
 			this.emit('ValueChanged',this.value, priorVal);
-	
-
 		}
 	}
 
-	public markAsChanged() {
-		this.lastChanged = new Date();
-	}
-	public sendSetValue(value, onComplete) {
-		this.isy.sendSetVariable(this.id, this.type, value, (success) => onComplete(success));
-	}
-
-	public async updateValue(value: any): Promise<void> {
-		const p = await this.isy.callISY(`vars\\${this.type}\\${this.id}\\${value}`);
+	public async updateValue(value: Variable<P>): Promise<void> {
+		const p = await this.isy.sendRequest(`vars\\${this.type}\\${this.id}\\${value}`);
 		this.value = value;
 		return p;
 	}

package/src/Matter/Behaviors/ISYBridgedDeviceBehavior.ts

@@ -0,0 +1,74 @@
+/**
+ * @license
+ * Copyright 2022-2024 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */ import { Behavior } from '@project-chip/matter.js/behavior';
+import { ClusterBehavior } from '@project-chip/matter.js/behavior/cluster';
+import type { StateType } from '@project-chip/matter.js/behavior/state';
+import { Internal } from '@project-chip/matter.js/behavior/state/managed';
+import { EventEmitter, Observable } from '@project-chip/matter.js/util';
+import internal from 'stream';
+import type { Driver } from '../../Definitions/Global/Drivers.js';
+import { ISY, type Family, type ISYNode } from '../../ISY.js';
+import type { ISYDevice } from '../../ISYDevice.js';
+import { DeviceToClusterMap, MappingRegistry, type ClusterMapping } from '../../Model/ClusterMap.js';
+
+
+type ClusterForBehavior<B extends ClusterBehavior> = B extends ClusterBehavior.Type<infer C> ? C : never;
+export class ISYBridgedDeviceBehavior extends Behavior {
+	static override readonly id = 'isyNode';
+
+	static override readonly early = true;
+
+	declare internal: ISYBridgedDeviceBehavior.Internal;
+	declare state: ISYBridgedDeviceBehavior.State;
+
+	declare events: ISYBridgedDeviceBehavior.Events;
+
+	override async initialize(_options?: {}) {
+		await super.initialize(_options);
+		var address = this.state.address;
+		this.internal.device = ISY.instance.nodeMap.get(this.state.address);
+		this.internal.map = MappingRegistry.getMapping(this.internal.device as unknown as ISYDevice<Family, any, any, any>);
+		ISY.instance.logger.debug(`Initializing ${this.constructor.name} for ${this.internal.device.constructor.name} ${this.internal.device.name} with address ${address}`);
+		if (this.internal.device) {
+			this.internal.device.events.on('PropertyChanged', this.handlePropertyChange.bind(this));
+		}
+	}
+
+	get device(): ISYNode<any, any, any, any> {
+		return (this.internal.device = this.internal.device ?? ISY.instance.getNode(this.state.address));
+	}
+
+	get map() {
+		return this.internal.map;
+	}
+
+	mapForBehavior<B extends { cluster: unknown }>(behavior: B): ClusterMapping<B['cluster'], typeof this.internal.device> {
+		return this.map[behavior.cluster['name']];
+	}
+
+	handlePropertyChange(driver: string, newValue: any, oldValue: any, formattedValue: string) {
+		this.events.propertyChanged.emit({ driver, newValue, oldValue, formattedValue });
+	}
+
+	[Symbol.asyncDispose]() {
+		this.internal.device = null;
+		return super[Symbol.asyncDispose]();
+	}
+}
+
+export namespace ISYBridgedDeviceBehavior {
+	export class Internal {
+		device?: ISYNode<any, any, any, any>;
+		map?: DeviceToClusterMap<typeof this.device, any>;
+	}
+
+	export class Events extends EventEmitter {
+		propertyChanged = Observable<[{ driver: string; newValue: any; oldValue: any; formattedValue: string }]>();
+	}
+
+	export class State {
+		address = '';
+	}
+}

package/src/Matter/Behaviors/ISYClusterBehavior.ts

@@ -0,0 +1,107 @@
+import type { ClusterBehavior, ClusterInterface } from '@project-chip/matter.js/behavior/cluster';
+
+import type { DriversOf, ISYNode } from '../../ISYNode.js';
+
+import type { Behavior } from '@project-chip/matter.js/behavior';
+import { BridgedDeviceBasicInformationServer } from '@project-chip/matter.js/behaviors/bridged-device-basic-information';
+import type { LevelControlBehavior } from '@project-chip/matter.js/behaviors/level-control';
+import type { OnOffBehavior, OnOffServer } from '@project-chip/matter.js/behaviors/on-off';
+import type { Cluster, ClusterServerHandlers, ClusterType as CT } from '@project-chip/matter.js/cluster';
+import '@project-chip/matter.js/device';
+import { OnOffLightRequirements } from '@project-chip/matter.js/devices/OnOffLightDevice';
+import { DriverType } from '../../Definitions/Global/Drivers.js';
+import type { Constructor } from '../../Devices/Constructor.js';
+import type { RelaxTypes } from '../../Devices/MapsTo.js';
+import { ISY, type ISYDevice } from '../../ISY.js';
+import { MappingRegistry, type ClusterMapping, type DeviceToClusterMap } from '../../Model/ClusterMap.js';
+
+import { ISYBridgedDeviceBehavior } from './ISYBridgedDeviceBehavior.js';
+
+type NotUnknown<T extends ClusterBehavior> = T extends { cluster: { name: 'Unknown' } } ? never : T;
+
+export type ConstructedType<B extends Constructor<any>> = B extends Constructor<infer C> ? C : never;
+
+export type ClusterForBehavior<B> = B extends ClusterBehavior.Type<infer C, infer D, infer E> ? C : never;
+
+type t = ClusterForBehavior<LevelControlBehavior>;
+
+export type PropertyChange<P extends ISYNode<any, any, any, any>> = {
+	driver: keyof DriversOf<P>;
+	newValue: any;
+	oldValue: any;
+	formattedValue: string;
+};
+
+export function ISYClusterBehavior<T extends Constructor<ClusterBehavior> & { cluster: unknown }, P extends ISYNode<any, any, any, any>>(
+	base: T,
+	p: Constructor<P>
+): typeof base & { new (...args: any[]): DeviceBehavior<P, T> } {
+	return class ISYClusterBehavior extends base implements DeviceBehavior<P, T> {
+		_device: P;
+
+		handlers: { [x in keyof DriversOf<P>]: (newValue, oldValue, formattedValue) => void } = {} as any;
+
+		///public map: ClusterMapping<ToClusterTypeByName<ClusterForBehavior<ConstructedType<typeof base>>["name"]>,ISYDeviceNode<any, any, any>>;
+
+		map: ClusterMapping<T['cluster'], P>;
+
+		override async initialize(_options?: {}) {
+			await super.initialize(_options);
+			var behavior = await this.agent.load(ISYBridgedDeviceBehavior);
+			//var behavior = this.agent.get(ISYBridgedDeviceBehavior);
+			this._device = behavior.device as P;
+			this.map = behavior.mapForBehavior<T>(this as unknown as T);
+			for (const key2 in this.map.attributes) {
+				if (typeof this.map.attributes[key2] === 'string') {
+					this.handlers[this.map.attributes[key2]] = (newValue, oldValue, formattedValue) => {
+						this.state[key2 as string] = newValue;
+					};
+				} else if (this.map.attributes[key2].driver) {
+					let { driver, converter } = this.map.attributes[key2];
+					this.handlers[driver] = (newValue, oldValue, formattedValue) => {
+						this.state[key2 as string] = converter(newValue);
+					};
+				}
+			}
+
+			this.reactTo(behavior.events.propertyChanged, this.handlePropertyChange, { lock: false });
+
+			//this._device.on("PropertyChanged", this.handlePropertyChange.bind(this));
+		}
+
+		get device(): P {
+			return (this._device = this._device ?? (this.agent.get(ISYBridgedDeviceBehavior).device as P));
+		}
+
+		handlePropertyChange({ driver, newValue, oldValue, formattedValue }: PropertyChange<P>) {
+			// for (const key2 in this.map.attributes) {
+
+			if (this.handlers[driver]) {
+				this.handlers[driver](newValue, oldValue, formattedValue);
+			}
+			//   if (typeof this.map.attributes[key2] === "string") {
+			//     if(this.map.attributes[key2] == driver)
+			//     {
+			//         this.state[key2 as string] = newValue;
+			//         return;
+
+			//   } }else if (this.map.attributes[key2].driver == driver) {
+			//     if (this.map.attributes[key2]?.driver == driver) {
+			//       this.state[key2 as string] = this.map.attributes[key2].converter(newValue);
+
+			//     }
+			//   }
+			// }
+		}
+	};
+}
+// <reference path="MatterDevice.js" />
+// @ts-ignore
+
+export type DeviceBehavior<P extends ISYNode, T extends { cluster }> = {
+	device: P;
+
+	map: ClusterMapping<T['cluster'], P>;
+
+	handlePropertyChange(chg: PropertyChange<P>): void;
+};

package/src/Matter/Behaviors/ISYOnOffBehavior.ts

@@ -0,0 +1,80 @@
+import { InsteonRelayDevice } from "../../Devices/Insteon/InsteonRelayDevice.js"
+import { OnOffLightRequirements } from "@project-chip/matter.js/devices/OnOffLightDevice";
+import { ISYClusterBehavior, ClusterForBehavior, type PropertyChange } from "./ISYClusterBehavior.js";
+import { OnOffLightSwitchDevice } from '@project-chip/matter.js/devices/OnOffLightSwitchDevice';
+import type { MaybePromise } from '@project-chip/matter.js/util';
+import { MappingRegistry } from '../../Model/ClusterMap.js';
+import type { MutableCluster, OnOffCluster } from '@project-chip/matter.js/cluster';
+import type { OnOffBehavior, OnOffServer } from '@project-chip/matter.js/behaviors/on-off';
+import type { LevelControlServer, LevelControlInterface } from '@project-chip/matter.js/behaviors/level-control';
+import { DriverType } from '../../Definitions/Global/Drivers.js';
+import { DimmableLightRequirements } from '@project-chip/matter.js/devices/DimmableLightDevice';
+import { InsteonDimmableDevice } from '../../Devices/Insteon/InsteonDimmableDevice.js';
+
+import {Converters} from '../../Converters.js';
+
+
+
+
+
+export class ISYOnOffBehavior extends ISYClusterBehavior(OnOffLightRequirements.OnOffServer, InsteonRelayDevice)
+{
+
+    override async initialize(_options?: {}) {
+        await super.initialize(_options);
+        //this.state.onOff = await this.device.state;
+
+
+
+    }
+
+
+  override on = async () => {
+    await super.on();
+
+
+     //this.device.commands.DON = true;
+  }
+
+  override async off() {
+    //await super.off();
+    // this.device.drivers = false;
+  }
+
+  override toggle =  async () => {
+    //this.device.state = !(await this.device.state);
+  }
+
+  override async handlePropertyChange({driver, newValue, oldValue, formattedValue}: PropertyChange<InsteonRelayDevice>) {
+    if (driver === "ST") {
+      this.state.onOff = newValue;
+
+    }
+
+    return super.handlePropertyChange({driver, newValue, oldValue, formattedValue});
+  }
+
+
+}
+
+
+export class ISYDimmableBehavior extends ISYClusterBehavior(DimmableLightRequirements.LevelControlServer, InsteonDimmableDevice) {
+  override async initialize(_options?: {}) {
+    await super.initialize(_options);
+    this.state.currentLevel = this.device.drivers.ST.value;
+    //this.state.onLevel = this.device.drivers.OL;
+
+  }
+
+  override setLevel(level: number): MaybePromise<void> {
+    level = Converters.Matter.LevelFrom0To255.LightingLevel.to(level);
+    if(level > 0)
+    {
+        return this.device.sendCommand('DON',level);
+    }
+    else
+    {
+        return this.device.sendCommand('DOF');
+    }
+  }
+}

package/src/Matter/Mappings/Insteon.json

@@ -0,0 +1,48 @@
+{
+  "InsteonRelayDevice": {
+    "deviceType": "OnOffDevice",
+    "mapping": {
+      "OnOffCluster": {
+        "attributes": {
+          "onOff": "ST",
+          "converter": "onOffConverter"
+        },
+        "commands": { "on": "DON", "off": "DOF" }
+      }
+    }
+  },
+  "InsteonDimmableDevice": {
+    "deviceType": "OnOffLightDevice",
+    "mapping": {
+      "OnOffCluster": {
+        "attributes": {
+          "onOff": "ST"
+        },
+        "commands": { "on": "DON", "off": "DOF" }
+      },
+      "LevelControlCluster": {
+        "attributes": {
+          "currentLevel": "ST"
+        },
+        "commands": { "setLevel": "DON" }
+      }
+    } 
+  },
+  "InsteonFanDevice": {
+    "deviceType": "FanDevice",
+    "mapping": {
+      "OnOffCluster": {
+        "attributes": {
+          "onOff": "ST"
+        },
+        "commands": { "on": "DON", "off": "DOF" }
+      },
+      "LevelControlCluster": {
+        "attributes": {
+          "currentLevel": "ST"
+        },
+        "commands": { "setLevel": "DON" }
+      }
+    }
+  }
+}

package/src/Matter/Mappings/Insteon.ts

@@ -0,0 +1,68 @@
+import { OnOffCluster } from "@project-chip/matter.js/cluster";
+import { DriverType } from "../../Definitions/Global/Drivers.js";
+import { Family, type t } from "../../Definitions/Global/Families.js";
+import { Insteon } from "../../Devices/Insteon/index.js";
+import { Devices} from "../../Devices/index.js";
+import {
+  MappingRegistry,
+  type FamilyToClusterMap,
+  type DeviceToClusterMap,
+  type EndpointMapping
+} from "../../Model/ClusterMap.js";
+import { DeviceTypeDefinition, DeviceTypes, OnOffBaseDevice } from "@project-chip/matter.js/device";
+import { OnOffLightDevice } from "@project-chip/matter.js/devices/OnOffLightDevice";
+
+//import InsteonMap from "./Insteon.json";
+import { DimmableLightDevice } from "@project-chip/matter.js/devices/DimmableLightDevice";
+import { Converters } from '../../Converters.js';
+import type { InsteonRelaySwitchDevice } from '../../Devices/Insteon/InsteonRelaySwitchDevice.js';
+
+
+
+const map: FamilyToClusterMap<Family.Insteon> = {
+  Relay: {
+    deviceType: OnOffLightDevice,
+    mapping:  {
+
+      OnOff: {
+        attributes: {
+          onOff: { driver: "ST"},
+        },
+        commands: { on: 'DON'},
+      },
+
+
+
+    }
+  } ,
+  RelaySwitch: {
+    deviceType: OnOffLightDevice,
+    mapping: {
+      OnOff: {
+        attributes: {
+          onOff: "ST",
+        },
+        commands: { on: "DON"},
+      },
+    },
+  } ,
+  Dimmer: {
+    deviceType: DimmableLightDevice,
+    mapping: {
+      OnOff: {
+        attributes: {
+          onOff: { driver: "ST" },
+        },
+        commands: { on: "DON" },
+      },
+      LevelControl: {
+        attributes: {
+          currentLevel: { driver: DriverType.Status },
+        },
+        commands: { moveToLevel: {command: 'DON'}},
+      },
+    },
+  },
+};
+
+MappingRegistry.register(map);