isy-nodejs 1.0.7-alpha.0 → 1.0.8-alpha.0

package/src/Registry.ts

@@ -0,0 +1,112 @@
+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 { ISYNode } from './ISYNode.js';
+import type { StringKeys } from './Utils.js';
+
+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 } } = {};
+
+
+	registerGlobal(key: K, value: T): void {
+		this.Global[key] = value;
+	}
+
+	registerFamilyLevel<F extends Family>(family: F & number, key: K, value: T): void {
+		this.FamilyLevel[Family[family] as string] = this.FamilyLevel[Family[family] as string] ?? {};
+		this.FamilyLevel[Family[family] as string]![key] = value;
+	}
+
+	registerDeviceLevel(device: string, key: K, value: T): void {
+		this.DeviceLevel[device] = this.DeviceLevel[device] ?? {};
+		this.DeviceLevel[device]![key] = value;
+	}
+
+	registerNodeLevel(nodeDefId: string, key: K, value: T): void {
+		this.NodeLevel[nodeDefId] = this.NodeLevel[nodeDefId] ?? {};
+		this.NodeLevel[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)
+		{
+			this.registerGlobal(key, value);
+			return;
+		}
+		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);
+			}
+			this.registerFamilyLevel(discriminant.family, key, value);
+			return;
+		}
+
+	}
+
+	getGlobal(key: K): T | undefined {
+		return this.Global[key];
+	}
+
+	getFamilyLevel<F extends Family>(family: F & number, key: K): T | undefined {
+		return this.FamilyLevel[Family[family] as string]?.[key];
+	}
+
+	getDeviceLevel(device: string, key: K): T | undefined {
+		return this.DeviceLevel[device]?.[key];
+	}
+
+	getNodeLevel(nodeDefId: string, key: K): T | undefined {
+		 return this.NodeLevel[nodeDefId]?.[key];
+	}
+
+	get(device: ISYDeviceInfo & ISYNode, key: K): T | undefined
+	{
+		if(device.type)
+		{
+			let d = this.getDeviceLevel(device.type, key);
+			if(d)
+				return d;
+		}
+
+			let d = this.getNodeLevel(device.nodeDefId, key);
+			if(d)
+			{
+				return d;
+			}
+			else
+			{
+				for (const nodeDefId in NodeFactory.getImplements(device))
+				{
+					let d = this.getNodeLevel(nodeDefId, key);
+					if(d)
+						return d;
+				}
+			}
+		let f = this.getFamilyLevel(device.family, key);
+		if(f)
+			return f;
+		return this.getGlobal(key);
+
+	}
+
+
+
+}

package/src/Utils.ts

@@ -12,6 +12,35 @@ import { readFile } from 'fs/promises';
 import path from 'path';
 import { Family } from './Definitions/index.js';
 import { EventType } from './Events/EventType.js';
+import type { Constructor } from 'type-fest';
+
+
+export type Factory<T extends object> =
+	{
+		create?: (...args: any[]) => T;
+		is?<K extends T>(obj: object): obj is T;
+		isImplementedBy?(obj: object): obj is T;
+
+
+	} & {Node: Constructor<T>} | {Device: Constructor<T>};
+
+export function isFactory(obj: any): obj is Factory<any> {
+	return obj.Node !== undefined || obj.Device !== undefined;
+}
+
+export function getConstructor<T extends object>(obj: Factory<T> | Constructor<T>): Constructor<T> {
+	if(isFactory(obj)) {
+		if('Node' in obj) {
+			return obj.Node;
+		}
+		return obj.Device;
+	}
+	return obj;
+}
+
+
+export type ConstructorOf<T> = T extends Factory<infer U>  ? Constructor<U> : T extends Constructor<infer U> ? U : Constructor<T> ;
+
 
 export type StringKeys<T> = Extract<keyof T, string>;
 

package/src/Devices/Insteon/DimmerLampSwitch.ts

