isy-nodejs 1.0.8-alpha.0 → 1.3.24

package/src/Devices/ZigBee/ZigBeeDeviceFactory.ts

@@ -0,0 +1,135 @@
+import { NodeInfo } from '../../Model/NodeInfo.js';
+
+import { Family } from '../../Definitions/index.js';
+import type { ISYDevice } from '../../ISYDevice.js';
+
+import { ColorControl, LevelControl, OnOff } from '@matter/main/clusters';
+import { ClusterId, type ClusterType } from '@matter/types';
+import { ISY, writeDebugFile } from '../../ISY.js';
+
+import { ColorTemperatureLight, DimmableLight, ExtendedColorLight } from './index.js';
+import { OnOffLight } from './OnOffLight.js';
+import { hasBitFlag, type ZigBeeClusterData } from './ZigbeeClusterData.js';
+
+export function parseZigbeeClusterData(input: string): { [x: string]: ZigBeeClusterData<any> } {
+	const clusters: { [x: ClusterId]: ZigBeeClusterData<ClusterType> } = {};
+	const clusterRegex = /Cluster (\d+) 0x([0-9A-Fa-f]+) ([\w_]+)/g;
+	const dataRegex = /(\w+)\s+DATA\s+devices\.\d+\.endpoints\.(\d+)\.clusters\.\d+\.data\.?([\w\.]*)\s*=\s*(.+)/gm;
+
+	let currentCluster: ZigBeeClusterData<ClusterType> | null = null;
+
+	input?.split('\n').forEach(line => {
+		clusterRegex.lastIndex = 0; // Reset lastIndex for clusterRegex
+		const clusterMatch = clusterRegex.exec(line);
+		if (clusterMatch) {
+			if (currentCluster) clusters[currentCluster.clusterName] = currentCluster;
+			currentCluster = {
+				clusterId: ClusterId(parseInt(clusterMatch[1], 10)),
+				clusterName: clusterMatch[3] as Uppercase<string>,
+				endpoint: 0, // Placeholder, will be updated later
+				data: {},
+			};
+			return;
+		}
+		dataRegex.lastIndex = 0; // Reset lastIndex for dataRegex
+		const dataMatch = dataRegex.exec(line);
+		if (dataMatch && currentCluster) {
+			const [, type, endpoint, key, value] = dataMatch;
+			currentCluster.endpoint = parseInt(endpoint, 10);
+			currentCluster.data[key] = parseValue(type, value);
+		}
+	});
+	if (currentCluster) {
+		clusters[currentCluster?.clusterName] = currentCluster;
+	}
+	return clusters;
+}
+
+function parseValue(type: string, value: string): any {
+	switch (type) {
+		case 'Boolean':
+			return value.trim() === 'True';
+		case 'Integer':
+			return parseInt(value, 10);
+		case 'Binary':
+			return value.match(/\[([0-9A-Fa-f]+)\]/)?.[1] || value;
+		case 'Empty':
+			return null;
+		default:
+			return value.trim();
+	}
+}
+export class ZigBeeDeviceFactory {
+	public static async create(
+		isy: ISY,
+		nodeInfo: NodeInfo<Family.ZigBee>
+	): Promise<ISYDevice<Family.ZigBee, any, any, any>> {
+		let clusterInfo = await isy.sendRequest(`zmatter/zigbee/dh/node/${nodeInfo.address}/cluster/0`, {
+			trailingSlash: false,
+		});
+		if (clusterInfo) {
+			if (isy.isDebugEnabled) {
+				await writeDebugFile(clusterInfo, `${nodeInfo.address}_ClusterData.txt`, isy.logger, isy.storagePath);
+			}
+
+			let cd = parseZigbeeClusterData(clusterInfo);
+			//@ts-expect-error
+			let cc = cd['COLOR_CONTROL'] as ZigBeeClusterData<ColorControl.Cluster>;
+			//@ts-expect-error
+			let lc = cd['LEVEL_CONTROL'] as ZigBeeClusterData<LevelControl.Cluster>;
+			//@ts-expect-error
+			let os = cd['ON_OFF_SWITCH'] as ZigBeeClusterData<OnOff.Cluster>;
+			if (cc) {
+				if (hasBitFlag(cc.data.colorCapabilities, ColorControl.ColorCapabilities.xy)) {
+					return new ExtendedColorLight(isy, nodeInfo, cd);
+				} else if (hasBitFlag(cc.data.colorCapabilities, ColorControl.ColorCapabilities.colorTemperature)) {
+					return new ColorTemperatureLight(isy, nodeInfo);
+				}
+			} else if (lc && os) return new DimmableLight(isy, nodeInfo);
+			else if (os) return new OnOffLight(isy, nodeInfo);
+		}
+	}
+
+	// public static buildDeviceMap() {
+
+	// 	var fams = new Map<Family, FamilyDef<Family>>();
+	// 	s.forEach((item) => {
+	// 		var id = item.id as Family;
+	// 		fams.set(id, { id: item.id, description: item.description, name: item.name, categories: new Map<string, CategoryDef<typeof id>>() });
+	// 		var famDef = fams[id] as FamilyDef<Family>;
+	// 		item.categories.forEach((element) => {
+	// 			var catDef = { id: element.id, name: element.name, devices: new Map<string, DeviceDef<Family>> };
+	// 			element.devices.forEach(
+	// 				device => {
+	// 					const r = this.getDeviceDetails({
+	// 						family: item.id,
+	// 						type: `${element.id}.${device.id}.0.0`,
+	// 						address: '0 0 0 1',
+	// 						nodeDefId: '',
+	// 						enabled: undefined,
+	// 						pnode: undefined,
+	// 						name: '',
+	// 						startDelay: 0,
+	// 						hint: '',
+	// 						endDelay: 0,
+	// 						wattage: 0,
+	// 						dcPeriod: 0
+	// 					});
+	// 					if (!r.unsupported) {
+	// 						device.name = r.name;
+	// 						device.modelNumber = r.modelNumber;
+	// 						device.class = r.class.name;
+	// 					}
+	// 					catDef.devices.set(`${device.id}`, { id: device.id, modelNumber: device.modelNumber, name: device.name, class: r.class });
+	// 				}
+
+	// 			);
+	// 			famDef.categories.set(element.name, catDef);
+	// 			element.devices = element.devices.sort((a, b) => a.id - b.id);
+	// 		});
+	// 	}
+
+	// 	);
+	// 	writeFileSync("DeviceMapClean.json", JSON.stringify(fams));
+	// }
+}

