isy-nodejs 1.0.9-alpha.1 → 1.3.24

package/src/Model/NodeDef.ts

@@ -1,45 +1,41 @@
-import { isArray } from 'util';
-import { Driver } from '../Definitions/Global/Drivers.js'
+import { Driver } from '../Definitions/Global/Drivers.js';
 import type { MaybeArray } from '../Utils.js';
 
-
 export interface DriverDef {
-    id: Driver.Type;
-    editor: string;
-    hide?: string;
-};
-
+	id: Driver.Type;
+	editor: string;
+	hide?: string;
+}
 export interface SendCommandDef {
-    id: string;
+	id: string;
 }
 
 export interface ParamDef {
-  id: string;
-  editor: string;
-  init: string;
-  optional?: string;
+	id: string;
+	editor: string;
+	init: string;
+	optional?: string;
 }
 
 export interface AcceptCommandDef {
-    name?: string;
-    id?: string;
-    p?: MaybeArray<ParamDef>;
+	name?: string;
+	id?: string;
+	p?: MaybeArray<ParamDef>;
 }
 
-export interface NodeDef extends Nested<"st">{
-  id: string;
-  nls: string;
-  nodeType: string;
-  eventMap: string;
-  links: Link;
-  sts: {st: MaybeArray<DriverDef>}
-  cmds: {
-    sends:  {cmd: MaybeArray<SendCommandDef>};
-    accepts: {cmd: MaybeArray<AcceptCommandDef>};
-  };
+export interface NodeDef extends Nested<'st'> {
+	id: string;
+	nls: string;
+	nodeType: string;
+	eventMap: string;
+	links: Link;
+	sts: { st: MaybeArray<DriverDef> };
+	cmds: {
+		sends: { cmd: MaybeArray<SendCommandDef> };
+		accepts: { cmd: MaybeArray<AcceptCommandDef> };
+	};
 }
 
-
 export interface Accept {
 	cmd: Cmd[];
 }
@@ -61,65 +57,51 @@ export interface Link {
 	rsp: Rsp;
 }
 
-
-
 export interface NodeDefs {
 	nodeDef: MaybeArray<NodeDef>;
 }
 
-type n  = NestedObject<"nodeDef">;
+type n = NestedObject<'nodeDef'>;
 
-type s = ReturnType<typeof flattenNestedObject<"nodeDef",NestedObject<"nodeDef">>>;
+type s = ReturnType<typeof flattenNestedObject<'nodeDef', NestedObject<'nodeDef'>>>;
 
-type NestedObject<Label extends string> = { [x in `${Label}s`]: {[y in `${Label}`]: any }};
+type NestedObject<Label extends string> = { [x in `${Label}s`]: { [y in `${Label}`]: any } };
 
 type Singular<T> = T extends `${infer R}s` ? R : never;
 
+type PickNestedProperties<T> = { [P in keyof T]: T[P] extends { [Y in Singular<P>]: any } ? T[P] : never };
 
-type PickNestedProperties<T> = { [P in keyof T]: T[P] extends {[Y in Singular<P>]:any} ? T[P] : never};
-
-type PickStrings<T> = {[P in keyof T]: T[P] & P extends string ? P : never}[keyof T];
-
-
+type PickStrings<T> = { [P in keyof T]: T[P] & P extends string ? P : never }[keyof T];
 
+type PickProperties<T> = { [P in keyof T]: T[P] & P extends { [y in keyof P]: P[y] } ? P : never }[keyof T];
 
-
-type PickProperties<T> = {[P in keyof T]: T[P] & P extends {[y in keyof P]: P[y]} ? P : never}[keyof T];
-
-type GetPropertyTypes<T,Y extends keyof T = keyof T> = T extends {[x in Y]: infer R} ? R : never;
-
+type GetPropertyTypes<T, Y extends keyof T = keyof T> = T extends { [x in Y]: infer R } ? R : never;
 
 type NodeDefProperties = PickNestedProperties<NodeDef>;
 
 type FlattenedNestedObject<T> = T extends NestedObject<infer R> ? R : never;
-  // ?
-  //   Omit<T, `${R}s`> & { [x in `${R}s`]: GetPropertyTypes<T[`${R}s`]> }
-  // : T;
+// ?
+//   Omit<T, `${R}s`> & { [x in `${R}s`]: GetPropertyTypes<T[`${R}s`]> }
+// : T;
 
 type FlattenedNestedNodeDef = FlattenedNestedObject<NodeDef>;
 
-function isNested<T extends string,objType extends object>(property: T, input: any): input is NestedObject<T> {
-
-     let prop = `${property}s`;
-     return input.hasOwnProperty(prop) ? input[prop].hasOwnProperty(property) : false;
+function isNested<T extends string, objType extends object>(property: T, input: any): input is NestedObject<T> {
+	let prop = `${property}s`;
+	return input.hasOwnProperty(prop) ? input[prop].hasOwnProperty(property) : false;
 }
 
-let x = /sts/;
-
-type Nested<T extends string> = { [x in T]: {[y in Singular<x>]: any }};
+type Nested<T extends string> = { [x in T]: { [y in Singular<x>]: any } };
 
 type isNested<T> = T extends Nested<infer R> ? true : false;
 
 //type isNestedNodeDef = isNested<NodeDef>;
 
-
-
-
 export function flattenNestedProperty<T extends string>(input: NestedObject<T>, property: T) {
-  if(isNested(property, input)) {
-    //@ts-expect-error
-    return { ...input, [`${property}s`]: input[`${property}s`][property] };
-  }
+	if (isNested(property, input)) {
+		//@ts-expect-error
+		return { ...input, [`${property}s`]: input[`${property}s`][property] };
+	}
 }
 //   for (const key in Object.keys(input)) {
 //     const subkey = key.left(key.length - 1);
@@ -133,16 +115,18 @@ export function flattenNestedProperty<T extends string>(input: NestedObject<T>,
 //   return clone;
 // }
 
-export function flattenNestedObject<Label extends string,T = unknown> (input: NestedObject<Label>) : Omit<typeof input,Label> & {[x in `${Label}s`]: MaybeArray<T> | T | T[]}{
- let clone = {} as Omit<typeof input,Label> & {[x in `${Label}s`]: MaybeArray<T> | T | T[]};
- for (const key in Object.keys(input)) {
-   const subkey = key.left(key.length - 1);
-   if (isNested(subkey, input)) {
-     const newValue = input[key][subkey];
-     clone[key] = newValue; //isArray(newValue) ? newValue.map(flattenNestedObject) : flattenNestedObject(newValue);
-   } else {
-     clone[key] = input[key];
-   }
- }
-  return clone;
+export function flattenNestedObject<Label extends string, T = unknown>(
+	input: NestedObject<Label>
+): Omit<typeof input, Label> & { [x in `${Label}s`]: MaybeArray<T> | T | T[] } {
+	let clone = {} as Omit<typeof input, Label> & { [x in `${Label}s`]: MaybeArray<T> | T | T[] };
+	for (const key in Object.keys(input)) {
+		const subkey = key.left(key.length - 1);
+		if (isNested(subkey, input)) {
+			const newValue = input[key][subkey];
+			clone[key] = newValue; //isArray(newValue) ? newValue.map(flattenNestedObject) : flattenNestedObject(newValue);
+		} else {
+			clone[key] = input[key];
+		}
+	}
+	return clone;
 }

package/src/Model/NodeInfo.ts

@@ -1,11 +1,15 @@
-import { Family } from '../Definitions/index.js';
-
+import { DeviceInfo } from '../Definitions/Global/Categories.js';
+import { Family, type Category } from '../Definitions/index.js';
 
 import type { DriverState } from './DriverState.js';
 
 // #region Type aliases (1)
 
-export type NodeInfo<T extends Family = Family> = (T extends Family.ZWave | Family.ZigBee ? DynamicNodeInfo : StaticNodeInfo) & { state?: { [x: string]: DriverState } };
+export type NodeInfo<T extends Family = Family> = (T extends Family.ZMatter | Family.ZigBee
+	? DynamicNodeInfo<T>
+	: T extends Family.ZWave
+		? ZWaveNodeInfo
+		: BaseNodeInfo<T>) & { state?: { [x: string]: DriverState } };
 
 // #endregion Type aliases (1)
 
@@ -14,47 +18,48 @@ export type NodeInfo<T extends Family = Family> = (T extends Family.ZWave | Fami
 interface Custom {
 	// #region Properties (2)
 
-	flags: string;
-	val1: string;
+	flags: number | string;
+	val1: number | string;
 
 	// #endregion Properties (2)
 }
 
+interface TypeInfo {
+	t: T[];
+}
+
+interface T {
+	id: 'ioxType' | 'mfgCode' | 'model';
+	val: number | string;
+}
+
 interface Devtype {
 	// #region Properties (3)
 
-	cat: string;
-	gen: string;
+	cat: number;
+	gen: `${number}.${number}.${number}`;
 	mfg: string;
 
 	// #endregion Properties (3)
 }
 
-export interface DynamicNodeInfo {
+export interface DynamicNodeInfo<F extends Family.ZigBee | Family.ZMatter> extends BaseNodeInfo<F> {
+	typeInfo: TypeInfo;
+
+	nodeTypeId: string;
+
+	rpnode: string;
+}
+
+export interface ZWaveNodeInfo extends BaseNodeInfo<Family.ZWave> {
 	// #region Properties (20)
 
-	address: any;
 	custom: Custom;
-	dcPeriod: number;
-	deviceClass?: any;
 	devtype: Devtype;
-	enabled?: boolean;
-	endDelay: number;
-	family?: Family.ZWave;
-	flag?: any;
-	hint: string;
-	name: string;
-	nodeDefId?: string;
-	parent?: Parent;
-	pnode: any;
-	property?: DriverState[] | DriverState;
-
 	rpnode: string;
 	sgid: string;
-	startDelay: number;
-	type?: string;
-	wattage: number;
 
+	nodeTypeId: string;
 	// #endregion Properties (20)
 }
 
@@ -97,7 +102,7 @@ interface RootObject {
 	// #endregion Properties (1)
 }
 
-export interface StaticNodeInfo {
+export interface BaseNodeInfo<F extends Family> {
 	// #region Properties (16)
 
 	address: any;
@@ -105,7 +110,7 @@ export interface StaticNodeInfo {
 	deviceClass?: any;
 	enabled?: boolean;
 	endDelay: number;
-	family?: Family;
+	family?: F extends Family.Poly ? { _: Family.Poly; instance: number } : F;
 	flag?: any;
 	hint: string;
 	name: string;
@@ -124,18 +129,71 @@ export interface StaticNodeInfo {
 
 // #region Functions (3)
 
-export function family<F extends Family>(nodeInfo: NodeInfo<any>): nodeInfo is NodeInfo<F> {
-	if (nodeInfo.family === Family.ZWave) {
+export function isFamily<T extends Family>(nodeInfo: NodeInfo<any>, family: T): nodeInfo is NodeInfo<T> {
+	return nodeInfo.family ?? 1 === family;
+}
+
+export function parseDeviceInfo<F extends Family>(
+	nodeInfo: NodeInfo<F>
+): NodeInfo<F> extends BaseNodeInfo<Family.Insteon>
+	? { category: Category.Insteon; model: number; firmwareVersion: string; firmwareRevision: string }
+	: DeviceInfo<any, any, any> {
+	const type = nodeInfo.type === undefined || nodeInfo.type === '0.0.0.0' ? nodeInfo.hint : nodeInfo.type;
+	const family = (nodeInfo.family ?? nodeInfo.family == 0) ? Family.Insteon : nodeInfo.family;
+	if (isFamily(nodeInfo, Family.Insteon)) {
+		const s = type.split('.');
+		return {
+			category: Number(s[0]),
+			model: Number(s[1]),
+			firmwareVersion: Number(Number(s[2]).toString(16)),
+			firmwareRevision: Number(Number(s[3]).toString(16)),
+		} as any;
+	} else {
+		const s = type.split('.');
+		return { domain: Number(s[0]), category: Number(s[1]), subcategory: Number(s[1]), model: Number(s[2]) } as any;
+	}
+}
+
+export function cleanNodeInfo<T extends Family>(nodeInfo: NodeInfo<T>) {
+	if (isDynamic(nodeInfo)) {
+		nodeInfo.nodeTypeId = `${nodeInfo.typeInfo.t.find(p => p.id == 'ioxType').val}`;
+	} else if (isZWave(nodeInfo)) {
+		nodeInfo.nodeTypeId = nodeInfo.sgid;
+	}
+	if (!nodeInfo.property) {
+		nodeInfo.property = [];
+	}
+	nodeInfo.property = Array.isArray(nodeInfo.property) ? nodeInfo.property : [nodeInfo.property];
+	nodeInfo.state = nodeInfo.property.reduce((acc, p) => {
+		if (p && p?.id) {
+			p.name = p.name == '' ? undefined : p.name;
+			acc[p.id] = p;
+		}
+		return acc;
+	}, {});
+	if (!nodeInfo.family || nodeInfo.family == -1) {
+		nodeInfo.family = Family.Insteon;
+	}
+	return nodeInfo;
+}
+
+export function isPlugin(nodeInfo: NodeInfo<any>): nodeInfo is NodeInfo<Family.Poly> {
+	if (typeof nodeInfo.family == 'object') {
 		return true;
 	}
+	return nodeInfo.family === Family.Poly;
+}
+
+export function isDynamic(nodeInfo: NodeInfo<any>): nodeInfo is DynamicNodeInfo<any> {
+	return [Family.ZMatter, Family.ZigBee].includes(nodeInfo.family);
 }
 
-export function isDynamic(nodeInfo: NodeInfo<any>): nodeInfo is DynamicNodeInfo {
-	return [Family.ZWave, Family.ZigBee].includes(nodeInfo.family);
+export function isZWave(nodeInfo: NodeInfo<any>): nodeInfo is ZWaveNodeInfo {
+	return nodeInfo.family == Family.ZWave;
 }
 
-export function isStatic(nodeInfo: NodeInfo<any>): nodeInfo is StaticNodeInfo {
-	return !isDynamic(nodeInfo);
+export function isStatic(nodeInfo: NodeInfo<any>): nodeInfo is BaseNodeInfo<any> {
+	return isDynamic(nodeInfo) || isZWave(nodeInfo) ? false : true;
 }
 
 // #endregion Functions (3)

package/src/Model/NodeNotes.ts

@@ -1,4 +1,5 @@
 export interface NodeNotes {
+	isLoad: boolean;
 	// #region Properties (2)
 	location: string;
 	spoken: string;

package/src/NodeType.ts

@@ -0,0 +1,6 @@
+export enum NodeType {
+	Device = 1,
+	Scene = 2,
+	Folder = 3,
+	X10A10 = 4,
+}

package/src/Registry.ts

@@ -1,18 +1,17 @@
 import { Family } from './Definitions/index.js';
-import { nodeDefId } from './Devices/Insteon/KeypadButton.js';
 import { NodeFactory } from './Devices/NodeFactory.js';
-import type { ISYDeviceInfo } from './ISYDevice.js';
+import { ISYDevice } from './ISYDevice.js';
 import { ISYNode } from './ISYNode.js';
 import type { StringKeys } from './Utils.js';
 
-export class Registry<K extends keyof any,T> {
-
+export class Registry<K extends keyof any, T> {
 	Global: { [x in K]?: T } = {};
 	FamilyLevel: { [x in StringKeys<typeof Family>]?: { [y in K]?: T } } = {};
 
 	DeviceLevel: { [x: string]: { [y in K]?: T } } = {};
-	NodeLevel: { [x: string]: { [y in K]?: T } } = {};
+	NodeDefLevel: { [x: string]: { [y in K]?: T } } = {};
 
+	ClassLevel: { [x: string]: { [y in K]?: T } } = {};
 
 	registerGlobal(key: K, value: T): void {
 		this.Global[key] = value;
@@ -28,37 +27,49 @@ export class Registry<K extends keyof any,T> {
 		this.DeviceLevel[device]![key] = value;
 	}
 
-	registerNodeLevel(nodeDefId: string, key: K, value: T): void {
-		this.NodeLevel[nodeDefId] = this.NodeLevel[nodeDefId] ?? {};
-		this.NodeLevel[nodeDefId]![key] = value;
+	registerNodeDefLevel(nodeDefId: string, key: K, value: T): void {
+		this.NodeDefLevel[nodeDefId] = this.NodeDefLevel[nodeDefId] ?? {};
+		this.NodeDefLevel[nodeDefId]![key] = value;
 	}
 
-	register(key: K, value: T): void
-	register(key: K, value: T, deviceType: string): void
-	register(key: K, value: T, nodeClass: typeof ISYNode): void
-	register(key: K, value: T, discriminant?: string | typeof ISYNode | Family ): void
-	{
-		if(discriminant === undefined)
-		{
+	registerClassLevel(className: string, key: K, value: T): void {
+		this.ClassLevel[className] = this.ClassLevel[className] ?? {};
+		this.ClassLevel[className]![key] = value;
+	}
+
+	register(key: K, value: T): void;
+	register(key: K, value: T, deviceType: string): void;
+	register(key: K, value: T, factory: ISYDevice.Factory<any, any, any, any, any>): void;
+	register(key: K, value: T, discriminant?: string | Family | ISYDevice.Factory<any, any, any, any, any>): void {
+		if (discriminant === undefined) {
 			this.registerGlobal(key, value);
 			return;
-		}
-		if(typeof discriminant === 'string')
-		{
+		} else if (typeof discriminant === 'string') {
 			this.registerDeviceLevel(discriminant, key, value);
 			return;
-		}
-		if(discriminant instanceof ISYNode.constructor)
-		{
-			this.registerNodeLevel(discriminant.nodeDefId, key, value);
-			for (const nodeDefId in NodeFactory.getImplements(discriminant))
-			{
-				this.registerNodeLevel(nodeDefId, key, value);
+		} else if (typeof discriminant === 'number') {
+			if (discriminant in Family) {
+				this.registerFamilyLevel(discriminant as Family, key, value);
+				return;
+			}
+		} else if (ISYDevice.isNode(discriminant)) {
+			this.registerNodeDefLevel(discriminant.Class.prototype.nodeDefId, key, value);
+			for (const nodeDefId in NodeFactory.getImplements(discriminant)) {
+				this.registerNodeDefLevel(nodeDefId, key, value);
 			}
-			this.registerFamilyLevel(discriminant.family, key, value);
+			this.registerClassLevel(discriminant.Class.name, key, value);
+			this.registerFamilyLevel((discriminant.Class as unknown as typeof ISYNode).family, key, value);
 			return;
-		}
+		} else if (ISYDevice.isComposite(discriminant)) {
+			this.registerClassLevel(discriminant.Class.name, key, value);
 
+			return;
+		}
+		/*else if(ISYDevice.isComposite(discriminant))
+		{
+			this.registerFamilyLevel(discriminant.types, key, value);
+			return;
+		}*/ //TODO: Implement Composite Device
 	}
 
 	getGlobal(key: K): T | undefined {
@@ -74,39 +85,35 @@ export class Registry<K extends keyof any,T> {
 	}
 
 	getNodeLevel(nodeDefId: string, key: K): T | undefined {
-		 return this.NodeLevel[nodeDefId]?.[key];
+		return this.NodeDefLevel[nodeDefId]?.[key];
 	}
 
-	get(device: ISYDeviceInfo & ISYNode, key: K): T | undefined
-	{
-		if(device.type)
-		{
+	getClassLevel(className: string, key: K): T | undefined {
+		return this.ClassLevel[className]?.[key];
+	}
+
+	get(device: ISYDevice.Any, key: K): T | undefined {
+		if (device.type) {
 			let d = this.getDeviceLevel(device.type, key);
-			if(d)
-				return d;
+			if (d) return d;
 		}
-
+		if (ISYDevice.isNode(device)) {
 			let d = this.getNodeLevel(device.nodeDefId, key);
-			if(d)
-			{
+			if (d) {
 				return d;
-			}
-			else
-			{
-				for (const nodeDefId in NodeFactory.getImplements(device))
-				{
+			} else {
+				for (const nodeDefId in NodeFactory.getImplements(device)) {
 					let d = this.getNodeLevel(nodeDefId, key);
-					if(d)
-						return d;
+					if (d) return d;
 				}
 			}
+		}
+		if (ISYDevice.isComposite(device)) {
+			let d = this.getClassLevel(device.constructor.name, key);
+			if (d) return d;
+		}
 		let f = this.getFamilyLevel(device.family, key);
-		if(f)
-			return f;
+		if (f) return f;
 		return this.getGlobal(key);
-
 	}
-
-
-
-}
+}

package/src/{ISYScene.ts → Scenes/ISYScene.ts}

@@ -1,14 +1,13 @@
-import type { Command } from './Definitions/Global/Commands.js';
-import type { Driver } from './Definitions/Global/Drivers.js';
-import { Family } from './Definitions/Global/Families.js';
-import {Insteon} from './Devices/index.js';
-import type { ISY } from './ISY.js';
-import {  LinkType } from './ISYConstants.js';
-import { ISYDevice } from './ISYDevice.js';
-import { ISYNode } from './ISYNode.js';
-import type { NodeInfo, StaticNodeInfo } from './Model/NodeInfo.js';
+import type { Command } from '../Definitions/Global/Commands.js';
+import type { Driver } from '../Definitions/Global/Drivers.js';
+import { Family } from '../Definitions/Global/Families.js';
+import { Insteon } from '../Devices/index.js';
+import type { ISY } from '../ISY.js';
+import { ISYNode } from '../ISYNode.js';
+import { LinkType } from '../LinkType.js';
+import type { BaseNodeInfo, NodeInfo } from '../Model/NodeInfo.js';
 
-interface SceneInfo extends StaticNodeInfo {
+interface SceneInfo extends BaseNodeInfo<Family.Scene> {
 	members?: {
 		link: any;
 	};
@@ -16,19 +15,24 @@ interface SceneInfo extends StaticNodeInfo {
 	nodeDefId?: 'InsteonDimmer';
 	address: string;
 	name: string;
-	family?: Family;
+	family?: Family.Scene;
 	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<
+	Family.Scene,
+	Driver.Signatures<'ST'>,
+	Command.Signatures<'DON' | 'DOF' | 'QUERY'>
+> {
 	public connectionType: string;
 	public batteryOperated: boolean;
 	public deviceType: any;
 	public deviceFriendlyName: string;
-	public members: ISYNode<any, any, any,any>[];
+	public members: ISYNode<any, any, any, any>[];
 	public typeCode: string;
+
 	constructor(isy: ISY, scene: SceneInfo) {
 		super(isy, scene as NodeInfo);
 		// this.logger(JSON.stringify(scene));
@@ -119,7 +123,13 @@ export class ISYScene extends ISYNode<Family.Scene, Driver.Signatures<'ST'>, Com
 		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 + '%'
+			);
 		}
 	}
 	public async updateIsOn(lightState: boolean) {