isy-nodejs 1.0.1-alpha.6 → 1.0.2-alpha.0

package/src/ISYDevice.ts

@@ -1,8 +1,9 @@
 import type { Command } from './Definitions/Global/Commands.js';
 import type { Driver } from './Definitions/Global/Drivers.js';
 import type { UnitOfMeasure } from './Definitions/Global/UOM.js';
-import type { Family, ISY } from './ISY.js';
-import type {  ISYNode } from './ISYNode.js';
+import type { Family } from './Definitions/index.js';
+import type { ISY } from './ISY.js';
+import type { ISYNode } from './ISYNode.js';
 import type { ISYScene } from './ISYScene.js';
 import type { DriverState } from './Model/DriverState.js';
 import type { StringKeys } from './Utils.js';

package/src/ISYError.ts

@@ -0,0 +1,29 @@
+import type { ISYNode } from './ISYNode.js';
+
+export class ISYError extends Error {
+	constructor(message: string);
+	constructor(error: Error);
+	constructor(messageOrError: string | Error) {
+		if (messageOrError instanceof Error) {
+			super(messageOrError.message);
+			this.stack = messageOrError.stack;
+			this.cause = messageOrError;
+			this.name = 'ISYError';
+		} else if (typeof messageOrError === 'string') {
+			super(messageOrError);
+			this.name = 'ISYError';
+		}
+	}
+}
+
+class ISYNodeError extends ISYError {
+	constructor(message: string, node: ISYNode);
+	constructor(error: Error, node: ISYNode);
+	constructor(messageOrError: string | Error, node: ISYNode) {
+		super(messageOrError as any);
+		this.name = 'ISYNodeError';
+		this.node = node;
+	}
+
+	node: ISYNode;
+}

package/src/ISYNode.ts

@@ -1,12 +1,12 @@
-import type { Merge, UnionToIntersection } from '@project-chip/matter.js/util';
+
 import { Logger } from 'winston';
 import { Driver } from './Definitions/Global/Drivers.js';
 import { Family } from './Definitions/Global/Families.js';
 import { UnitOfMeasure } from './Definitions/Global/UOM.js';
-import { ISY, NodeType, type ISYScene } from './ISY.js';
+import { ISY } from './ISY.js';
 
 import { CliConfigSetLevels } from 'winston/lib/winston/config/index.js';
-import { Converters } from './Converters.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';
@@ -14,13 +14,16 @@ import type { DriverState } from './Model/DriverState.js';
 import { NodeInfo } from './Model/NodeInfo.js';
 import type { NodeNotes } from './Model/NodeNotes.js';
 import { type StringKeys } from './Utils.js';
+import { NodeType } from './ISYConstants.js';
+import type { ISYScene } from './ISYScene.js';
+import type { UnionToIntersection } from '@matter/general';
 
 //type DriverValues<DK extends string | number | symbol,V = any> = {[x in DK]?:V};
 
 export class ISYNode<
-	T extends Family,
-	D extends ISYNode.DriverSignatures,
-	C extends ISYNode.CommandSignatures,
+	T extends Family = Family,
+	D extends ISYNode.DriverSignatures = {},
+	C extends ISYNode.CommandSignatures = {},
 	E extends ISYNode.EventSignatures = { [x in keyof D]: Event.DriverToEvent<D[x]> & { driver: x } } & { [x in keyof C]: Event.CommandToEvent<C[x]> & { command: x } }
 > {
 	// #region Properties (32)
@@ -106,7 +109,7 @@ export class ISYNode<
 			.trim();
 		if (this.parentType === NodeType.Folder) {
 			this.folder = isy.folderMap.get(this.parent._);
-			isy.logger.info(`${this.name} this node is in folder ${this.folder}`);
+			isy.logger.debug(`${this.name} is in folder ${this.folder}`);
 			this.logger = (msg: any, level: keyof CliConfigSetLevels = 'debug', ...meta: any[]) => {
 				isy.logger[level](`${this.folder} ${this.name} (${this.address}): ${msg}`, meta);
 				return isy.logger;
@@ -168,7 +171,7 @@ export class ISYNode<
 		if (from === to) return value;
 		else {
 			try {
-				return Converters.Standard[from][to].from(value);
+				return Converter.Standard[from][to].from(value);
 			} catch {
 				this.isy.logger.error(`Conversion from ${UnitOfMeasure[from]} to ${UnitOfMeasure[to]} not supported.`);
 			} finally {
@@ -191,7 +194,7 @@ export class ISYNode<
 		}
 	}
 
-	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);
 	}
@@ -219,7 +222,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', validateStatus(status) { return true; }});
 			if (result !== null && result !== undefined) {
 				return result.NodeProperties;
 			} else {
@@ -232,7 +235,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;
 	}
 
@@ -255,20 +258,23 @@ export class ISYNode<
 			const e = event.control;
 			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);
