isy-nodejs 1.0.8-alpha.0 → 1.3.24

package/src/Utils.ts

@@ -1,105 +1,214 @@
 import * as log4js from '@log4js-node/log4js-api';
-import winston, { Logger, format, type LeveledLogMethod, type LogMethod } from 'winston';
+import winston, { Logger, format, type LeveledLogMethod } from 'winston';
 
 import { EventEmitter as BaseEventEmitter } from 'events';
-import { Category } from './Definitions/Global/Categories.js';
 
-//import { get } from 'http';
+//import { get } from 'http';}
 import type { PackageJson } from '@npmcli/package-json';
-import type { Axios, AxiosRequestConfig } from 'axios';
-import { existsSync } from 'fs';
-import { readFile } from 'fs/promises';
+import { type AxiosRequestConfig } from 'axios';
+import chalk, { type ChalkInstance } from 'chalk';
+import { existsSync, mkdirSync } from 'fs';
+import { writeFile as baseWriteFile, readFile } from 'fs/promises';
+import { resolve } from 'import-meta-resolve';
+import { merge } from 'moderndash';
+import Mutex, * as mutex from 'p-mutex';
 import path from 'path';
-import { Family } from './Definitions/index.js';
+import {
+	Constructor,
+	Primitive,
+	type Get,
+	type JsonObject,
+	type JsonPrimitive,
+	type Merge,
+	type SnakeCase,
+	type SnakeCasedProperties,
+	type SnakeCasedPropertiesDeep,
+	type StringKeyOf,
+} from 'type-fest';
+import { fileURLToPath } from 'url';
 import { EventType } from './Events/EventType.js';
-import type { Constructor } from 'type-fest';
+import type { ISY, UnitOfMeasure, Family } from './ISY.js';
+import type { ISYNode } from './ISYNode.js';
+import type { RelayLamp } from './Devices/Insteon/index.js';
+
+export interface Factory<T extends object> {
+	create?(...args: any[]): Promise<T> | T;
+	is?<K extends T>(obj: object): obj is T;
+	isImplementedBy?(obj: object): obj is T;
+	Class: Constructor<T>;
+}
+
+export function isFactory(obj: any): obj is Factory<any> {
+	return obj.Class !== undefined;
+}
 
+export function includes<T>(value: T, maybeArray: MaybeArray<T>): boolean;
+export function includes<T>(value: T, ...maybeArray: T[]): boolean {
+	if (Array.isArray(maybeArray)) {
+		return maybeArray.includes(value);
+	} else if (maybeArray != null) {
+		return maybeArray === value;
+	} else {
+		return false;
+	}
+}
 
-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;
+export async function writeFile<T extends JsonObject | string>(
+	data: T,
+	filename: string,
+	...paths: string[]
+): Promise<void> {
+	try {
+		let o = path.resolve(...paths);
+		if (!existsSync(o)) {
+			mkdirSync(o, { recursive: true });
+		}
+		return await baseWriteFile(path.resolve(o, filename), typeof data == 'object' ? JSON.stringify(data) : data);
+	} catch (err) {
+		console.error(`Error writing file ${filename} to folder: ${err}`, err);
+	}
+}
+
+export async function writeDebugFile<T extends JsonObject | string>(
+	data: T,
+	filename: string,
+	logger?: winston.Logger,
+	...paths: string[]
+): Promise<void> {
+	try {
+		let o = path.resolve(...paths, 'debug');
+		if (!existsSync(o)) {
+			mkdirSync(o, { recursive: true });
+		}
+		return await baseWriteFile(path.resolve(o, filename), typeof data == 'object' ? JSON.stringify(data) : data);
+	} catch (err) {
+		logger?.error(`Error writing file ${filename} to debug folder: ${err}`, err);
+	}
+}
 
+export function some<T>(predicate: (p: T) => boolean, ...maybeArray: T[]): boolean {
+	return maybeArray.some(predicate);
+}
 
