isy-nodejs 1.0.8-alpha.0 → 1.3.24

package/src/Definitions/Global/Commands.ts

@@ -28,39 +28,58 @@ export interface Parameter<P, T> {
 	driver: string;
 }
 
-
-
 type ParameterCollection = { [K: string]: Parameter<typeof K, any> };
 
-
 function isParameterCollection(value: any): value is ParameterCollection {
 	return value !== undefined && value.name === undefined;
 }
 
-export type Command<C extends string, N = C, L = N, P extends { [K: string]: Parameter<typeof K, any> } | Parameter<string,any> = null> =
-	P extends null ? { id: C; label: L; name: N }
-	: P extends Parameter<string,any> ? {id: C; label: L; name: N; uom: P['uom']; serverUom?: P['serverUom']; converter?: (value: P['value']) => P['value']; driver: P['driver']} : P extends ParameterCollection ?
-	 {
-			// #region Properties (8)
+export type Command<
+	C extends string,
+	N = C,
+	L = N,
+	P extends { [K: string]: Parameter<typeof K, any> } | Parameter<string, any> = null,
+> = P extends null
+	? { id: C; label: L; name: N }
+	: P extends Parameter<string, any>
+		? {
+				id: C;
+				label: L;
+				name: N;
+				uom: P['uom'];
+				serverUom?: P['serverUom'];
+				converter?: (value: P['value']) => P['value'];
+				driver: P['driver'];
+			}
+		: P extends ParameterCollection
+			? {
+					// #region Properties (8)
 
-			(params: { [x in keyof P]: P[x]["value"] }): Promise<boolean>;
-			id: C;
-			label: L;
-			name: N;
-			parameters: P;
+					(params: { [x in keyof P]: P[x]['value'] }): Promise<boolean>;
+					id: C;
+					label: L;
+					name: N;
+					parameters: P;
 
-			// #endregion Properties (8)
+					// #endregion Properties (8)
 
-			// #region Public Methods (2)
+					// #region Public Methods (2)
 
-			// #endregion Public Methods (2)
-			//override on('change', listener: (value: any) => void): this;
-		} : never;
+					// #endregion Public Methods (2)
+					//override on('change', listener: (value: any) => void): this;
+				}
+			: never;
 
 export namespace Command {
-	export type Signature<F extends { name } = CallableFunction, L extends string = string, N extends string = string> = F & { label: L; name: N };
-
-	export type Signatures<C extends string> = { [K in C]: Signature<(...args: any[]) => Promise<Boolean>, string, string> };
+	export type Signature<
+		F extends { name } = CallableFunction,
+		L extends string = string,
+		N extends string = string,
+	> = F & { label: L; name: N };
+
+	export type Signatures<C extends string> = {
+		[K in C]: Signature<(...args: any[]) => Promise<Boolean>, string, string>;
+	};
 
 	export type NoExtraKeys<U> = U extends infer F ? F : never;
 
@@ -79,17 +98,15 @@ export namespace Command {
 		[K in keyof T]: For<T[K]['name'], T[K]['label'], T[K]>;
 	};
 
-
-
-	function getCommandFunctionSignature<P extends { [x: string]: Parameter<string, any> } | Parameter<string, any> | null> (command: string, node: ISYNode<any,any,any,any>,parameters?: P): Function {
+	function getCommandFunctionSignature<
+		P extends { [x: string]: Parameter<string, any> } | Parameter<string, any> | null,
+	>(command: string, node: ISYNode<any, any, any, any>, parameters?: P): Function {
 		if (!parameters) {
-			return  () => {
+			return () => {
 				return node.sendCommand(command);
 			};
-		}
-
-		else if (isParameterCollection(parameters)) {
-			let cmd : any = (params: { [x in keyof P]: typeof parameters[x]['value'] }) => {
+		} else if (isParameterCollection(parameters)) {
+			let cmd: any = (params: { [x in keyof P]: (typeof parameters)[x]['value'] }) => {
 				for (let key in params) {
 					let p = parameters[key];
 					if (p.converter) {
@@ -103,24 +120,21 @@ export namespace Command {
 				let p = parameters[key];
 
 				let srvUom = node.drivers[p.driver]?.serverUom;
-				if (srvUom)
-				{
-					if(srvUom !== p.uom) {
+				if (srvUom) {
+					if (srvUom !== p.uom) {
 						cmd.parameters[key].converter = Converter.get(p.uom, srvUom).to;
 						cmd.parameters[key].serverUom = srvUom;
 					}
 				}
-
 			}
 			return cmd;
-		}
-		else if(parameters.name) {
+		} else if (parameters.name) {
 			let cmd = function (value): Promise<boolean> {
-				if(parameters.converter) {
+				if (parameters.converter) {
 					value = parameters.converter(value);
 				}
 				return node.sendCommand(command, { value: value });
-			} as any
+			} as any;
 			let srvUom = node.drivers[parameters.driver]?.serverUom;
 			if (srvUom) {
 				cmd.serverUom = srvUom;
@@ -129,25 +143,21 @@ export namespace Command {
 			cmd.uom = parameters.uom;
 			return cmd;
 		}
-
 	}
 
 	export function create<
 		C extends string,
 		N = string,
 		L = string,
-		P extends ParameterCollection | Parameter<any,any> | null = null
+		P extends ParameterCollection | Parameter<any, any> | null = null,
 	>(command: C, node: ISYNode<any, any, any, any>, label: L, name: N, parameters: P = null): Command<C, N, L, P> {
-
-		let cmd: Command<C, N, L, P> =
-		getCommandFunctionSignature(command, node, parameters) as Command<C, N, L, P>;
+		let cmd: Command<C, N, L, P> = getCommandFunctionSignature(command, node, parameters) as Command<C, N, L, P>;
 		cmd.label = label;
 		cmd.name = name;
 		cmd.id = command;
 		return cmd;
 	}
 
-
 	type Commands = {
 		BEEP: ((value: number) => Promise<boolean>) & { label: 'Beep'; name: 'beep' };
 		BL: ((value: number) => Promise<boolean>) & { label: 'Backlight'; name: 'backlight' };

package/src/Definitions/Global/Drivers.ts

@@ -11,7 +11,7 @@ import type { DriverState } from '../../Model/DriverState.js';
 import type { StringKeys } from '../../Utils.js';
 import type { Family } from './Families.js';
 
-export enum DriverType {
+export enum StandardDrivers {
 	AccelerationXAxis = 'ACCX',
 	AccelerationYAxis = 'ACCY',
 	AccelerationZAxis = 'ACCZ',
@@ -167,63 +167,52 @@ export enum DriverType {
 	WindChill = 'WINDCH',
 	WindDirection = 'WINDDIR',
 	BoilerWaterTemperature = 'WATERTB',
-	OutsideTemperature = 'TEMPOUT'
+	OutsideTemperature = 'TEMPOUT',
 }
 
-type a = keyof typeof DriverType;
+type a = keyof typeof StandardDrivers;
 
 type EnumFromLabel<L extends keyof N, N> = N[L];
 
-type DriverTypeFromName<N extends keyof typeof DriverType> = EnumFromLabel<N, typeof DriverType>;
-type x = DriverTypeFromName<'Status' | 'SoilTemperature'>;
+type DriverTypeFromName<N extends keyof typeof StandardDrivers> = EnumFromLabel<N, typeof StandardDrivers>;
 
 //export type DriverLabel<T extends DriverType> = ReturnType>LabelMap.get>
 
-export type EnumLiteral<T> =
-	T extends string ? `${T}`
-	: T extends boolean ?
-		T extends true ?
-			true
-		:	false
-	:	T;
+export type EnumLiteral<T> = T extends string ? `${T}` : T extends boolean ? (T extends true ? true : false) : T;
 
-type y = EnumLiteral<DriverType.Status>;
+type y = EnumLiteral<StandardDrivers.Status>;
 
-type z = EnumLiteral<DriverType.Status | DriverType.Precipitation>;
+type z = EnumLiteral<StandardDrivers.Status | StandardDrivers.Precipitation>;
 
-type T = DriverTypeFromName<keyof typeof DriverType>;
+type T = DriverTypeFromName<keyof typeof StandardDrivers>;
 
 //type Driver<D extends DriverType> = D extends D[0] | infer K extends DriverType ? D[0] | DriverLabels<K> : never;
 
 type s = EnumLiteral<{ 100: true; 200: false }>;
 
-export type DriverList<D> =
-	D extends DriverType ? { [K in D]?: Driver<K, any, any> } & { add(driver: Driver<D, any, any>): void }
-	: D extends EnumLiteral<infer R extends DriverType> ? { [K in R]?: Driver<R, any, any> } & { add(driver: Driver<R, any, any>): void }
-	: {}; //& { [N in keyof typeof DriverType]?: Driver<DriverTypeFromName<N>> };
+export type DriverList<D> = D extends StandardDrivers
+	? { [K in D]?: Driver<K, any, any> } & { add(driver: Driver<D, any, any>): void }
+	: D extends EnumLiteral<infer R extends StandardDrivers>
+		? { [K in R]?: Driver<R, any, any> } & { add(driver: Driver<R, any, any>): void }
+		: {}; //& { [N in keyof typeof DriverType]?: Driver<DriverTypeFromName<N>> };
 
-type KeyOrValue<K, D> =
-	K extends D ? D
-	: K extends keyof D ? D[K]
-	: never;
+type KeyOrValue<K, D> = K extends D ? D : K extends keyof D ? D[K] : never;
 
-const LabelMap = new Map<DriverType, keyof typeof DriverType>(Object.entries(DriverType).map(([a, b]) => [b, a]) as any);
+// const LabelMap = new Map<StandardDrivers, keyof typeof StandardDrivers>(Object.entries(StandardDrivers).map(([a, b]) => [b, a]) as any);
 
 ///onst DriverNames = Object.entries(DriverType).(a)=>[a[1],a[0]]) as [DriverType,(keyof typeof DriverType)][];
-type DriverListType<D extends DriverType> = Identity<DriverList<D>>;
-
-export class Drivers<D extends DriverType> {
+/* export class Drivers<D extends StandardDrivers> {
 	// #region Properties (1)
 
 	public DriverHandler: ProxyHandler<Drivers<D>> = {
-		set(target, p: DriverType | keyof typeof DriverType, newValue, receiver) {
+		set(target, p: StandardDrivers | keyof typeof StandardDrivers, newValue, receiver) {
 			if (p in target) {
-				if (p in DriverType) {
+				if (p in StandardDrivers) {
 					target[p] = newValue;
-					target[LabelMap.get(p as DriverType)] = newValue;
+					target[LabelMap.get(p as StandardDrivers)] = newValue;
 					return true;
 				} else if (typeof p === 'string' && p in LabelMap.values()) {
-					target[DriverType[p]] = newValue;
+					target[StandardDrivers[p]] = newValue;
 					target[p] = newValue;
 					return true;
 				}
@@ -231,7 +220,7 @@ export class Drivers<D extends DriverType> {
 			}
 			return false;
 		},
-		get(target, p: DriverType | keyof typeof DriverType, receiver) {
+		get(target, p: StandardDrivers | keyof typeof StandardDrivers, receiver) {
 			if (p in target) {
 				return target[p];
 			}
@@ -257,16 +246,16 @@ export class Drivers<D extends DriverType> {
 	}
 
 	// #endregion Public Methods (1)
-}
+} */
 
 export interface Driver<
-	D extends DriverType | EnumLiteral<DriverType> | `${string}.${EnumLiteral<DriverType>}` | string,
+	D extends StringKeys<StandardDrivers> | string,
 	U extends UnitOfMeasure,
 	T = number,
 	SU extends UnitOfMeasure = U,
 	ST = T,
-	N = D,
-	L = N
+	N extends string = D,
+	L extends string = N,
 > {
 	// #region Properties (8)
 
@@ -275,6 +264,8 @@ export interface Driver<
 	id: D;
 	label: L;
 	name: N;
+
+	changedEventName: `${N}Changed`;
 	query: () => Promise<DriverState>;
 	serverUom?: SU;
 	state: {
@@ -286,7 +277,7 @@ export interface Driver<
 	};
 
 	initialized: boolean;
-		uom: U;
+	uom: U;
 
 	// #endregion Properties (8)
 
@@ -300,13 +291,13 @@ export interface Driver<
 }
 
 export interface StatelessDriver<
-	D extends DriverType | EnumLiteral<DriverType> | `${string}.${EnumLiteral<DriverType>}` | string,
+	D extends StandardDrivers | EnumLiteral<StandardDrivers> | `${string}.${EnumLiteral<StandardDrivers>}` | string,
 	U extends UnitOfMeasure,
 	T = number,
 	SU extends UnitOfMeasure = U,
 	ST = T,
 	N = D,
-	L = N
+	L = N,
 > {
 	// #region Properties (9)
 
@@ -315,6 +306,7 @@ export interface StatelessDriver<
 	id: D;
 	label: L;
 	name: N;
+
 	query: () => Promise<DriverState>;
 	serverUom?: SU;
 	state: {
@@ -339,21 +331,34 @@ export function isTrue(x: true | false): x is true {
 	return x;
 }
 
-export type DriverTypeLiteral = EnumLiteral<DriverType>;
-
 export type EnumWithLiteral<D extends string | bigint | number | boolean> = D | EnumLiteral<D>;
 export namespace Driver {
-	export type Signature<U extends UnitOfMeasure = UnitOfMeasure, V = any, SU extends UnitOfMeasure = U, N = string, L = N> = { uom: U; value: V; name: N; label: L };
+	export type Signature<
+		U extends UnitOfMeasure = UnitOfMeasure,
+		V = any,
+		SU extends UnitOfMeasure = U,
+		N extends string = string,
+		L extends string = N,
+	> = { uom: U; value: V; name: N; label: L };
+
+	export const Standard = StandardDrivers;
 
 	export type Signatures<D> = UnionToIntersection<
-		D extends string ? { [K in D]: Signature<UnitOfMeasure, any, UnitOfMeasure, K, K> }
-		: D extends { [K in keyof D]: Signature } ? D
-		: never
+		D extends string
+			? { [K in D]: Signature<UnitOfMeasure, any, UnitOfMeasure, K, K> }
+			: D extends { [K in keyof D]: Signature }
+				? D
+				: never
 	>;
 
 	///D extends (infer R extends string | infer K extends {[L in keyof K]: Signature}) ? {[J in R & string]: Signature} & K : D extends string ? { [K in D]: Signature } : D extends {[K in keyof D]: Signature} ? D : never;
 
-	type test = Signatures<DriverType.Status | { ERR: Signature; BUSY: Signature } | { ERR: Signature; BUSY: Signature } | { ERR: Signature; BUSY: Signature }>;
+	type test = Signatures<
+		| StandardDrivers.Status
+		| { ERR: Signature; BUSY: Signature }
+		| { ERR: Signature; BUSY: Signature }
+		| { ERR: Signature; BUSY: Signature }
+	>;
 
 	type Drivers = {
 		ST?: {
@@ -370,27 +375,48 @@ export namespace Driver {
 		};
 	};
 
-	export type For<D extends string, T, S extends boolean = false> = T extends Signature<infer U, infer V, infer SU, infer N, infer L> ? StatelessOrStateful<D, U, V, SU, V, N, L, S> : never;
+	export type For<D extends string, T, S extends boolean = false> =
+		T extends Signature<infer U, infer V, infer SU, infer N, infer L>
+			? StatelessOrStateful<D, U, V, SU, V, N, L, S>
+			: never;
 
 	export type ForAll<T, S extends boolean = false> = {
-		[K in StringKeys<T>]: T[K] extends Signature<UnitOfMeasure, any, UnitOfMeasure, string, string> ? For<K, T[K], S> : never;
+		[K in StringKeys<T>]: T[K] extends Signature<UnitOfMeasure, any, UnitOfMeasure, string, string>
+			? For<K, T[K], S>
+			: never;
 	};
 
 	export type SignaturesOf<D> = D extends ForAll<infer R> ? R : never;
 
 	type test2 = SignaturesOf<ForAll<Drivers>>;
 
-	export type Type = DriverType;
-	export type Literal = EnumLiteral<DriverType>;
+	export type Type = StandardDrivers;
+	export type Literal = EnumLiteral<StandardDrivers>;
 	export type LiteralWithExtensions = Literal | `${string}.${Literal}`;
-	export type LiteralWithType = EnumWithLiteral<DriverType>;
-	type StatelessOrStateful<D extends string, U extends UnitOfMeasure, T = number, SU extends UnitOfMeasure = U, ST = T, N = D, L = N, S extends boolean = false> =
-		S extends true ? StatelessDriver<D, U, T, SU, ST, N, L> : Driver<D, U, T, SU, ST, N, L>;
-
-	export function create<D extends Literal, U extends UnitOfMeasure, T = number, N extends string = string, L extends string = string, S extends boolean = false>(
+	export type LiteralWithType = EnumWithLiteral<StandardDrivers>;
+	type StatelessOrStateful<
+		D extends string,
+		U extends UnitOfMeasure,
+		T = number,
+		SU extends UnitOfMeasure = U,
+		ST = T,
+		N extends string = D,
+		L extends string = N,
+		S extends boolean = false,
+	> = S extends true ? StatelessDriver<D, U, T, SU, ST, N, L> : Driver<D, U, T, SU, ST, N, L>;
+
+	export function create<
+		D extends Literal,
+		K extends ISYNode<Family, any, any, any>,
+		U extends UnitOfMeasure,
+		T = number,
+		N extends string = string,
+		L extends string = string,
+		S extends boolean = false,
+	>(
 		driver: EnumWithLiteral<D>,
 
-		node?: ISYNode<Family, any, any, any>,
+		node?: K,
 		initState?: DriverState,
 		driverSignature?: { uom: U; label: L; name: N },
 		stateless?: S,
@@ -399,7 +425,9 @@ export namespace Driver {
 		const query = async () => {
 			return await node.readProperty(driver as D);
 		};
-
+		const name = initState?.name ?? driverSignature?.name ?? driver;
+		const label = driverSignature?.label ?? name;
+		const changedEventName = `${name}Changed`;
 		if (isTrue(stateless)) {
 			return {
 				id: driver as D,
@@ -410,94 +438,129 @@ export namespace Driver {
 					initial: true,
 					value: initState?.value, //TODO include converter
 					formattedValue: initState?.formatted,
-					pendingValue: null
+					pendingValue: null,
 				},
 				query,
 				get value() {
-					return query().then((p) => p.value) as Promise<T>;
+					return query().then(p => p.value) as Promise<T>;
 				},
 				name: initState?.name ?? driverSignature.name ?? driverSignature.label ?? driver,
-				label: driverSignature.label ?? driver
+				label: driverSignature.label ?? driver,
 			} as StatelessOrStateful<D, U, T, UnitOfMeasure, any, N, L, typeof stateless>;
 		}
+
 		var c = {
 			id: driver as D,
-			initialized: initState ? true : false,
+			initialized: initState && initState?.uom != 0 && initState?.uom != null ? true : false,
 			uom: driverSignature?.uom as U,
 			serverUom: initState?.uom != driverSignature?.uom ? initState?.uom : undefined,
+
 			state: {
 				initial: true,
-				value:
-					initState ?
-						converter ? converter.from(initState.value)
-						: driverSignature?.uom && initState?.uom != driverSignature?.uom ? Converter.convert(initState.uom, driverSignature.uom, initState.value)
-						: initState.value
-					:	null,
+				value: initState
+					? converter
+						? converter.from(initState.value)
+						: driverSignature?.uom && initState?.uom != driverSignature?.uom
+							? Converter.convert(initState.uom, driverSignature.uom, initState.value)
+							: initState.value
+					: null,
 				rawValue: initState ? initState.value : null,
 				formattedValue: initState ? initState.formatted : null,
-				pendingValue: null
+				pendingValue: null,
 			},
 			async query() {
 				let s = await query();
-				this.state.value =
-					converter ? converter.from(s.value)
-					: this.uom !== s.uom ? Converter.convert(s.value, s.uom, this.uom)
-					: s.value;
+				this.state.value = converter
+					? converter.from(s.value)
+					: this.uom !== s.uom
+						? Converter.convert(s.value, s.uom, this.uom)
+						: s.value;
 				this.state.formattedValue = s.formatted;
 				this.state.rawValue = s.value;
 				return s;
 			},
 			apply(state: DriverState, notify = true) {
+				if (state == null || state.uom == null || state.uom == 0) {
+					return false;
+				}
 				if (state.id == this.id) {
-
-					let previousValue = this.state.rawValue;
+					let previousRawValue = this.state.rawValue;
+					let previousValue = this.state.value;
 					this.state.rawValue = state.value;
-					if (previousValue === this.state.rawValue) {
+					this.state.formattedValue = state.formatted;
+					if (previousRawValue == this.state.rawValue) {
 						return false;
 					}
+
 					if (state.uom != this.uom) {
-						this.serverUom == state.uom;
-						this.state.value = converter ? converter.from(this.state.rawValue) : Converter.convert(state.uom, this.uom, this.state.rawValue);
+						this.serverUom = state.uom;
+						this.state.value = converter
+							? converter.from(this.state.rawValue)
+							: Converter.convert(state.uom, this.uom, this.state.rawValue);
 					} else if (converter) {
 						this.state.value = converter.from(state.value);
 					} else {
 						this.state.value = state.value;
 					}
-					this.state.formattedValue = state.formatted;
-					if (notify) node.events.emit(`${this.name}Changed`, driver as D, this.state.value, previousValue, this.state.formattedValue);
+
+					if (notify) {
+						// @ts-ignore
+						node.events.emit(changedEventName, driver as D, this.state.value, previousValue, this.state.formattedValue);
+					}
 					if (!this.initialized) {
 						this.initialized = true;
+					} else {
+						this.state.initial = false;
 					}
 					return true;
 				}
 			},
 			patch(value: T, formattedValue: string, uom: UnitOfMeasure, prec: number, notify = true) {
-				let previousValue = this.state.rawValue;
+				if (uom == 0 || uom == null) {
+					return false;
+				}
+				let previousRawValue = this.state.rawValue;
+				let previousValue = this.state.value;
 				this.state.rawValue = value;
 				this.state.formattedValue = formattedValue;
+
 				if (uom != this.uom) {
 					this.serverUom == uom;
-					this.state.value = converter ? converter.from(this.state.rawValue) : Converter.convert(uom, this.uom, this.state.rawValue);
+					this.state.value = converter
+						? converter.from(this.state.rawValue)
+						: Converter.convert(uom, this.uom, this.state.rawValue);
 				} else if (converter) {
 					this.state.value = converter.from(value);
 				} else {
 					this.state.value = value;
 				}
-				if (previousValue == this.state.value) {
+				if (previousRawValue == this.state.rawValue) {
 					return false;
 				}
-				if (notify) node.events.emit(`${this.name}Changed`, driver as D, this.state.value, previousValue, formattedValue);
+
+				if (notify) {
+					// @ts-ignore
+					if (node.events.emit(changedEventName, driver as D, this.state.value, previousValue, formattedValue)) {
+						// @ts-ignore
+						node.logger(
+							`Driver ${this.id} changed from ${previousValue} ${previousRawValue} to ${this.state.value} (${this.state.rawValue})`
+						);
+					}
+				}
+
 				if (!this.initialized) {
-					
 					this.initialized = true;
+				} else {
+					this.state.initial = false;
 				}
 				return true;
 			},
 			get value() {
 				return c.state.value;
 			},
-			name: initState?.name ?? driverSignature?.name ?? driver,
-			label: driverSignature?.label ?? driver
+			name: name,
+			label: label,
+			changedEventName: changedEventName,
 		};
 		//  node.on('PropertyChanged', (propertyName, newValue, oldValue, formattedValue) => {
 		//     if (propertyName === driver) {