isy-nodejs 1.0.2-alpha.2 → 1.0.2-alpha.4

package/package.json

@@ -2,7 +2,7 @@
     "name": "isy-nodejs",
     "description": "Node.js wrapper for ISY interface including websockets for change notifications. Fork of isy-js by Rod Toll. Designed to be used in a node.js application.",
     "license": "MIT",
-    "version": "1.0.2-alpha.2",
+    "version": "1.0.2-alpha.4",
     "author": {
         "name": "Pradeep Mouli"
     },
@@ -71,5 +71,5 @@
     "publishConfig": {
         "access": "public"
     },
-    "gitHead": "fac612b29924e40d54cfda336f91c8dc9ba01636"
+    "gitHead": "21e7087d05090f242cbd715056d218bd71f0bba8"
 }

package/src/CodeGeneration/NodeClassFactory.ts

@@ -3,9 +3,10 @@ import { factory, Statement, type Declaration } from 'typescript';
 import type { Driver } from '../Definitions/Global/Drivers.js';
 import { UnitOfMeasure } from '../Definitions/Global/UOM.js';
 
+import { Family } from '../Definitions/index.js';
 import { CommandDefinition, DataTypeDefinition, DriverDefinition, NodeClassDefinition, ParameterDefinition } from '../Model/ClassDefinition.js';
 import { EnumDefinitionMap } from '../Model/EnumDefinition.js';
-import  { Family } from '../Definitions/index.js';
+import { CodeFactory } from './NodeFactory.js';
 
 // #region Type aliases (1)
 
