isy-nodejs 1.0.1-alpha.1 → 1.0.1-alpha.11

package/src/ISYNode.ts

@@ -6,6 +6,7 @@ import { UnitOfMeasure } from './Definitions/Global/UOM.js';
 import { ISY, NodeType, type ISYScene } from './ISY.js';
 
 import { CliConfigSetLevels } from 'winston/lib/winston/config/index.js';
+import { Converter } from './Converters.js';
 import type { Command } from './Definitions/Global/Commands.js';
 import { Event } from './Definitions/Global/Events.js';
 import type { Constructor } from './Devices/Constructor.js';
@@ -164,21 +165,33 @@ export class ISYNode<
 	}
 
 	public convert(value: any, from: UnitOfMeasure, to: UnitOfMeasure): any {
-		return value;
+		if (from === to) return value;
+		else {
+			try {
+				return Converter.Standard[from][to].from(value);
+			} catch {
+				this.isy.logger.error(`Conversion from ${UnitOfMeasure[from]} to ${UnitOfMeasure[to]} not supported.`);
+			} finally {
+				return value;
+			}
+		}
 	}
 
 	public convertFrom(value: any, uom: UnitOfMeasure, propertyName?: StringKeys<D>): any {
-		throw new Error('Method not implemented.');
+		if (this.drivers[propertyName]?.uom != uom) {
+			this.logger(`Converting ${this.drivers[propertyName].label} to ${UnitOfMeasure[this.drivers[propertyName]?.uom]} from ${UnitOfMeasure[uom]}`);
+			return this.convert(value, uom, this.drivers[propertyName].uom);
+		}
 	}
 
 	public convertTo(value: any, uom: UnitOfMeasure, propertyName?: StringKeys<D>) {
-		if (this.drivers[propertyName].uom != uom) {
-			this.isy.logger.debug(`Converting ${this.drivers[propertyName].label} from ${this.drivers[propertyName].uom} to ${UnitOfMeasure}`);
-			return this.convertTo(value, uom);
+		if (this.drivers[propertyName]?.uom != uom) {
+			this.isy.logger.debug(`Converting ${this.drivers[propertyName].label} from ${UnitOfMeasure[this.drivers[propertyName].uom]} to ${UnitOfMeasure[uom]}`);
+			return this.convert(value, uom, this.drivers[propertyName].uom);
 		}
 	}
 
-	public emit(event: 'PropertyChanged' | 'ControlTriggered', propertyName?: string, newValue?: any, oldValue?: any, formattedValue?: string, controlName?: string) {
+	public emit(event: 'propertyChanged' | 'controlTriggered', propertyName?: string, newValue?: any, oldValue?: any, formattedValue?: string, controlName?: string) {
 		//if ('PropertyChanged') return super.emit(event, propertyName, newValue, oldValue, formattedValue);
 		//else if ('ControlTriggered') return super.emit(event, controlName);
 	}
@@ -206,7 +219,7 @@ export class ISYNode<
 
 	public async getNotes(): Promise<NodeNotes> {
 		try {
-			const result = await this.isy.sendRequest(`nodes/${this.address}/notes`);
+			const result = await this.isy.sendRequest(`nodes/${this.address}/notes`,{trailingSlash: false,errorLogLevel: 'debug'});
 			if (result !== null && result !== undefined) {
 				return result.NodeProperties;
 			} else {
@@ -219,7 +232,7 @@ export class ISYNode<
 
 	public handleControlTrigger(controlName: keyof E & keyof C): boolean {
 		//this.lastChanged = new Date();
-		this.events.emit('ControlTriggered', controlName);
+		this.events.emit('controlTriggered', controlName);
 		return true;
 	}
 
@@ -240,23 +253,26 @@ export class ISYNode<
 		} else {
 			// this.logger(event.control);
 			const e = event.control;
-			const dispName = this.commands[e].name;
+			const dispName = this.commands[e]?.name;
 			if (dispName !== undefined && dispName !== null) {
-				this.logger(`Command ${dispName} (${e}) triggered.`);
+				this.logger(`Command ${dispName} (${e}) event sent.`);
 			} else {
-				this.logger(`Command ${e} triggered.`);
+				this.logger(`Command ${e} event sent.`);
 			}
 			this.handleControlTrigger(e);
 			return true;
 		}
 	}
 
-	public handlePropertyChange(propertyName: StringKeys<D>, value: any, uom: UnitOfMeasure, formattedValue: string, prec?: number): boolean {
+	public handlePropertyChange(propertyName: StringKeys<D>, value: any, uom: UnitOfMeasure, prec?: number, formattedValue?: string): boolean {
 		this.lastChanged = new Date();
-		const oldValue = this.drivers[propertyName].value;
-		if (this.drivers[propertyName].patch(value, formattedValue, uom, prec)) {
-			this.emit('PropertyChanged', propertyName, value, oldValue, formattedValue);
-			this.scenes.forEach((element) => {
+		let driver = this.drivers[propertyName];
+		this.logger(`Driver ${propertyName} (${driver?.label} value update ${value} (${formattedValue}) uom: ${UnitOfMeasure[uom]} event received.`);
+		const oldValue = driver?.value;
+		if (driver?.patch(value, formattedValue, uom, prec)) {
+			this.logger(`Driver ${driver.label} updated from ${oldValue} to ${value} (${formattedValue})`);
+			this.emit('propertyChanged', propertyName, value, oldValue, formattedValue);
+			this.scenes?.forEach((element) => {
 				this.logger(`Recalulating ${element.deviceFriendlyName}`);
 				element.recalculateState();
 			});
@@ -523,7 +539,7 @@ export namespace ISYNode {
       [K in C[U]["name"]]: C[K];
     } : never;*/
 
-	export const With = <K extends Family, D extends DriverSignatures, C extends CommandSignatures, T extends Constructor<ISYNode<K,  any, any, any>>>(Base: T) => {
+	export const With = <K extends Family, D extends DriverSignatures, C extends CommandSignatures, T extends Constructor<ISYNode<K, any, any, any>>>(Base: T) => {
 		return class extends Base implements Omit<ISYNode<K, D, C>, 'events'> {
 			declare drivers: Driver.ForAll<any, false>;
 			declare commands: Command.ForAll<C>;

package/src/ISYScene.ts

@@ -77,7 +77,7 @@ export class ISYScene extends ISYNode<Family.Scene, Driver.Signatures<'ST'>,Comm
 	get isOn() {
 		for (const device of this.members) {
 			if (device instanceof Insteon.Relay)  {
-				if (device.drivers.ST?.value === 1) {
+				if (device.drivers.ST?.value != 0) {
 					return true;
 				}
 			}
@@ -110,10 +110,10 @@ export class ISYScene extends ISYNode<Family.Scene, Driver.Signatures<'ST'>,Comm
 	}
 	public markAsChanged() {
 		this.lastChanged = new Date();
-		this.emit('PropertyChanged', 'isOn', this.isOn, this.isOn, this.isOn ? 'on' : 'off');
+		this.emit('propertyChanged', 'isOn', this.isOn, this.isOn, this.isOn ? 'on' : 'off');
 
 		if (this.isDimmable) {
-			this.emit('PropertyChanged', 'brightnesslevel', this.brightnessLevel, this.brightnessLevel, this.brightnessLevel + '%');
+			this.emit('propertyChanged', 'brightnesslevel', this.brightnessLevel, this.brightnessLevel, this.brightnessLevel + '%');
 
 		}
 	}

package/src/Matter/Behaviors/ISYBridgedDeviceBehavior.ts

@@ -11,11 +11,11 @@ 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';
+import { DeviceToClusterMap, MappingRegistry, type ClusterMapping, type BehaviorMapping } from '../../Model/ClusterMap.js';
 
 
 type ClusterForBehavior<B extends ClusterBehavior> = B extends ClusterBehavior.Type<infer C> ? C : never;
-export class ISYBridgedDeviceBehavior extends Behavior {
+export class ISYBridgedDeviceBehavior<N extends ISYNode<any, D, any, any>, D extends ISYNode.DriverSignatures = ISYNode.DriverSignatures> extends Behavior {
 	static override readonly id = 'isyNode';
 
 	static override readonly early = true;
@@ -23,16 +23,24 @@ export class ISYBridgedDeviceBehavior extends Behavior {
 	declare internal: ISYBridgedDeviceBehavior.Internal;
 	declare state: ISYBridgedDeviceBehavior.State;
 
-	declare events: ISYBridgedDeviceBehavior.Events;
+	declare events: ISYBridgedDeviceBehavior.Events & ISYBridgedDeviceBehavior.EventsFor<N["drivers"]>;
 
 	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>);
+		const d = ISY.instance.nodeMap.get(this.state.address);
+		this.internal.device = d;
+		this.internal.map = MappingRegistry.getMapping(this.internal.device as unknown as ISYNode<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));
+		if (d) {
+			d.events.on('PropertyChanged', this.handlePropertyChange.bind(this));
+			for(const f in d.drivers)
+			{
+				let evt = `${d.drivers[f].name}Changed`;
+				this.events[evt] = Observable<[{ driver: string; newValue: any; oldValue: any; formattedValue: string }]>();
+				//@ts-ignore
+				d.events.on(evt, (driver: string, newValue: any, oldValue: any, formattedValue: string) => this.events.emit(evt, { driver, newValue, oldValue, formattedValue } as unknown as any));
+			}
 		}
 	}
 
@@ -44,15 +52,15 @@ export class ISYBridgedDeviceBehavior extends Behavior {
 		return this.internal.map;
 	}
 
-	mapForBehavior<B extends { cluster: unknown }>(behavior: B): ClusterMapping<B['cluster'], typeof this.internal.device> {
-		return this.map[behavior.cluster['name']];
+	mapForBehavior<B extends ClusterBehavior>(behavior: B): BehaviorMapping<B, typeof this.internal.device> {
+		return this.map.mapping[behavior.cluster['name']];
 	}
 
 	handlePropertyChange(driver: string, newValue: any, oldValue: any, formattedValue: string) {
 		this.events.propertyChanged.emit({ driver, newValue, oldValue, formattedValue });
 	}
 
-	[Symbol.asyncDispose]() {
+	override [Symbol.asyncDispose]() {
 		this.internal.device = null;
 		return super[Symbol.asyncDispose]();
 	}
@@ -64,8 +72,18 @@ export namespace ISYBridgedDeviceBehavior {
 		map?: DeviceToClusterMap<typeof this.device, any>;
 	}
 
-	export class Events extends EventEmitter {
+	export type EventsFor<D extends {[x: string]: Driver<any,any,any>}> = {
+		[s in keyof D as `${D[s]["name"]}Changed`] : Observable<[{ driver: s; newValue: any; oldValue: any; formattedValue: string }]>;
+	}
+
+
+
+
+	export class Events extends EventEmitter{
 		propertyChanged = Observable<[{ driver: string; newValue: any; oldValue: any; formattedValue: string }]>();
+
+
+
 	}
 
 	export class State {

package/src/Matter/Behaviors/ISYClusterBehavior.ts

@@ -1,38 +1,50 @@
-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 type { ClusterBehavior, ClusterInterface } from '@project-chip/matter.js/behavior/cluster';
 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 { Converter } from '../../Converters.js';
+import { Driver, 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 type { DriversOf, ISYNode } from '../../ISYNode.js';
+import { BehaviorMapping, 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;
+// #region Type aliases (6)
 
+export type ClusterForBehavior<B> = B extends ClusterBehavior.Type<infer C, infer D, infer E> ? C : never;
 export type ConstructedType<B extends Constructor<any>> = B extends Constructor<infer C> ? C : never;
+// <reference path="MatterDevice.js" />
+// @ts-ignore
+export type DeviceBehavior<P extends ISYNode, T extends { cluster? }> = {
+	device: P;
 
-export type ClusterForBehavior<B> = B extends ClusterBehavior.Type<infer C, infer D, infer E> ? C : never;
+	bridgedDeviceBehavior: ISYBridgedDeviceBehavior<P>;
 
-type t = ClusterForBehavior<LevelControlBehavior>;
+	//ts-ignore
+	map: BehaviorMapping<T, P>;
 
+	handlePropertyChange(chg: PropertyChange<P>): void;
+};
+type NotUnknown<T extends ClusterBehavior> = T extends { cluster: { name: 'Unknown' } } ? never : T;
 export type PropertyChange<P extends ISYNode<any, any, any, any>> = {
 	driver: keyof DriversOf<P>;
 	newValue: any;
 	oldValue: any;
 	formattedValue: string;
 };
+type t = ClusterForBehavior<LevelControlBehavior>;
+
+// #endregion Type aliases (6)
 
-export function ISYClusterBehavior<T extends Constructor<ClusterBehavior> & { cluster: unknown }, P extends ISYNode<any, any, any, any>>(
+// #region Functions (1)
+
+export function ISYClusterBehavior<T extends Constructor<ClusterBehavior> & { cluster }, P extends ISYNode<any, any, any, any>>(
 	base: T,
 	p: Constructor<P>
 ): typeof base & { new (...args: any[]): DeviceBehavior<P, T> } {
@@ -41,30 +53,44 @@ export function ISYClusterBehavior<T extends Constructor<ClusterBehavior> & { cl
 
 		handlers: { [x in keyof DriversOf<P>]: (newValue, oldValue, formattedValue) => void } = {} as any;
 
+		bridgedDeviceBehavior: ISYBridgedDeviceBehavior<P>;
 		///public map: ClusterMapping<ToClusterTypeByName<ClusterForBehavior<ConstructedType<typeof base>>["name"]>,ISYDeviceNode<any, any, any>>;
 
-		map: ClusterMapping<T['cluster'], P>;
+		map: BehaviorMapping<T, P>;
 
 		override async initialize(_options?: {}) {
 			await super.initialize(_options);
-			var behavior = await this.agent.load(ISYBridgedDeviceBehavior);
+			var behavior = (await this.agent.load(ISYBridgedDeviceBehavior)) as ISYBridgedDeviceBehavior<P>;
+			this.bridgedDeviceBehavior = behavior;
 			//var behavior = this.agent.get(ISYBridgedDeviceBehavior);
 			this._device = behavior.device as P;
+			//@ts-ignore
 			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) => {
+				let val = this.map.attributes[key2];
+				let driverObj = null;
+				if (typeof val === 'string' || typeof val === 'symbol' || typeof val === 'number') {
+					driverObj = this._device.drivers[val];
+					this.handlers[val] = (newValue, oldValue, formattedValue) => {
 						this.state[key2 as string] = newValue;
 					};
-				} else if (this.map.attributes[key2].driver) {
-					let { driver, converter } = this.map.attributes[key2];
+				} else if (val.driver as DriversOf<P>) {
+					driverObj = this._device.drivers[val.driver as string];
+
+					let { driver, converter } = val;
+					const convFunc = Converter.get(converter)?.from;
 					this.handlers[driver] = (newValue, oldValue, formattedValue) => {
-						this.state[key2 as string] = converter(newValue);
+						if (convFunc) this.state[key2 as string] = convFunc(newValue);
+						else this.state[key2 as string] = newValue;
 					};
 				}
+				if (driverObj) {
+					let evt = `${driverObj.name}Changed`;
+					this.reactTo(behavior.events[evt], this.handlePropertyChange.bind(this), { lock: false });
+				}
 			}
 
-			this.reactTo(behavior.events.propertyChanged, this.handlePropertyChange, { lock: false });
+			//this.reactTo(behavior.events.propertyChanged, this.handlePropertyChange, { lock: false });
 
 			//this._device.on("PropertyChanged", this.handlePropertyChange.bind(this));
 		}
@@ -95,13 +121,5 @@ export function ISYClusterBehavior<T extends Constructor<ClusterBehavior> & { cl
 		}
 	};
 }
-// <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;
-};
+// #endregion Functions (1)

package/src/Matter/Behaviors/ISYOnOffBehavior.ts

@@ -1,80 +1,69 @@
-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 type { LevelControlInterface, LevelControlServer } from '@project-chip/matter.js/behaviors/level-control';
+import type { OnOffBehavior, OnOffServer } from '@project-chip/matter.js/behaviors/on-off';
+import type { MutableCluster, OnOffCluster } from '@project-chip/matter.js/cluster';
+import { DimmableLightRequirements } from '@project-chip/matter.js/devices/DimmableLightDevice';
+import { OnOffLightRequirements } from '@project-chip/matter.js/devices/OnOffLightDevice';
 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 { InsteonRelayDevice } from '../../Devices/Insteon/InsteonRelayDevice.js';
+import { MappingRegistry } from '../../Model/ClusterMap.js';
+import { ClusterForBehavior, ISYClusterBehavior, type PropertyChange } from './ISYClusterBehavior.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;
-
-
+import { Converter } 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();
+		await this.device.on();
 
-  override on = async () => {
-    await super.on();
+		//this.device.commands.DON = true;
+	};
 
+	override async off() {
+		await super.off();
+		await this.device.off();
 
-     //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);
-  }
+		// this.device.drivers = false;
+	}
 
-  override async handlePropertyChange({driver, newValue, oldValue, formattedValue}: PropertyChange<InsteonRelayDevice>) {
-    if (driver === "ST") {
-      this.state.onOff = newValue;
+	override toggle = async () => {
 
-    }
+		//this.device.state = !(await this.device.state);
+	};
 
-    return super.handlePropertyChange({driver, newValue, oldValue, formattedValue});
-  }
+	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');
-    }
-  }
-}
+	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 = Converter.Matter.LevelFrom0To255.LightingLevel.from(level);
+		if (level > 0) {
+			return this.device.sendCommand('DON', level);
+		} else {
+			return this.device.sendCommand('DOF');
+		}
+	}
+}