-	} & {Node: Constructor<T>} | {Device: Constructor<T>};
+export type WithUOM<P extends Primitive = JsonPrimitive, U extends UnitOfMeasure = UnitOfMeasure> = [value: P, uom: U];
+
+export type MaybeWithUOM<P extends Primitive = JsonPrimitive, U extends UnitOfMeasure = UnitOfMeasure> =
+	| [value: P | undefined, uom: U]
+	| P;
+
+export function hasUOM<P extends Primitive>(value: MaybeWithUOM<P>): value is WithUOM<P>;
+export function hasUOM<P extends Primitive, U extends UnitOfMeasure>(
+	value: MaybeWithUOM<P, U>,
+	uom?: U
+): value is WithUOM<P, U> {
+	if (!Array.isArray(value)) {
+		return false;
+	} else if (uom != null) return value['uom'] == uom;
+	else return true;
+}
 
-export function isFactory(obj: any): obj is Factory<any> {
-	return obj.Node !== undefined || obj.Device !== undefined;
+export function isPrimitive(value: any): value is JsonPrimitive {
+	return typeof value == 'string' || typeof value == 'boolean' || typeof value == 'number';
 }
 
 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;
+	if (isFactory(obj)) {
+		return obj.Class;
 	}
 	return obj;
 }
 
+export type ConstructorOf<T> =
+	T extends Factory<infer U> ? Constructor<U> : T extends Constructor<infer U> ? Constructor<U> : Constructor<T>;
 
-export type ConstructorOf<T> = T extends Factory<infer U>  ? Constructor<U> : T extends Constructor<infer U> ? U : Constructor<T> ;
+export type InstanceOf<T> = T extends Factory<infer U> ? U : T extends Constructor<infer U> ? U : T;
 
+export type ExtractKeys<T, U> = keyof { [K in keyof T]: T[K] extends U ? K : never };
 
 export type StringKeys<T> = Extract<keyof T, string>;
 
 export type PickOfType<T, U> = {
-	[K in keyof T]: T[K] extends U ?
-		any extends T[K] ?
-			never
-		:	K
-	:	undefined;
+	[K in keyof T]: T[K] extends U ? (any extends T[K] ? never : K) : undefined;
 }[keyof T];
 