@@ -22,7 +23,7 @@ type GeneratedNodeClass<T extends Family> = {
 
 // #region Classes (1)
 
-export class NodeClassFactory {
+export class NodeClassFactory extends CodeFactory {
 	// #region Properties (2)
 
 	public static _basePath: string;
@@ -38,6 +39,8 @@ export class NodeClassFactory {
 		}
 	});
 
+	static instance: NodeClassFactory = new NodeClassFactory(ts.factory);
+
 	// #endregion Properties (2)
 
 	// #region Public Static Getters And Setters (2)
@@ -55,10 +58,20 @@ export class NodeClassFactory {
 	// #region Public Static Methods (4)
 
 	public static buildNodeClasses<T extends Family>(map: { [x: string]: NodeClassDefinition<T> }): GeneratedNodeClass<T>[] {
-		return Object.values(map).map((p) => this.createNodeClass(p));
+		return Object.values(map)
+			.filter((p) => !p.equivalentTo)
+			.map((p) => {
+				try {
+					return NodeClassFactory.instance.createNodeClass(p);
+				} catch (e) {
+					console.error(e);
+				}
+			});
 	}
 
-	public static createNodeClass<T extends Family>(nodeClassDef: NodeClassDefinition<T>) {
+	N;
+
+	public createNodeClass<T extends Family>(nodeClassDef: NodeClassDefinition<T>) {
 		let path = `${NodeClassFactory.basePath}/${Family[nodeClassDef.family]}/Generated/${nodeClassDef.name}.ts`;
 		let sf = ts.createSourceFile(path, '', ts.ScriptTarget.ES2023, true, ts.ScriptKind.TS);
 		//@ts-expect-error
@@ -82,12 +95,7 @@ export class NodeClassFactory {
 				factory.createStringLiteral('../../../Model/NodeInfo.js'),
 				undefined
 			),
-			factory.createImportDeclaration(
-				undefined,
-				factory.createImportClause(true, undefined, factory.createNamedImports([factory.createImportSpecifier(false, undefined, factory.createIdentifier('ISY'))])),
-				factory.createStringLiteral('../../../ISY.js'),
-				undefined
-			),
+			this.createImportDeclaration('../../../ISY.js', ['ISY']),
 			factory.createImportDeclaration(
 				undefined,
 				factory.createImportClause(true, undefined, factory.createNamedImports([factory.createImportSpecifier(false, undefined, factory.createIdentifier('ISYNode'))])),
@@ -131,7 +139,7 @@ export class NodeClassFactory {
 				undefined
 			),
 			factory.createVariableStatement(
-				[factory.createToken(ts.SyntaxKind.ExportKeyword)],
+				undefined,
 				factory.createVariableDeclarationList(
 					[factory.createVariableDeclaration(factory.createIdentifier('nodeDefId'), undefined, undefined, factory.createStringLiteral(nodeClassDef.id))],
 					ts.NodeFlags.Const
@@ -195,11 +203,28 @@ export class NodeClassFactory {
 						undefined,
 						factory.createStringLiteral(nodeClassDef.id)
 					),
+					this.createPropertyDeclaration(
+						'implements',
+						factory.createArrayLiteralExpression(
+							nodeClassDef.implementedBy ?
+								[this.createStringLiteral(nodeClassDef.id)].concat(
+									!nodeClassDef.implements || nodeClassDef.implements.length == 0 ? [] : nodeClassDef.implements?.map((p) => factory.createStringLiteral(p))
+								)
+							:	[this.createStringLiteral(nodeClassDef.id)]
+						),
+						this.createModifiers(ts.ModifierFlags.Static | ts.ModifierFlags.Override)
+					),
 					factory.createPropertyDeclaration(
 						[factory.createToken(ts.SyntaxKind.DeclareKeyword), factory.createToken(ts.SyntaxKind.ReadonlyKeyword)],
 						factory.createIdentifier('nodeDefId'),
 						undefined,
-						factory.createLiteralTypeNode(factory.createStringLiteral(nodeClassDef.id)),
+						nodeClassDef.equivalents ?
+							NodeClassFactory.instance.createUnionTypeNode(
+								...[this.createLiteralTypeNode(nodeClassDef.id)].concat(
+									!nodeClassDef.equivalents || nodeClassDef.equivalents.length == 0 ? [] : nodeClassDef.equivalents?.map((p) => factory.createLiteralTypeNode(factory.createStringLiteral(p)))
+								)
+							)
+						:	this.createLiteralTypeNode(nodeClassDef.id),
 						undefined
 					),
 					factory.createConstructorDeclaration(
@@ -239,6 +264,17 @@ export class NodeClassFactory {
 					factory.createIdentifier(`${nodeClassDef.name}Node`)
 				])
 			),
+
+			...(nodeClassDef.equivalents ?
+				nodeClassDef.equivalents?.map((p) =>
+					factory.createExpressionStatement(
+						factory.createCallExpression(factory.createPropertyAccessExpression(factory.createIdentifier('NodeFactory'), factory.createIdentifier('register')), undefined, [
+							factory.createIdentifier(`${nodeClassDef.name}Node`),
+							factory.createStringLiteral(p)
+						])
+					)
+				)
+			:	[]),
 			factory.createModuleDeclaration(
 				[factory.createToken(ts.SyntaxKind.ExportKeyword)],
 				factory.createIdentifier(nodeClassDef.name),
@@ -250,7 +286,7 @@ export class NodeClassFactory {
 						[
 							factory.createHeritageClause(ts.SyntaxKind.ExtendsKeyword, [
 								factory.createExpressionWithTypeArguments(factory.createIdentifier('Omit'), [
-									factory.createTypeReferenceNode(factory.createIdentifier('InstanceType'), [factory.createTypeQueryNode(factory.createIdentifier(`${nodeClassDef.name}Node`), undefined)]),
+									this.createTypeReferenceNode('InstanceType', this.factory.createTypeQueryNode(factory.createIdentifier(`${nodeClassDef.name}Node`))),
 									factory.createTypeOperatorNode(
 										ts.SyntaxKind.KeyOfKeyword,
 										factory.createTypeReferenceNode(factory.createIdentifier('ISYDeviceNode'), [
@@ -263,8 +299,22 @@ export class NodeClassFactory {
 								])
 							])
 						],
-						[factory.createPropertySignature(undefined, factory.createIdentifier('nodeDefId'), undefined, factory.createLiteralTypeNode(factory.createStringLiteral(nodeClassDef.id)))]
+						[
+							factory.createPropertySignature(
+								undefined,
+								factory.createIdentifier('nodeDefId'),
+								undefined,
+								nodeClassDef.equivalents ?
+									this.createUnionTypeNode(
+										...[this.createLiteralTypeNode(nodeClassDef.id)].concat(
+											!nodeClassDef.equivalents || nodeClassDef.equivalents.length == 0 ? [] : nodeClassDef.equivalents?.map((p) => factory.createLiteralTypeNode(factory.createStringLiteral(p)))
+										)
+									)
+								:	this.createLiteralTypeNode(nodeClassDef.id)
+							)
+						]
 					),
+
 					factory.createFunctionDeclaration(
 						[factory.createToken(ts.SyntaxKind.ExportKeyword)],
 						undefined,
@@ -286,17 +336,65 @@ export class NodeClassFactory {
 							)
 						],
 						factory.createTypePredicateNode(undefined, factory.createIdentifier('node'), factory.createTypeReferenceNode(factory.createIdentifier(`${nodeClassDef.name}Node`), undefined)),
-						factory.createBlock(
-							[
-								factory.createReturnStatement(
-									factory.createBinaryExpression(
-										factory.createPropertyAccessExpression(factory.createIdentifier('node'), factory.createIdentifier('nodeDefId')),
-										factory.createToken(ts.SyntaxKind.EqualsEqualsEqualsToken),
-										factory.createIdentifier('nodeDefId')
-									)
+						this.createBlock(
+							this.createReturnStatement(
+								factory.createCallExpression(
+									factory.createPropertyAccessExpression(
+										factory.createArrayLiteralExpression(
+											nodeClassDef.equivalents ?
+												[this.createStringLiteral(nodeClassDef.id)].concat(
+													!nodeClassDef.equivalents || nodeClassDef.equivalents.length == 0 ? [] : nodeClassDef.equivalents?.map((p) => factory.createStringLiteral(p))
+												)
+											:	[this.createStringLiteral(nodeClassDef.id)]
+										),
+										'includes'
+									),
+									undefined,
+									[factory.createPropertyAccessExpression(factory.createIdentifier('node'), factory.createIdentifier('nodeDefId'))]
 								)
-							],
-							true
+							)
+						)
+					),
+					factory.createFunctionDeclaration(
+						[factory.createToken(ts.SyntaxKind.ExportKeyword)],
+						undefined,
+						factory.createIdentifier('isImplementedBy'),
+						undefined,
+						[
+							factory.createParameterDeclaration(
+								undefined,
+								undefined,
+								factory.createIdentifier('node'),
+								undefined,
+								factory.createTypeReferenceNode(factory.createIdentifier('ISYNode'), [
+									factory.createKeywordTypeNode(ts.SyntaxKind.AnyKeyword),
+									factory.createKeywordTypeNode(ts.SyntaxKind.AnyKeyword),
+									factory.createKeywordTypeNode(ts.SyntaxKind.AnyKeyword),
+									factory.createKeywordTypeNode(ts.SyntaxKind.AnyKeyword)
+								]),
+								undefined
+							)
+						],
+						factory.createTypePredicateNode(undefined, factory.createIdentifier('node'), factory.createTypeReferenceNode(factory.createIdentifier(`${nodeClassDef.name}Node`), undefined)),
+						this.createBlock(
+							true,
+
+							factory.createReturnStatement(
+								factory.createCallExpression(
+									factory.createPropertyAccessExpression(
+										factory.createArrayLiteralExpression(
+											nodeClassDef.implementedBy ?
+												[this.createStringLiteral(nodeClassDef.id)].concat(
+													!nodeClassDef.implementedBy || nodeClassDef.implementedBy.length == 0 ? [] : nodeClassDef.implementedBy?.map((p) => factory.createStringLiteral(p))
+												)
+											:	[this.createStringLiteral(nodeClassDef.id)]
+										),
+										'includes'
+									),
+									undefined,
+									[factory.createPropertyAccessExpression(factory.createIdentifier('node'), factory.createIdentifier('nodeDefId'))]
+								)
+							)
 						)
 					),
 					factory.createFunctionDeclaration(
@@ -430,8 +528,8 @@ function createCommandMethodDeclaration(def: CommandDefinition) {
 
 		def.parameters ? Object.values(def.parameters).map(createParameterDeclarationSignature) : undefined,
 		undefined,
-		factory.createBlock(
-			[
+		NodeClassFactory.instance.createBlock(
+
 				factory.createReturnStatement(
 					factory.createCallExpression(factory.createPropertyAccessExpression(factory.createThis(), factory.createIdentifier('sendCommand')), undefined, [
 						factory.createStringLiteral(def.id),
@@ -445,8 +543,7 @@ function createCommandMethodDeclaration(def: CommandDefinition) {
 						:	[])
 					])
 				)
-			],
-			true
+
 		)
 	);
 }
@@ -464,10 +561,10 @@ function createCommandParameterType(def: DataTypeDefinition, parent: ParameterDe
 			}
 
 			if (def.values) {
-				return factory.createUnionTypeNode(Object.keys(def.values).map((p) => factory.createLiteralTypeNode(factory.createNumericLiteral(p))));
+				return NodeClassFactory.instance.createUnionTypeNode(...Object.keys(def.values).map((p) => factory.createLiteralTypeNode(factory.createNumericLiteral(p))));
 			}
 
-			//   return factory.createUnionTypeNode(
+			//   return NodeClassFactory.instance.createUnionTypeNode(...
 			//     Object.values(def.values).map((p) => factory.createTypeReferenceNode(
 			//   factory.createQualifiedName(
 			//     factory.createIdentifier("UnitOfMeasure"),
@@ -507,7 +604,7 @@ function createDriverGetDeclaration(def: DriverDefinition) {
 		[factory.createToken(ts.SyntaxKind.PublicKeyword)],
 		factory.createIdentifier(def.name),
 		[],
-		factory.createUnionTypeNode(Object.values(def.dataType).map((p) => createDriverPropertyReturnType(p, def))),
+		NodeClassFactory.instance.createUnionTypeNode(...Object.values(def.dataType).map((p) => createDriverPropertyReturnType(p, def))),
 		factory.createBlock(
 			[
 				factory.createReturnStatement(
@@ -563,10 +660,10 @@ function createDriverPropertyReturnType(def: DataTypeDefinition, parent: DriverD
 				}
 			}
 			if (def.values) {
-				return factory.createUnionTypeNode(Object.keys(def.values).map((p) => factory.createLiteralTypeNode(factory.createNumericLiteral(p))));
+				return NodeClassFactory.instance.createUnionTypeNode(...Object.keys(def.values).map((p) => factory.createLiteralTypeNode(factory.createNumericLiteral(p))));
 			}
 
-			//   return factory.createUnionTypeNode(
+			//   return NodeClassFactory.instance.createUnionTypeNode(...
 			//     Object.values(def.values).map((p) => factory.createTypeReferenceNode(
 			//   factory.createQualifiedName(
 			//     factory.createIdentifier("UnitOfMeasure"),
@@ -589,13 +686,17 @@ function createDriverSignature(def: DriverDefinition) {
 				undefined,
 				factory.createIdentifier('uom'),
 				undefined,
-				def.dataType ? factory.createUnionTypeNode(Object.values(def.dataType).map((p) => createTypeNodeForUOM(p.uom))) : factory.createKeywordTypeNode(ts.SyntaxKind.NumberKeyword)
+				def.dataType ?
+					NodeClassFactory.instance.createUnionTypeNode(...Object.values(def.dataType).map((p) => createTypeNodeForUOM(p.uom)))
+				:	factory.createKeywordTypeNode(ts.SyntaxKind.NumberKeyword)
 			),
 			factory.createPropertySignature(
 				undefined,
 				factory.createIdentifier('value'),
 				undefined,
-				def.dataType ? factory.createUnionTypeNode(Object.values(def.dataType).map((p) => createDriverSignatureReturnType(p, def))) : factory.createKeywordTypeNode(ts.SyntaxKind.NumberKeyword)
+				def.dataType ?
+					NodeClassFactory.instance.createUnionTypeNode(...Object.values(def.dataType).map((p) => createDriverSignatureReturnType(p, def)))
+				:	factory.createKeywordTypeNode(ts.SyntaxKind.NumberKeyword)
 			),
 			factory.createPropertySignature(undefined, factory.createIdentifier('label'), undefined, factory.createLiteralTypeNode(factory.createStringLiteral(def.label))),
 			factory.createPropertySignature(undefined, factory.createIdentifier('name'), undefined, factory.createLiteralTypeNode(factory.createStringLiteral(def.name)))
@@ -614,7 +715,7 @@ function createDriverSignatureReturnType(def: DataTypeDefinition, parent: Driver
 			}
 		}
 		if (def.values) {
-			return factory.createUnionTypeNode(Object.keys(def.values).map((p) => factory.createLiteralTypeNode(factory.createNumericLiteral(p))));
+			return NodeClassFactory.instance.createUnionTypeNode(...Object.keys(def.values).map((p) => factory.createLiteralTypeNode(factory.createNumericLiteral(p))));
 		}
 	}
 	return factory.createKeywordTypeNode(ts.SyntaxKind.NumberKeyword);
@@ -626,7 +727,9 @@ function createParameterDeclarationSignature(def: ParameterDefinition) {
 		undefined,
 		factory.createIdentifier(def.name ?? 'value'),
 		def.optional ? factory.createToken(ts.SyntaxKind.QuestionToken) : undefined,
-		def.dataType ? factory.createUnionTypeNode(Object.values(def.dataType).map((p) => createCommandParameterType(p, def))) : factory.createKeywordTypeNode(ts.SyntaxKind.NumberKeyword),
+		def.dataType ?
+			NodeClassFactory.instance.createUnionTypeNode(...Object.values(def.dataType).map((p) => createCommandParameterType(p, def)))
+		:	factory.createKeywordTypeNode(ts.SyntaxKind.NumberKeyword),
 		undefined
 	);
 }
@@ -637,13 +740,15 @@ function createParameterSignature(def: ParameterDefinition) {
 		undefined,
 		factory.createIdentifier(def.id ?? 'value'),
 		def.optional ? factory.createToken(ts.SyntaxKind.QuestionToken) : undefined,
-		def.dataType ? factory.createUnionTypeNode(Object.values(def.dataType).map((p) => createCommandParameterType(p, def))) : factory.createKeywordTypeNode(ts.SyntaxKind.NumberKeyword),
+		def.dataType ?
+			NodeClassFactory.instance.createUnionTypeNode(...Object.values(def.dataType).map((p) => createCommandParameterType(p, def)))
+		:	factory.createKeywordTypeNode(ts.SyntaxKind.NumberKeyword),
 		undefined
 	);
 }
 
 function createTypeNodeForUOM(uom: number): ts.TypeNode {
-	return factory.createTypeReferenceNode(factory.createQualifiedName(factory.createIdentifier('UnitOfMeasure'), factory.createIdentifier(UnitOfMeasure[uom] ?? 'Unknown')));
+	return NodeClassFactory.instance.createTypeReferenceNode(UnitOfMeasure[uom] ?? 'Unknown', 'UnitOfMeasure');
 }
 
 // #endregion Functions (12)