package/src/Devices/ZigBee/ZigbeeClusterData.ts

@@ -0,0 +1,31 @@
+import { BitFlag, type ClusterType, type TlvSchema, type TypeFromPartialBitSchema } from '@matter/types';
+import type { SnakeCase } from 'type-fest';
+
+export interface ZigBeeClusterData<C extends ClusterType> {
+	clusterId: C['id'];
+	clusterName: Uppercase<SnakeCase<C['name']>>;
+	endpoint: number;
+	data: {
+		[x in keyof C['attributes']]: C['attributes'][x]['schema'] extends TlvSchema<infer R> ? R : any;
+	};
+}
+
+export type ZigBeeClusterDataMap = {
+	[x: string]: ZigBeeClusterData<ClusterType>;
+};
+
+export function hasBitFlag(
+	value: TypeFromPartialBitSchema<{
+		[flag: string]: BitFlag;
+		[flag: number]: BitFlag;
+		[flag: symbol]: BitFlag;
+	}>,
+	flag: BitFlag
+): boolean {
+	if (typeof value !== 'number' && typeof value !== 'bigint') return value[flag.offset];
+	else {
+		let val = Math.pow(2, flag.offset);
+
+		return (value & val) == val;
+	}
+}

package/src/Devices/ZigBee/index.ts