@@ -1,207 +0,0 @@
-/* THIS FILE WAS AUTOMATICALLY GENERATED. DO NOT EDIT DIRECTLY. */
-
-import { Driver } from '../../Definitions/Global/Drivers.js';
-import { Family } from '../../Definitions/Global/Families.js';
-import { UnitOfMeasure } from '../../Definitions/Global/UOM.js';
-import { Insteon } from '../../Definitions/index.js';
-import type { ISY } from '../../ISY.js';
-import type { ISYNode } from '../../ISYNode.js';
-import type { DriverState } from '../../Model/DriverState.js';
-import type { NodeInfo } from '../../Model/NodeInfo.js';
-import { ISYDeviceNode } from '../ISYDeviceNode.js';
-import { NodeFactory } from '../NodeFactory.js';
-import { InsteonBaseDevice as Base } from './InsteonBaseDevice.js';
-
-export const nodeDefId = 'DimmerLampSwitch';
-
-type Commands = DimmerLampSwitch.Commands;
-type Drivers = DimmerLampSwitch.Drivers;
-
-export class DimmerLampSwitchNode extends Base<Drivers, Commands> implements DimmerLampSwitch.Interface {
-	public override readonly commands = {
-		DON: this.on,
-		DOF: this.off,
-		DFOF: this.fastOff,
-		DFON: this.fastOn,
-		BRT: this.brighten,
-		DIM: this.dim,
-		FDUP: this.fadeUp,
-		FDDOWN: this.fadeDown,
-		FDSTOP: this.fadeStop,
-		QUERY: this.query,
-		BEEP: this.beep,
-		OL: this.updateOnLevel,
-		RR: this.updateRampRate,
-		BL: this.backlight,
-		WDU: this.writeChanges
-	};
-	static override nodeDefId = 'DimmerLampSwitch';
-	declare readonly nodeDefId: 'DimmerLampSwitch';
-	constructor(isy: ISY, nodeInfo: NodeInfo) {
-		super(isy, nodeInfo);
-		this.drivers.ST = Driver.create('ST', this, nodeInfo.state['ST'], { uom: UnitOfMeasure.LevelFrom0To255, label: 'Status', name: 'status' });
-		this.drivers.OL = Driver.create('OL', this, nodeInfo.state['OL'] as DriverState, { uom: UnitOfMeasure.Percent, label: 'On Level', name: 'onLevel' });
-		this.drivers.RR = Driver.create('RR', this, nodeInfo.state['RR'] as DriverState, { uom: UnitOfMeasure.Index, label: 'Ramp Rate', name: 'rampRate' });
-		this.drivers.ERR = Driver.create('ERR', this, nodeInfo.state['ERR'] as DriverState, { uom: UnitOfMeasure.Index, label: 'Responding', name: 'responding' });
-	}
-	async on(value?: number) {
-		return this.sendCommand('DON', value);
-	}
-	async off() {
-		return this.sendCommand('DOF');
-	}
-	async fastOff() {
-		return this.sendCommand('DFOF');
-	}
-	async fastOn() {
-		return this.sendCommand('DFON');
-	}
-	async brighten() {
-		return this.sendCommand('BRT');
-	}
-	async dim() {
-		return this.sendCommand('DIM');
-	}
-	async fadeUp() {
-		return this.sendCommand('FDUP');
-	}
-	async fadeDown() {
-		return this.sendCommand('FDDOWN');
-	}
-	async fadeStop() {
-		return this.sendCommand('FDSTOP');
-	}
-	async query() {
-		return this.sendCommand('QUERY');
-	}
-	async beep(value?: number) {
-		return this.sendCommand('BEEP', { value: value });
-	}
-	async updateOnLevel(value: number) {
-		return this.sendCommand('OL', { value: value });
-	}
-	async updateRampRate(value: number) {
-		return this.sendCommand('RR', { value: value });
-	}
-	async backlight(value: number) {
-		return this.sendCommand('BL', { value: value });
-	}
-	async writeChanges() {
-		return this.sendCommand('WDU');
-	}
-	public get status(): number {
-		return this.drivers.ST?.value;
-	}
-	public get onLevel(): number {
-		return this.drivers.OL?.value;
-	}
-	public get rampRate(): number {
-		return this.drivers.RR?.value;
-	}
-	public get responding(): Insteon.Error {
-		return this.drivers.ERR?.value;
-	}
-}
-
-NodeFactory.register(DimmerLampSwitchNode);
-
-export namespace DimmerLampSwitch {
-	export interface Interface extends Omit<InstanceType<typeof DimmerLampSwitchNode>, keyof ISYDeviceNode<any, any, any, any>> {
-		nodeDefId: 'DimmerLampSwitch';
-	}
-	export function is(node: ISYNode<any, any, any, any>): node is DimmerLampSwitchNode {
-		return node.nodeDefId === nodeDefId;
-	}
-	export function create(isy: ISY, nodeInfo: NodeInfo) {
-		return new DimmerLampSwitchNode(isy, nodeInfo);
-	}
-	export const Node = DimmerLampSwitchNode;
-	export type Commands = {
-		DON: ((value?: number) => Promise<boolean>) & {
-			label: 'On';
-			name: 'on';
-		};
-		DOF: (() => Promise<boolean>) & {
-			label: 'Off';
-			name: 'off';
-		};
-		DFOF: (() => Promise<boolean>) & {
-			label: 'Fast Off';
-			name: 'fastOff';
-		};
-		DFON: (() => Promise<boolean>) & {
-			label: 'Fast On';
-			name: 'fastOn';
-		};
-		BRT: (() => Promise<boolean>) & {
-			label: 'Brighten';
-			name: 'brighten';
-		};
-		DIM: (() => Promise<boolean>) & {
-			label: 'Dim';
-			name: 'dim';
-		};
-		FDUP: (() => Promise<boolean>) & {
-			label: 'Fade Up';
-			name: 'fadeUp';
-		};
-		FDDOWN: (() => Promise<boolean>) & {
-			label: 'Fade Down';
-			name: 'fadeDown';
-		};
-		FDSTOP: (() => Promise<boolean>) & {
-			label: 'Fade Stop';
-			name: 'fadeStop';
-		};
-		QUERY: (() => Promise<boolean>) & {
-			label: 'Query';
-			name: 'query';
-		};
-		BEEP: ((value?: number) => Promise<boolean>) & {
-			label: 'Beep';
-			name: 'beep';
-		};
-		OL: ((value: number) => Promise<boolean>) & {
-			label: 'On Level';
-			name: 'updateOnLevel';
-		};
-		RR: ((value: number) => Promise<boolean>) & {
-			label: 'Ramp Rate';
-			name: 'updateRampRate';
-		};
-		BL: ((value: number) => Promise<boolean>) & {
-			label: 'Backlight';
-			name: 'backlight';
-		};
-		WDU: (() => Promise<boolean>) & {
-			label: 'Write Changes';
-			name: 'writeChanges';
-		};
-	};
-	export type Drivers = {
-		ST: {
-			uom: UnitOfMeasure.LevelFrom0To255;
-			value: number;
-			label: 'Status';
-			name: 'status';
-		};
-		OL: {
-			uom: UnitOfMeasure.Percent;
-			value: number;
-			label: 'On Level';
-			name: 'onLevel';
-		};
-		RR: {
-			uom: UnitOfMeasure.Index;
-			value: number;
-			label: 'Ramp Rate';
-			name: 'rampRate';
-		};
-		ERR: {
-			uom: UnitOfMeasure.Index;
-			value: Insteon.Error;
-			label: 'Responding';
-			name: 'responding';
-		};
-	};
-}