-export type Paths<T> = T extends object ? { [K in keyof T]: `${Exclude<K, symbol>}${'' | `.${Paths<T[K]>}`}` }[keyof T] : never;
+export type Paths<T> = T extends object
+	? { [K in keyof T]: `${Exclude<K, symbol>}${'' | `.${Paths<T[K]>}`}` }[keyof T]
+	: never;
 
 export type Prev = [never, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
 
-
-export type Join<K, P> =
-	K extends string | number ?
-		P extends string | number ?
-			`${K}${'' extends P ? '' : '.'}${P}`
-		:	never
-	:	never;
-export type PathsWithLimit<T, D extends number = 10> =
-	[D] extends [never] ? never
-	: T extends object ? { [K in keyof T]-?: K extends string | number ? `${K}` | Join<K, PathsWithLimit<T[K], Prev[D]>> : never }[keyof T]
-	: '';
-
-export type Leaves<T, D extends number = 10> =
-	[D] extends [never] ? never
-	: T extends object ? { [K in keyof T]-?: Join<K, Leaves<T[K], Prev[D]>> }[keyof T]
-	: '';
-
-export function getEnumValueByEnumKey<E extends { [index: string]: number }, T extends keyof E>(enumType: E, enumKey: T): E[T] {
+export type Join<K, P> = K extends string | number
+	? P extends string | number
+		? `${K}${'' extends P ? '' : '.'}${P}`
+		: never
+	: never;
+export type PathsWithLimit<T, D extends number = 10> = [D] extends [never]
+	? never
+	: T extends object
+		? {
+				[K in keyof T]-?: K extends string | number ? `${K}` | Join<K, PathsWithLimit<T[K], Prev[D]>> : never;
+			}[keyof T]
+		: '';
+
+export type Leaves<T, D extends number = 10> = [D] extends [never]
+	? never
+	: T extends object
+		? { [K in keyof T]-?: Join<K, Leaves<T[K], Prev[D]>> }[keyof T]
+		: '';
+
+export function getEnumValueByEnumKey<E extends { [index: string]: number }, T extends keyof E>(
+	enumType: E,
+	enumKey: T
+): E[T] {
 	return enumType[enumKey];
 }
 
-export type Replace<K extends string, T extends string, U extends string> = K extends `${infer L}${T}${infer R}` ? `${L}${U}${R}` : K;
+export type Replace<K extends string, T extends string, U extends string> = K extends `${infer L}${T}${infer R}`
+	? `${L}${U}${R}`
+	: K;
 
 export type Remove<K extends string, T extends string> = K extends `${infer L}${T}${infer R}` ? `${L}${R}` : K;
 
-export type ReplaceAll<K extends string, T extends string, U extends string> = K extends `${infer L}${T}${infer R}` ? `${L}${U}${ReplaceAll<R, T, U>}` : K;
+export type ReplaceAll<K extends string, T extends string, U extends string> = K extends `${infer L}${T}${infer R}`
+	? `${L}${U}${ReplaceAll<R, T, U>}`
+	: K;
 
-export function getEnumKeyByEnumValue<E extends { [index: string]: number }, T extends E[keyof E]>(enumType: E, enumValue: E[T]): T {
-	return Object.keys(enumType).find((key) => enumType[key] === enumValue) as unknown as T;
+export function getEnumKeyByEnumValue<E extends { [index: string]: number }, T extends E[keyof E]>(
+	enumType: E,
+	enumValue: E[T]
+): T {
+	return Object.keys(enumType).find(key => enumType[key] === enumValue) as unknown as T;
 }
 
+export namespace Enums {
+	export function getKeyByValue<E extends { [index: string]: number }, T extends E[keyof E]>(
+		enumType: E,
+		enumValue: E[T]
+	): T {
+		return Object.keys(enumType).find(key => enumType[key] === enumValue) as unknown as T;
+	}
+
+	export type ValuesOf<TEnum extends number | string | boolean | bigint> =
+		`${TEnum}` extends `${infer R extends number}` ? R : `${TEnum}`;
 
+	export type KeysOf<TEnum extends number | string | boolean | bigint> = `${TEnum}` extends infer R extends string
+		? R
+		: `${TEnum}`;
+}
+
+export function updateConfig<U extends Record<PropertyKey, any>, T extends U = U>(
+	baseConfig: T,
+	...updates: Partial<U>[]
+): T {
+	return merge(baseConfig, updates[0], ...updates.slice(1)) as any as T;
+}
 
 export type LogLevel = PickOfType<winston.Logger, LeveledLogMethod>;
-export type ValuesOf<TEnum extends number | string | boolean | bigint> = `${TEnum}` extends `${infer R extends number}` ? R : `${TEnum}`;
 
-type s = ValuesOf<Family>;
+export type LabelFor<TEnum, TEnumMember> = PickOfType<TEnum, TEnumMember>;
 
-type test = IdentityOf<Family>;
 export type IdentityOf<T> = T extends (...args: any[]) => infer R ? R : T;
 
-export type LabelsOf<TEnum> = keyof IdentityOf<TEnum>;
-type d = LabelsOf<Family>;
-
 export type MaybeArray<T> = T | T[];
 
 export type ObjectToUnion<T> = T[keyof T];
@@ -153,6 +262,21 @@ declare global {
 	}
 }
 
+export type ToENV<T> = SnakeCase<T>;
+
+export type UpperCaseProperties<T extends Record<string, any>> = {
+	[K in StringKeys<T> as Uppercase<`${K}`>]: T[K];
+};
+export type PROCESS_ENV = {
+	[x in Uppercase<ReplaceAll<Leaves<SnakeCasedPropertiesDeep<{ isy: ISY.Config }>>, '.', '_'>>]: string;
+};
+
+export type AsENV<T extends Record<string, unknown>> = {
+	[x in Leaves<T> as Uppercase<ReplaceAll<SnakeCase<`${x}`>, '.', '_'>>]?: Get<T, x> | undefined;
+};
+
+export type ENVISYConfig = AsENV<{ isy: ISY.Config }>;
+
 export interface LoggerLike extends Partial<log4js.Logger> {
 	//default(msg: any): void;
 }
@@ -176,7 +300,7 @@ export function clone(logger: Logger, label: string): Logger {
 		levels: logger.levels,
 		exitOnError: logger.exitOnError,
 		exceptionHandlers: logger.exceptions,
-		...logger
+		...logger,
 	});
 
 	// `${const copy1 = { ...logger };copy1.prefix = copy1.prefix = prefix ?? logger.prototype;
@@ -251,7 +375,10 @@ type TEventType = keyof typeof EventType;
 export interface PropertyChangedEventEmitter extends EventEmitter<'PropertyChanged'> {
 	// #region Public Methods (1)
 
-	on(event: 'PropertyChanged', listener: (propertyName: string, newValue: any, oldValue: any, formattedValue: string) => void): this;
+	on(
+		event: 'PropertyChanged',
+		listener: (propertyName: string, newValue: any, oldValue: any, formattedValue: string) => void
+	): this;
 
 	// #endregion Public Methods (1)
 }
@@ -259,7 +386,12 @@ export interface PropertyChangedEventEmitter extends EventEmitter<'PropertyChang
 export class EventEmitter<T extends TEventType> extends BaseEventEmitter {
 	// #region Public Methods (1)
 
-	public override on(event: T, listener: ((propertyName: string, newValue: any, oldValue: any, formattedValue: string) => any) | ((controlName: string) => any)): this {
+	public override on(
+		event: T,
+		listener:
+			| ((propertyName: string, newValue: any, oldValue: any, formattedValue: string) => any)
+			| ((controlName: string) => any)
+	): this {
 		return super.on(event, listener);
 	}
 
@@ -268,7 +400,7 @@ export class EventEmitter<T extends TEventType> extends BaseEventEmitter {
 
 export function right(this: string, numChars: number) {
 	var l = this.length;
-	return this.substring(length - numChars);
+	return this.substring(l - numChars);
 }
 
 export function left(this: string, numChars: number) {
@@ -304,7 +436,39 @@ export function removeAll(this: string, searchValue: string | RegExp) {
 	return this.replaceAll(searchValue, '');
 }
 
-export function parseTypeCode(typeCode: `${string}.${string}.${string}.${string}`): { category: Category; deviceCode: number; firmwareVersion: number; minorVersion: number } {
+const closeMutex = new Mutex();
+
+const exitMutex = new Mutex();
+
+export async function disposeGracefully(object: Disposable | AsyncDisposable, logger?: winston.Logger): Promise<void> {
+	await closeMutex.withLock(async () => {
+		if (Symbol.dispose in object) {
+			logger?.warn(`Disposing ${object.constructor.name}`);
+			object[Symbol.dispose]();
+			logger?.warn(`Disposed ${object.constructor.name}`);
+		} else if (Symbol.asyncDispose in object) {
+			logger?.warn(`Async disposing ${object.constructor.name}`);
+			await object[Symbol.asyncDispose]();
+			logger?.warn(`Async disposed ${object.constructor.name}`);
+		}
+	});
+}
+
+export async function exitGracefully(exitCode: number, logger?: winston.Logger): Promise<void> {
+	await exitMutex.withLock(async () => {
+		logger.once('finish', () => {
+			process.exit(exitCode);
+		});
+		if (exitCode === 0) {
+			logger?.info('Exiting');
+		} else {
+			logger?.error(`Exiting with error code ${exitCode}`);
+		}
+		logger.end();
+	});
+}
+
+/*export function parseTypeCode(typeCode: `${string}.${string}.${string}.${string}`): { category: Category; deviceCode: number; firmwareVersion: number; minorVersion: number } {
 	try {
 		const s = typeCode.split('.');
 
@@ -314,24 +478,7 @@ export function parseTypeCode(typeCode: `${string}.${string}.${string}.${string}
 	} catch (err) {
 		return null;
 	}
-}
-
-export function getCategory(device: { type: string }) {
-	try {
-		const s = device.type.split('.');
-		return Number(s[0]);
-	} catch (err) {
-		return Category.Unknown;
-	}
-}
-export function getSubcategory(device: { type: string }) {
-	try {
-		const s = device.type.split('.');
-		return Number(s[1]);
-	} catch (err) {
-		return Category.Unknown;
-	}
-}
+}*/
 
 function getImportMeta() {
 	try {
@@ -344,20 +491,29 @@ function getImportMeta() {
 		return { dirname, filename };
 	}
 }
-export async function findPackageJson(currentPath: string = getImportMeta().dirname): Promise<PackageJson> {
-	try {
-		while (currentPath !== '/') {
-			const packageJsonPath = path.join(currentPath, 'package.json');
-			if (existsSync(packageJsonPath)) {
-				return JSON.parse((await readFile(packageJsonPath)).toString());
+export async function findPackageJson(moduleName: string = 'isy-nodejs'): Promise<PackageJson & { path: string }> {
+	let currentPath = fileURLToPath(resolve(moduleName, import.meta.url));
+
+	console.log(currentPath);
+	while (currentPath !== '/') {
+		const packageJsonPath = path.join(currentPath, 'package.json');
+		if (existsSync(packageJsonPath)) {
+			let s = JSON.parse((await readFile(packageJsonPath)).toString());
+			if (s.name?.toLowerCase() === moduleName.toLowerCase()) {
+				return { ...s, path: packageJsonPath };
 			}
-			currentPath = path.join(currentPath, '..');
 		}
-	} catch {
-		//@ts-expect-error
-		return (await import('../../package.json', { with: { type: 'json' } })).default;
+		currentPath = path.resolve(currentPath, '..');
 	}
-	return null;
+	//} catch {
+
+	//	return (await import('../../package.json', { with: { type: 'json' } })).default;
+	//}
+	//return null;
+}
+
+export function emphasize(text: unknown, color: ChalkInstance = chalk.white): string {
+	return color.bold(text);
 }
 
 export function logStringify(obj: any, indent = 2) {
@@ -379,7 +535,14 @@ export function logStringify(obj: any, indent = 2) {
 			if (value instanceof Set) {
 				return [...value];
 			}
-			if (key.toLowerCase().includes('password')) {
+			if (
+				key.toLowerCase().includes('password') ||
+				key.toLowerCase().includes('secret') ||
+				key.toLowerCase().includes('token') ||
+				key.toLowerCase().includes('key') ||
+				key.toLowerCase().includes('credentials') ||
+				key.toLowerCase().includes('credential')
+			) {
 				return '********';
 			}
 			return value;
@@ -389,13 +552,14 @@ export function logStringify(obj: any, indent = 2) {
 	cache = null;
 	return retVal;
 }
-export type RelaxTypes<V> =
-	V extends number ? number
-	: V extends bigint ? bigint
-	: V extends object ?
-		V extends (...args: any[]) => any ?
-			V
-		:	{
-				[K in keyof V]: RelaxTypes<V[K]>;
-			}
-	:	V;
+export type RelaxTypes<V> = V extends number
+	? number
+	: V extends bigint
+		? bigint
+		: V extends object
+			? V extends (...args: any[]) => any
+				? V
+				: {
+						[K in keyof V]: RelaxTypes<V[K]>;
+					}
+			: V;

package/src/VariableType.ts

@@ -0,0 +1,4 @@
+export enum VariableType {
+	Integer = 1,
+	State = 2,
+}