@@ -1,13 +1,8 @@
-import { Family as FamilyEnum } from '../../Definitions/index.js';
-import type { ISY } from '../../ISY.js';
-import { ISYNode } from '../../ISYNode.js';
-import type { NodeInfo } from '../../Model/NodeInfo.js';
-import { NodeFactory } from '../NodeFactory.js';
+export { ZigBeeBase as Base } from './ZigBeeBase.js';
 
+export * from './Generated/index.js';
 
-export { ZigBeeBaseDevice as Base } from './ZigBeeBase.js';
-
-
-
-
-//export * from './Generated/index.js';
+export { ColorTemperatureLight } from './ColorTemperatureLight.js';
+export { DimmableLight } from './DimmableLight.js';
+export { ExtendedColorLight } from './ExtendedColorLight.js';
+export { OnOffLight } from './OnOffLight.js';

package/src/Devices/ZigBeeLegacy/Generated/Relay.ts

@@ -1,97 +1,126 @@
 /* THIS FILE WAS AUTOMATICALLY GENERATED. DO NOT EDIT DIRECTLY. */
 
-import { UnitOfMeasure } from "../../../Definitions/Global/UOM.js";
-import { Family } from "../../../Definitions/Global/Families.js";
+import { Family, UnitOfMeasure } from "../../../Definitions/Global/index.js";
 import type { NodeInfo } from "../../../Model/NodeInfo.js";
 import { ISY } from "../../../ISY.js";
-import type { ISYNode } from "../../../ISYNode.js";
-import { Base } from "../index.js";
+import { ISYNode } from "../../../ISYNode.js";
 import { ISYDeviceNode } from "../../ISYDeviceNode.js";
+import { Base } from "../index.js";
 import { Driver } from "../../../Definitions/Global/Drivers.js";
 import { ZigBeeLegacy } from "../../../Definitions/index.js";
-import type { DriverState } from "../../../Model/DriverState.js";
 import { NodeFactory } from "../../NodeFactory.js";
 
-const nodeDefId = "RelayLoadControl";
-
-type Commands = Relay.Commands;
-type Drivers = Relay.Drivers;
+type Commands = Relay.Commands.Type;
+type Drivers = Relay.Drivers.Type;
+type Events = Relay.Events.Type;
 
