isy-nodejs 0.5.0-beta.8 → 1.0.1-alpha.0

package/src/Utils.ts

@@ -1,11 +1,71 @@
-import { get } from 'restler';
+import axios, { AxiosRequestConfig } from 'axios';
 
 import * as log4js from '@log4js-node/log4js-api';
+import winston, { Logger, format } from 'winston';
 
-import { Categories } from './Categories';
-
+import { Axios } from 'axios';
+import { EventEmitter as BaseEventEmitter } from 'events';
+import { Category } from './Definitions/Global/Categories.js';
 
 //import { get } from 'http';
+import type { Identity } from '@project-chip/matter.js/util';
+import { isBoxedPrimitive } from 'util/types';
+import {  Family, type Driver, type DriverType, type EnumLiteral } from './Definitions/index.js';
+import { EventType } from './Events/EventType.js';
+
+export interface Converter<F, T> {
+	// #region Properties (2)
+
+	from: (value: F) => T;
+	to: (value: T) => F;
+
+	// #endregion Properties (2)
+}
+
+export type StringKeys<T> = Extract<keyof T, string>;
+
+export function getEnumValueByEnumKey<E extends { [index: string]: number }, T extends keyof E>(enumType: E, enumKey: T): E[T] {
+	return enumType[enumKey];
+}
+
+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 type ValuesOf<TEnum extends number | string | boolean | bigint> = `${TEnum}` extends `${infer R extends number}` ? R : `${TEnum}`;
+
+type s = ValuesOf<Family>;
+
+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>;
+
+//onst D: d = 'ST';
+//type DriverLabel = Values<IdentityOf<DriverType>>;
+export function invert<F, T>(converter: Converter<F, T>): Converter<T, F> {
+	return {
+		from: converter.to,
+		to: converter.from
+	};
+}
+
+export type MaybeArray<T> = T | T[];
+
+export type ObjectToUnion<T> = T[keyof T];
+
+export function toArray<T>(value: MaybeArray<T>): T[] {
+	if (undefined === value) return [];
+	return Array.isArray(value) ? value : [value];
+}
+
+export function fromArray<T>(...value: T[]): MaybeArray<T> {
+	if (value.length === 1) {
+		return value[0] ?? undefined;
+	}
+	return value;
+}
 
 export function byteToPct(value) {
 	return Math.round((value * 100) / 255);
@@ -21,50 +81,177 @@ export function byteToDegree(value) {
 
 let lastrequest = Promise.resolve();
 
-export async function getAsync(url: string, options: any): Promise<any> {
-	const p = new Promise<any>((resolve, reject) => {
-		// console.log('Calling: ' + url);
-		get(url, options)
-			.on('complete', (result: any) => {
-				//console.log(JSON.stringify(result));
-				resolve(result);
-			})
-			.on('error', (err, response) => {
-
-				reject(err);
-			})
-			.on('fail', (data, response) => {
-
-				reject(data);
-			})
-			.on('abort', () => {
-				reject();
-			})
-			.on('timeout', (ms) => {
-				reject(ms);
-			});
+declare module 'winston' {
+	interface Logger extends LoggerLike {}
+}
+
+declare global {
+	interface String {
+		// #region Public Methods (6)
+
+		left(numChars: number): string;
+		leftWithToken(numChars: number, token?: string): string;
+		remove(string: string): string;
+		removeAll(string: string): string;
+		right(numChars: number): string;
+		rightWithToken(numChars: number, token?: string): string;
+
+		// #endregion Public Methods (6)
+	}
+}
+
+export interface LoggerLike extends Partial<log4js.Logger> {
+	//default(msg: any): void;
+}
+// `${`${const origCreateLogger = winston.createLogger.bind(winston)
+// Logger.prototwinston.createLogger = (options) =>
+// {
+// let logger =  winston.createLogger(options);
+// logger.prototype = logger.log.bind(logger);
+// }
+// }`}`
+
+export function valueOf<E, T extends Extract<keyof E, string>>(e: E, val: T): E[T] {
+	return e[val];
+}
+
+export function clone(logger: Logger, label: string): Logger {
+	return winston.createLogger({
+		format: format.label({ label }),
+		transports: logger.transports,
+		level: logger.level,
+		levels: logger.levels,
+		exitOnError: logger.exitOnError,
+		exceptionHandlers: logger.exceptions,
+		...logger
 	});
-	//await lastrequest;
 
-	//lastrequest = p;
+	// `${const copy1 = { ...logger };copy1.prefix = copy1.prefix = prefix ?? logger.prototype;
+
+	// const copy = logger.info.bind(copy1) as Logging;
+	// Object.assign(copy, logger);
+	// copy.prefix = prefix ?? logger.prefix;
+
+	// copy.isDebugEnabled = () => ISYPlatform.Instance.debugLoggingEnabled;
 
-	return p;
+	// copy.isErrorEnabled = () => true;
+
+	// copy.isWarnEnabled = () => true;
+
+	// copy.isFatalEnabled = () => true;
+
+	// copy.isTraceEnabled = () => true;
+
+	// // copy._log = logger._log.bind(copy);
+	// copy.debug = logger.debug.bind(copy);
+	// // copy.fatal = logger..bind(copy);
+	// copy.info = logger.info.bind(copy);
+	// copy.error = logger.error.bind(copy);
+	// copy.warn = logger.warn.bind(copy);
+
+	// copy.trace = ((message: ConcatArray<string>, ...args: any[]) => {
+	// 	// onst newMsg = chalk.dim(msg);
+	// 	if (copy.isTraceEnabled) {
+	// 		copy.log.apply(this, ['trace'].concat(message).concat(args));
+	// 	}
+	// }).bind(copy);
+
+	// copy.fatal = ((message: ConcatArray<string>, ...args: any[]) => {
+	// 	// onst newMsg = chalk.dim(msg);
+	// 	if (logger?.isFatalEnabled) {
+	// 		logger.log.apply(this, ['fatal'].concat(message).concat(args));
+	// 	}
+	// }).bind(copy);}`
+
+	//return copy;
+}
+
+// export function wire(logger: Logger) {
+// 	logger.isDebugEnabled = () => ISYPlatform.Instance.debugLoggingEnabled;
+
+// 	logger.isErrorEnabled = () => true;
+
+// 	logger.isWarnEnabled = () => true;
+
+// 	logger.isFatalEnabled = () => true;
+
+// 	logger.isTraceEnabled = () => true;
+
+// 	logger.trace = ((message, ...args: any[]) => {
+// 		// onst newMsg = chalk.dim(msg);
+// 		if (logger.isTraceEnabled()) {
+// 			logger.log.apply(this, ['trace'].concat(message).concat(args));
+// 		}
+// 	}).bind(logger);
+
+// 	logger.fatal = ((message, ...args: any[]) => {
+// 		// onst newMsg = chalk.dim(msg);
+// 		if (logger.isFatalEnabled()) {
+// 			logger.log.apply(this, ['fatal'].concat(message).concat(args));
+// 		}
+// 	}).bind(logger);
+
+// }
+
+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;
+
+	// #endregion Public Methods (1)
 }
 
-export enum Family {
-	Insteon = 1,
-	UPB = 7
+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 {
+		return super.on(event, listener);
+	}
+
+	// #endregion Public Methods (1)
 }
 
-export interface LoggerLike extends Partial<log4js.Logger> {
-	prefix?: string;
-	(msg: any): void;
-	default(msg: any): void;
+export function right(this: string, numChars: number) {
+	var l = this.length;
+	return this.substring(length - numChars);
+}
+
+export function left(this: string, numChars: number) {
+	return this.substring(0, numChars - 1);
+}
+
+export function rightWithToken(this: string, maxNumChars: number, token: string = ' ') {
+	var s = this.split(token);
+	var sb = s.pop();
+	var sp = s.pop();
+	while (sp !== undefined && sb.length + sp.length + token.length <= maxNumChars) {
+		sb = sp + token + sb;
+		sp = s.pop();
+	}
+}
+
+export function leftWithToken(this: string, maxNumChars: number, token: string = ' ') {
+	var s = this.split(token).reverse();
+	var sb = s.pop();
+	var sp = s.pop();
+	while (sp !== undefined && sb.length + sp?.length + token.length <= maxNumChars) {
+		sb = sb + token + sp;
+
+		sp = s.pop();
+	}
+}
+
+export function remove(this: string, searchValue: string | RegExp) {
+	return this.replace(searchValue, '');
+}
 
+export function removeAll(this: string, searchValue: string | RegExp) {
+	return this.replaceAll(searchValue, '');
 }
 
-export function parseTypeCode(typeCode: string) : {category: Categories, deviceCode: number, firmwareVersion: number, minorVersion: number }
-{
+export function parseTypeCode(typeCode: `${string}.${string}.${string}.${string}`): { category: Category; deviceCode: number; firmwareVersion: number; minorVersion: number } {
 	try {
 		const s = typeCode.split('.');
 
@@ -76,19 +263,19 @@ export function parseTypeCode(typeCode: string) : {category: Categories, deviceC
 	}
 }
 
-export function getCategory(device: { type: string; }) {
+export function getCategory(device: { type: string }) {
 	try {
 		const s = device.type.split('.');
 		return Number(s[0]);
 	} catch (err) {
-		return Categories.Unknown;
+		return Category.Unknown;
 	}
 }
-export function getSubcategory(device: { type: string; }) {
+export function getSubcategory(device: { type: string }) {
 	try {
 		const s = device.type.split('.');
 		return Number(s[1]);
 	} catch (err) {
-		return Categories.Unknown;
+		return Category.Unknown;
 	}
 }