package/src/Devices/Insteon/InsteonRelaySwitchDevice.ts

@@ -1,11 +0,0 @@
-import type { NodeInfo } from '../../Model/NodeInfo.js';
-import type { ISY } from '../../ISY.js';
-
-import { InsteonRelayDevice } from './InsteonRelayDevice.js';
-import 'winston';
-
-export class InsteonRelaySwitchDevice extends InsteonRelayDevice {
-	constructor (isy: ISY, deviceNode: NodeInfo ) {
-		super(isy, deviceNode);
-	}
-}

package/src/Devices/Insteon/RelayLampSwitch.ts

@@ -1,132 +0,0 @@
-/* THIS FILE WAS AUTOMATICALLY GENERATED. DO NOT EDIT DIRECTLY. */
-
-import { Driver } from '../../Definitions/Global/Drivers.js';
-import { Command } from '../../Definitions/index.js';
-import { Family } from '../../Definitions/Global/Families.js';
-import { UnitOfMeasure } from '../../Definitions/Global/UOM.js';
-import { Insteon } from '../../Definitions/index.js';
-import type { ISY } from '../../ISY.js';
-import type { ISYNode } from '../../ISYNode.js';
-import type { DriverState } from '../../Model/DriverState.js';
-import type { NodeInfo } from '../../Model/NodeInfo.js';
-import { ISYDeviceNode } from '../ISYDeviceNode.js';
-import { NodeFactory } from '../NodeFactory.js';
-import { InsteonBaseDevice } from './InsteonBaseDevice.js';
-
-export const nodeDefId = 'RelayLampSwitch';
-
-type Commands = RelayLampSwitch.Commands;
-type Drivers = RelayLampSwitch.Drivers;
-
-export class RelayLampSwitchNode extends InsteonBaseDevice<Drivers, Commands> implements RelayLampSwitch.Interface {
-	public override readonly commands = {
-		DON: this.on,
-		DOF: this.off,
-		DFOF: this.fastOff,
-		DFON: this.fastOn,
-		QUERY: this.query,
-		BEEP: this.beep,
-		BL: this.backlight,
-		WDU: this.writeChanges
-	};
-	static override nodeDefId = 'RelayLampSwitch';
-	declare readonly nodeDefId: 'RelayLampSwitch';
-	constructor(isy: ISY, nodeInfo: NodeInfo) {
-		super(isy, nodeInfo);
-		this.drivers.ST = Driver.create('ST', this, nodeInfo.state['ST'], { uom: UnitOfMeasure.Boolean, label: 'Status', name: 'status' });
-		this.drivers.ERR = Driver.create('ERR', this, nodeInfo.state['ERR'], { uom: UnitOfMeasure.Index, label: 'Responding', name: 'responding' });
-	}
-	async on(value?: 0 | 100) {
-		return this.sendCommand('DOF');
-	}
-	async off() {
-		return this.sendCommand('DOF');
-	}
-	async fastOff() {
-		return this.sendCommand('DFOF');
-	}
-	async fastOn() {
-		return this.sendCommand('DFON');
-	}
-	async query() {
-		return this.sendCommand('QUERY');
-	}
-	async beep(value?: number) {
-		return this.sendCommand('BEEP', { value: value });
-	}
-	async backlight(value: number) {
-		return this.sendCommand('BL', { value: value });
-	}
-	async writeChanges() {
-		return this.sendCommand('WDU');
-	}
-	public get status(): boolean {
-		return this.drivers.ST?.value;
-	}
-	public get responding(): Insteon.Error {
-		return this.drivers.ERR?.value;
-	}
-}
-
-NodeFactory.register(RelayLampSwitchNode);
-
-export namespace RelayLampSwitch {
-	export interface Interface extends Omit<InstanceType<typeof RelayLampSwitchNode>, keyof ISYDeviceNode<any, any, any, any>> {
-		nodeDefId: 'RelayLampSwitch';
-	}
-	export function is(node: ISYNode<any, any, any, any>): node is RelayLampSwitchNode {
-		return node.nodeDefId === nodeDefId;
-	}
-	export function create(isy: ISY, nodeInfo: NodeInfo) {
-		return new RelayLampSwitchNode(isy, nodeInfo);
-	}
-	export const Node = RelayLampSwitchNode;
-	export type Commands = {
-		DON: ((value?: 0 | 100) => Promise<boolean>) & {
-			label: 'On';
-			name: 'on';
-		};
-		DOF: (() => Promise<boolean>) & {
-			label: 'Off';
-			name: 'off';
-		};
-		DFOF: (() => Promise<boolean>) & {
-			label: 'Fast Off';
-			name: 'fastOff';
-		};
-		DFON: (() => Promise<boolean>) & {
-			label: 'Fast On';
-			name: 'fastOn';
-		};
-		QUERY: (() => Promise<boolean>) & {
-			label: 'Query';
-			name: 'query';
-		};
-		BEEP: ((value?: number) => Promise<boolean>) & {
-			label: 'Beep';
-			name: 'beep';
-		};
-		BL: ((value: number) => Promise<boolean>) & {
-			label: 'Backlight';
-			name: 'backlight';
-		};
-		WDU: (() => Promise<boolean>) & {
-			label: 'Write Changes';
-			name: 'writeChanges';
-		};
-	};
-	export type Drivers = {
-		ST: {
-			uom: UnitOfMeasure.Boolean;
-			value: boolean;
-			label: 'Status';
-			name: 'status';
-		};
-		ERR: {
-			uom: UnitOfMeasure.Index;
-			value: Insteon.Error;
-			label: 'Responding';
-			name: 'responding';
-		};
-	};
-}

package/src/Matter/Behaviors/Insteon/ISYOnOffBehavior.ts

@@ -1,66 +0,0 @@
-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 { ClusterForBehavior, ISYClusterBehavior, type PropertyChange } from '../ISYClusterBehavior.js';
-
-import { Converter } from '../../../Converters.js';
-import { BehaviorRegistry } from '../BehaviorRegistry.js';
-import type { ClusterBehavior } from '@matter/node';
-
-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 });
-	}
-}
-
-BehaviorRegistry.register(ISYOnOffBehavior);
-
-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();
-		}
-
-	}
-}
-
-BehaviorRegistry.register(ISYDimmableBehavior);