-class RelayNode extends Base<Drivers, Commands> implements Relay.Interface {
+export class Relay extends Base<Drivers, Commands, Events> implements Relay.Interface {
 	public override readonly commands = {
 		DON: this.on,
 		DOF: this.off,
 		QUERY: this.query,
 		ADRPST: this.adr
 	};
+	public readonly events: Events = {
+		DON: { label: "On", name: "on" },
+		DOF: { label: "Off", name: "off" }
+	};
 	static override nodeDefId = "RelayLoadControl";
 	static override implements = ['RelayLoadControl'];
 	declare readonly nodeDefId: 'RelayLoadControl';
-	constructor (isy: ISY, nodeInfo: NodeInfo) {
+	constructor (isy: ISY, nodeInfo: NodeInfo<Family.ZigBeeLegacy>) {
 		super(isy, nodeInfo);
-		this.drivers.ST = Driver.create("ST", this, nodeInfo.state['ST'], { uom: UnitOfMeasure.Unknown, label: "Status", name: "status" });
-		this.drivers.ERR = Driver.create("ERR", this, nodeInfo.state['ERR'], { uom: UnitOfMeasure.Unknown, label: "Responding", name: "responding" });
+		this.drivers.ST = Driver.create("ST", this, nodeInfo.state['ST'], { uom: UnitOfMeasure.Percent, label: "Status", name: "status" });
+		this.drivers.ERR = Driver.create("ERR", this, nodeInfo.state['ERR'], { uom: UnitOfMeasure.Index, label: "Responding", name: "responding" });
 	}
 	async on() { return this.sendCommand("DON"); }
 	async off() { return this.sendCommand("DOF"); }
 	async query() { return this.sendCommand("QUERY"); }
-	async adr(value: ) { return this.sendCommand("ADRPST", value); }
-	public get status(): {
-        
-return this.drivers.ST?.value;
-    }
-    public 
-get responding(): 
-{
-	return this.drivers.ERR?.value;
-}
+	async adr(value: (0 | 1)) { return this.sendCommand("ADRPST", [value, UnitOfMeasure.Index]); }
+	public get status(): (0 | 100) {
+		return this.drivers.ST?.value;
+	}
+	public get responding(): ZigBeeLegacy.Error {
+		return this.drivers.ERR?.value;
+	}
 }
 
-NodeFactory.register(RelayNode);
+NodeFactory.register(Relay);
 
 export namespace Relay {
-	export interface Interface extends Omit<InstanceType<typeof RelayNode>, keyof ISYDeviceNode<any, any, any, any>> {
+	export interface Interface extends Omit<InstanceType<typeof Relay>, keyof ISYDeviceNode<any, any, any, any>> {
 	}
-	export function is(node: ISYNode<any, any, any, any>): node is RelayNode {
+	export function is(node: ISYNode<any, any, any, any>): node is Relay {
 		return ['RelayLoadControl'].includes(node.nodeDefId);
 	}
-	export function isImplementedBy(node: ISYNode<any, any, any, any>): node is RelayNode {
+	export function isImplementedBy(node: ISYNode<any, any, any, any>): node is Relay {
 		return ['RelayLoadControl'].includes(node.nodeDefId);
 	}
-	export function create(isy: ISY, nodeInfo: NodeInfo) {
-		return new RelayNode(isy, nodeInfo);
+	export function create(isy: ISY, nodeInfo: NodeInfo<Family.ZigBeeLegacy>) {
+		return new Relay(isy, nodeInfo);
 	}
-	export const Node = RelayNode;
-	export type Commands = {
-		DON: (() => Promise<boolean>) & {
-			label: "On";
-			name: "on";
-		};
-		DOF: (() => Promise<boolean>) & {
-			label: "Off";
-			name: "off";
-		};
-		QUERY: (() => Promise<boolean>) & {
-			label: "Query";
-			name: "query";
+	export const Node = Relay;
+	export const Class = Relay;
+	export namespace Commands {
+		export type Type = {
+			DON: (() => Promise<boolean>) & {
+				label: "On";
+				name: "on";
+			};
+			DOF: (() => Promise<boolean>) & {
+				label: "Off";
+				name: "off";
+			};
+			QUERY: (() => Promise<boolean>) & {
+				label: "Query";
+				name: "query";
+			};
+			ADRPST: ((value: (0 | 1)) => Promise<boolean>) & {
+				label: "ADR";
+				name: "adr";
+			};
 		};
-		ADRPST: ((value: ) => Promise<boolean>) & {
-			label: "ADR";
-			name: "adr";
-		};
-	};
-	export type Drivers = {
-		ST: {
-			uom: ;
-			value: ;
-			label: "Status";
-			name: "status";
+	}
+	export enum Commands {
+		on = 'DON',
+		off = 'DOF',
+		query = 'QUERY',
+		adr = 'ADRPST'
+	}
+	export namespace Drivers {
+		export type Type = {
+			ST: {
+				uom: UnitOfMeasure.Percent;
+				value: (0 | 100);
+				label: "Status";
+				name: "status";
+			};
+			ERR: {
+				uom: UnitOfMeasure.Index;
+				value: ZigBeeLegacy.Error;
+				label: "Responding";
+				name: "responding";
+			};
 		};
-		ERR: {
-			uom: ;
-			value: ;
-			label: "Responding";
-			name: "responding";
+	}
+	export enum Drivers {
+		status = 'ST',
+		responding = 'ERR'
+	}
+	export namespace Events {
+		export type Type = {
+			DON: {
+				label: "On";
+				name: "on";
+			};
+			DOF: {
+				label: "Off";
+				name: "off";
+			};
 		};
-	};
+	}
+	export enum Events {
+		on = 'DON',
+		off = 'DOF'
+	}
 }