isy-nodejs 1.0.1-alpha.9 → 1.0.2-alpha.1

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,9 +1,9 @@
-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 { Converter } from './Converters.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;
@@ -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 {

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;
 				}
 			}

package/src/Matter/Behaviors/ISYBridgedDeviceBehavior.ts

@@ -9,9 +9,14 @@ 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, 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;
@@ -30,16 +35,26 @@ export class ISYBridgedDeviceBehavior<N extends ISYNode<any, D, any, any>, D ext
 		var address = this.state.address;
 		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>);
+		this.internal.map = MappingRegistry.getMapping(this.internal.device 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 (d) {
-			d.events.on('PropertyChanged', this.handlePropertyChange.bind(this));
+			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 }]>();
+				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));
+				//d.events.on(evt, (driver: string, newValue: any, oldValue: any, formattedValue: string) => this.events.emit(evt, { driver, newValue, oldValue, formattedValue } as unknown as any));
+
 			}
 		}
 	}
@@ -57,11 +72,17 @@ export class ISYBridgedDeviceBehavior<N extends ISYNode<any, D, any, any>, D ext
 	}
 
 	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]();
 	}
 }

package/src/Matter/Behaviors/ISYClusterBehavior.ts

@@ -1,18 +1,10 @@
-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 { 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 { 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 type { DriversOf, ISYNode } from '../../ISYNode.js';
-import { BehaviorMapping, MappingRegistry, type ClusterMapping, type DeviceToClusterMap } from '../../Model/ClusterMap.js';
+import { BehaviorMapping } from '../../Model/ClusterMap.js';
 import { ISYBridgedDeviceBehavior } from './ISYBridgedDeviceBehavior.js';
 
 // #region Type aliases (6)
@@ -21,7 +13,7 @@ export type ClusterForBehavior<B> = B extends ClusterBehavior.Type<infer C, infe
 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? }> = {
+export type DeviceBehavior<P extends ISYNode<any, any, any, any>, T extends { cluster? }> = {
 	device: P;
 
 	bridgedDeviceBehavior: ISYBridgedDeviceBehavior<P>;
@@ -60,33 +52,40 @@ export function ISYClusterBehavior<T extends Constructor<ClusterBehavior> & { cl
 
 		override async initialize(_options?: {}) {
 			await super.initialize(_options);
+
 			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) {
 				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 (val.driver as DriversOf<P>) {
 					driverObj = this._device.drivers[val.driver as string];
 
 					let { driver, converter } = val;
-					const convFunc = Converter.get(converter)?.from;
+					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) => {
-						if (convFunc) this.state[key2 as string] = convFunc(newValue);
-						else this.state[key2 as string] = 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.reactTo(behavior.events[evt], this.handlePropertyChange.bind(this), { lock: false });
+					(this as any).evt = this.handlers[driverObj.name];
+					this.reactTo(behavior.events[evt], this.handlePropertyChange, { lock: false });
 				}
 			}
 
@@ -99,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);
 			}

package/src/Matter/Behaviors/{ISYOnOffBehavior.ts → Insteon/ISYOnOffBehavior.ts}

@@ -5,46 +5,34 @@ import { DimmableLightRequirements } from '@project-chip/matter.js/devices/Dimma
 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 { 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';
+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 super.on();
 		await this.device.on();
 
 		//this.device.commands.DON = true;
 	};
 
 	override async off() {
-		await super.off();
 		await this.device.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 });
 	}
@@ -53,7 +41,8 @@ export class ISYOnOffBehavior extends ISYClusterBehavior(OnOffLightRequirements.
 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 = Converter.get('Level255toZero.LightingLevel').to(this.device.drivers.OL)*/
+		//this.state.currentLevel = this.device.drivers.ST.value;
 
 		//this.state.onLevel = this.device.drivers.OL;
 	}
@@ -61,9 +50,10 @@ export class ISYDimmableBehavior extends ISYClusterBehavior(DimmableLightRequire
 	override setLevel(level: number): MaybePromise<void> {
 		level = Converter.Matter.LevelFrom0To255.LightingLevel.from(level);
 		if (level > 0) {
-			return this.device.sendCommand('DON', level);
+			return this.device.on(level);
 		} else {
-			return this.device.sendCommand('DOF');
+			return this.device.off();
 		}
+
 	}
 }