+		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();

package/src/ISYScene.ts

@@ -32,7 +32,7 @@ export class ISYScene extends ISYNode<Family.Scene, Driver.Signatures<'ST'>,Comm
 	public members: ISYDevice<any,any,any>[];
 	public typeCode: string;
 	constructor(isy: ISY, scene: SceneInfo) {
-		super(isy, scene as SceneInfo);
+		super(isy, scene as NodeInfo);
 		// this.logger(JSON.stringify(scene));
 		this.typeCode = '';
 		this.connectionType = 'Insteon Wired';
@@ -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 != 0) {
+				if (device.drivers.ST?.value) {
 					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

@@ -9,13 +9,16 @@ 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 { ISY } 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';
+import { server } from 'typescript';
+import type { ISYNode } from '../../ISYNode.js';
+import type { Family } from '../../Definitions/index.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 +26,32 @@ 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`;
+				const obs = Observable<[{ driver: string; newValue: any; oldValue: any; formattedValue: string }]>();
+
+				d.events.on(evt, (driver: string, newValue: any, oldValue: any, formattedValue: string) => obs.emit({ driver, newValue, oldValue, formattedValue }));
+				this.events[evt] = obs;
+
+
+				//@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,16 +63,22 @@ 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 });
+
+
 	}
 
 	override [Symbol.asyncDispose]() {
+
 		this.internal.device = null;
+
+
 		return super[Symbol.asyncDispose]();
 	}
 }
@@ -64,8 +89,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,42 @@
-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 { ClusterBehavior } from '@project-chip/matter.js/behavior/cluster';
 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 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 } 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<any, any, any, any>, 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>;
 
-export function ISYClusterBehavior<T extends Constructor<ClusterBehavior> & { cluster: unknown }, P extends ISYNode<any, any, any, any>>(
+// #endregion Type aliases (6)
+
+// #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 +45,51 @@ 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.state[key2 as string] = this._device.drivers[val].value;
+					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)?.to;
+					if(!convFunc) throw new Error(`Converter ${converter} not found`);
+					this.state[key2 as string] = convFunc(this._device.drivers[driver as string].value);
 					this.handlers[driver] = (newValue, oldValue, formattedValue) => {
-						this.state[key2 as string] = converter(newValue);
+						//if (convFunc) this.state[key2 as string] = convFunc(newValue);
+						 this.state[key2 as string] = convFunc(newValue);
 					};
 				}
+				if (driverObj) {
+					let evt = `${driverObj.name}Changed`;
+					(this as any).evt = this.handlers[driverObj.name];
+					this.reactTo(behavior.events[evt], this.handlePropertyChange, { 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));
 		}
@@ -73,9 +98,9 @@ export function ISYClusterBehavior<T extends Constructor<ClusterBehavior> & { cl
 			return (this._device = this._device ?? (this.agent.get(ISYBridgedDeviceBehavior).device as P));
 		}
 
-		handlePropertyChange({ driver, newValue, oldValue, formattedValue }: PropertyChange<P>) {
+		async handlePropertyChange({ driver, newValue, oldValue, formattedValue }: PropertyChange<P>) {
 			// for (const key2 in this.map.attributes) {
-
+			await this.initialize();
 			if (this.handlers[driver]) {
 				this.handlers[driver](newValue, oldValue, formattedValue);
 			}
@@ -95,13 +120,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/Insteon/ISYOnOffBehavior.ts

@@ -0,0 +1,59 @@
+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 { DriverType } from '../../../Definitions/Global/Drivers.js';
+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 { Converter } from '../../../Converters.js';
+
+export class ISYOnOffBehavior extends ISYClusterBehavior(OnOffLightRequirements.OnOffServer, InsteonRelayDevice) {
+	override async initialize(_options?: {}) {
+		await super.initialize(_options);
+		//this.state.onOff = this.device.status;
+		//this.state.onOff = await this.device.state;
+	}
+
+	override on = async () => {
+		await this.device.on();
+
+		//this.device.commands.DON = true;
+	};
+
+	override async off() {
+		await this.device.off();
+
+		// this.device.drivers = false;
+	}
+
+	override async handlePropertyChange({ driver, newValue, oldValue, formattedValue }: PropertyChange<InsteonRelayDevice>) {
+
+		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.onLevel = Converter.get('Level255toZero.LightingLevel').to(this.device.drivers.OL)*/
+		//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.on(level);
+		} else {
+			return this.device.off();
+		}
+
+	}
+}