isy-nodejs 1.0.2-alpha.3 → 1.0.2-alpha.6

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 './CodeFactory.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>) {
+
+
+	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
-			),
+			NodeClassFactory.instance.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)
 					),
+					NodeClassFactory.instance.createPropertyDeclaration(
+						'implements',
+						factory.createArrayLiteralExpression(
+							nodeClassDef.implementedBy ?
+								[NodeClassFactory.instance.createStringLiteral(nodeClassDef.id)].concat(
+									!nodeClassDef.implements || nodeClassDef.implements.length == 0 ? [] : nodeClassDef.implements?.map((p) => factory.createStringLiteral(p))
+								)
+							:	[NodeClassFactory.instance.createStringLiteral(nodeClassDef.id)]
+						),
+						NodeClassFactory.instance.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(
+								...[NodeClassFactory.instance.createLiteralTypeNode(nodeClassDef.id)].concat(
+									!nodeClassDef.equivalents || nodeClassDef.equivalents.length == 0 ? [] : nodeClassDef.equivalents?.map((p) => factory.createLiteralTypeNode(factory.createStringLiteral(p)))
+								)
+							)
+						:	NodeClassFactory.instance.createLiteralTypeNode(nodeClassDef.id),
 						undefined
 					),
 					factory.createConstructorDeclaration(
@@ -225,13 +250,13 @@ export class NodeClassFactory {
 						factory.createBlock(
 							[
 								factory.createExpressionStatement(factory.createCallExpression(factory.createSuper(), undefined, [factory.createIdentifier('isy'), factory.createIdentifier('nodeInfo')])),
-								...Object.values(nodeClassDef.drivers).map(createDriverInitializationStatement)
+								...Object.values(nodeClassDef.drivers).map(p => NodeClassFactory.instance.createDriverInitializationStatement(p))
 							],
 							true
 						)
 					),
-					...Object.values(nodeClassDef.commands).map(createCommandMethodDeclaration),
-					...Object.values(nodeClassDef.drivers).map(createDriverGetDeclaration)
+					...Object.values(nodeClassDef.commands).map(p => NodeClassFactory.instance.createCommandMethodDeclaration(p)),
+					...Object.values(nodeClassDef.drivers).map(p => NodeClassFactory.instance.createDriverGetDeclaration(p))
 				]
 			),
 			factory.createExpressionStatement(
@@ -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)]),
+									NodeClassFactory.instance.createTypeReferenceNode('InstanceType', NodeClassFactory.instance.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 ?
+									NodeClassFactory.instance.createUnionTypeNode(
+										...[NodeClassFactory.instance.createLiteralTypeNode(nodeClassDef.id)].concat(
+											!nodeClassDef.equivalents || nodeClassDef.equivalents.length == 0 ? [] : nodeClassDef.equivalents?.map((p) => factory.createLiteralTypeNode(factory.createStringLiteral(p)))
+										)
+									)
+								:	NodeClassFactory.instance.createLiteralTypeNode(nodeClassDef.id)
+							)
+						]
 					),
+
 					factory.createFunctionDeclaration(
 						[factory.createToken(ts.SyntaxKind.ExportKeyword)],
 						undefined,
@@ -286,17 +336,66 @@ 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')
-									)
+						NodeClassFactory.instance.createBlock(
+							NodeClassFactory.instance.createReturnStatement(
+								factory.createCallExpression(
+									factory.createPropertyAccessExpression(
+										factory.createArrayLiteralExpression(
+											nodeClassDef.equivalents ?
+												[NodeClassFactory.instance.createStringLiteral(nodeClassDef.id)].concat(
+													!nodeClassDef.equivalents || nodeClassDef.equivalents.length == 0 ? [] : nodeClassDef.equivalents?.map((p) => factory.createStringLiteral(p))
+												)
+											:	[NodeClassFactory.instance.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,
+								NodeClassFactory.instance.createTypeReferenceNode(
+									'ISYNode',
+									NodeClassFactory.instance.createKeywordTypeNode(ts.SyntaxKind.AnyKeyword),
+									NodeClassFactory.instance.createKeywordTypeNode(ts.SyntaxKind.AnyKeyword),
+									NodeClassFactory.instance.createKeywordTypeNode(ts.SyntaxKind.AnyKeyword),
+									NodeClassFactory.instance.createKeywordTypeNode(ts.SyntaxKind.AnyKeyword)
+								),
+								undefined
+							)
+						],
+						factory.createTypePredicateNode(undefined, factory.createIdentifier('node'), factory.createTypeReferenceNode(factory.createIdentifier(`${nodeClassDef.name}Node`), undefined)),
+						NodeClassFactory.instance.createBlock(
+							true,
+
+							factory.createReturnStatement(
+								factory.createCallExpression(
+									factory.createPropertyAccessExpression(
+										factory.createArrayLiteralExpression(
+											nodeClassDef.implementedBy ?
+												[NodeClassFactory.instance.createStringLiteral(nodeClassDef.id)].concat(
+													!nodeClassDef.implementedBy || nodeClassDef.implementedBy.length == 0 ? [] : nodeClassDef.implementedBy?.map((p) => factory.createStringLiteral(p))
+												)
+											:	[NodeClassFactory.instance.createStringLiteral(nodeClassDef.id)]
+										),
+										'includes'
+									),
+									undefined,
+									[factory.createPropertyAccessExpression(factory.createIdentifier('node'), factory.createIdentifier('nodeDefId'))]
+								)
+							)
 						)
 					),
 					factory.createFunctionDeclaration(
@@ -343,13 +442,13 @@ export class NodeClassFactory {
 						[factory.createToken(ts.SyntaxKind.ExportKeyword)],
 						factory.createIdentifier('Commands'),
 						undefined,
-						factory.createTypeLiteralNode([...Object.values(nodeClassDef.commands).map(createCommandSignature)])
+						factory.createTypeLiteralNode([...Object.values(nodeClassDef.commands).map(NodeClassFactory.instance.createCommandSignature)])
 					),
 					factory.createTypeAliasDeclaration(
 						[factory.createToken(ts.SyntaxKind.ExportKeyword)],
 						factory.createIdentifier('Drivers'),
 						undefined,
-						factory.createTypeLiteralNode([...Object.values(nodeClassDef.drivers).map(createDriverSignature)])
+						factory.createTypeLiteralNode([...Object.values(nodeClassDef.drivers).map(NodeClassFactory.instance.createDriverSignature)])
 					)
 				]),
 				ts.NodeFlags.Namespace
@@ -396,164 +495,237 @@ export class NodeClassFactory {
 		let modules = [];
 		for (const family of NodeClassDefinition.Map.keys()) {
 			var t = this.generateClassesForFamily(family);
-			modules.push(buildClassIndex(family, t));
+			modules.push(NodeClassFactory.buildClassIndex(family, t));
 		}
 		return modules;
 	}
 
 	public static generateClassesForFamily<T extends Family>(family: T): GeneratedNodeClass<T>[] {
-		return this.buildNodeClasses<T>(NodeClassDefinition.Map.get(family) as { [x: string]: NodeClassDefinition<T> });
+		return NodeClassFactory.buildNodeClasses<T>(NodeClassDefinition.Map.get(family) as { [x: string]: NodeClassDefinition<T> });
 	}
 
-	// #endregion Public Static Methods (4)
-}
+	// #region Functions (12)
 
-// #endregion Classes (1)
+	static buildClassIndex<T extends Family>(family: T, classes: GeneratedNodeClass<T>[]) {
+		return {
+			family,
+			path: `/${Family[family]}/Generated/index.ts`,
+			statements: [...classes.map((p) => factory.createExportDeclaration(undefined, false, undefined, factory.createStringLiteral(`./${p.name}.js`), undefined))]
+		};
+	}
 
-// #region Functions (12)
+	createCommandArguments(def: CommandDefinition)
+	{
+		 let c = [
+				factory.createStringLiteral(def.id)];
+		let n = [];
+		let r = [];
 
-function buildClassIndex<T extends Family>(family: T, classes: GeneratedNodeClass<T>[]) {
-	return {
-		family,
-		path: `/${Family[family]}/Generated/index.ts`,
-		statements: [...classes.map((p) => factory.createExportDeclaration(undefined, false, undefined, factory.createStringLiteral(`./${p.name}.js`), undefined))]
-	};
-}
+		if(def.parameters)
+		{
+			for(let p in def.parameters)
+			{
+				let p2 = def.parameters[p];
+				if(!p2?.id || p2.id == 'value')
+				{
+					n.push(factory.createIdentifier(p2.name ?? 'value'))
+				}
+				else
+				{
+					r.push(p2);
+				}
+			}
+		}
+		let fnl = [...c,...n,
 
-function createCommandMethodDeclaration(def: CommandDefinition) {
-	return factory.createMethodDeclaration(
-		[factory.createToken(ts.SyntaxKind.AsyncKeyword)],
-		undefined,
-		factory.createIdentifier(def.name),
-		undefined,
-		undefined,
-
-		def.parameters ? Object.values(def.parameters).map(createParameterDeclarationSignature) : undefined,
-		undefined,
-		factory.createBlock(
-			[
-				factory.createReturnStatement(
-					factory.createCallExpression(factory.createPropertyAccessExpression(factory.createThis(), factory.createIdentifier('sendCommand')), undefined, [
-						factory.createStringLiteral(def.id),
-						...(def.parameters ?
-							[
-								factory.createObjectLiteralExpression(
-									[...Object.values(def.parameters).map((p) => factory.createPropertyAssignment(factory.createIdentifier(p.id ?? 'value'), factory.createIdentifier(p.name ?? 'value')))],
-									false
-								)
-							]
-						:	[])
-					])
-				)
-			],
-			true
-		)
-	);
-}
 
-function createCommandParameterType(def: DataTypeDefinition, parent: ParameterDefinition): ts.TypeNode {
-	if (def.enum) {
-		{
-			if (EnumDefinitionMap.has(parent.classDef.family)) {
-				var enumDef = EnumDefinitionMap.get(parent.classDef.family)[def.indexId];
+						...(r.length > 0 ? [factory.createObjectLiteralExpression(
+							r.map((q) => factory.createPropertyAssignment(factory.createIdentifier(q.id ?? 'value'), factory.createIdentifier(q.name ?? 'value'))),
+							false
+						)] : [])
 
-				// ?? EnumDefinitionMap[Family.Global]?[def.indexId]
-				if (enumDef) {
-					return factory.createTypeReferenceNode(factory.createQualifiedName(factory.createIdentifier(Family[parent.classDef.family]), factory.createIdentifier(enumDef.name)), undefined);
+
+			];
+		return fnl.length > 0 ? fnl : undefined;
+	}
+
+	createCommandMethodDeclaration(def: CommandDefinition) {
+		return factory.createMethodDeclaration(
+			[factory.createToken(ts.SyntaxKind.AsyncKeyword)],
+			undefined,
+			factory.createIdentifier(def.name),
+			undefined,
+			undefined,
+
+			def.parameters ? Object.values(def.parameters).map(NodeClassFactory.instance.createParameterDeclarationSignature.bind(this)) : undefined,
+			undefined,
+			factory.createBlock(
+				[factory.createReturnStatement(
+					factory.createCallExpression(factory.createPropertyAccessExpression(factory.createThis(), factory.createIdentifier('sendCommand')), undefined,NodeClassFactory.instance.createCommandArguments(def))
+				)]
+			)
+		);
+	}
+
+	createCommandParameterType(def: DataTypeDefinition, parent: ParameterDefinition): ts.TypeNode {
+		if (def.enum) {
+			{
+				if (EnumDefinitionMap.has(parent.classDef.family)) {
+					var enumDef = EnumDefinitionMap.get(parent.classDef.family)[def.indexId];
+
+					// ?? EnumDefinitionMap[Family.Global]?[def.indexId]
+					if (enumDef) {
+						return factory.createTypeReferenceNode(factory.createQualifiedName(factory.createIdentifier(Family[parent.classDef.family]), factory.createIdentifier(enumDef.name)), undefined);
+					}
 				}
-			}
 
-			if (def.values) {
-				return factory.createUnionTypeNode(Object.keys(def.values).map((p) => factory.createLiteralTypeNode(factory.createNumericLiteral(p))));
-			}
+				if (def.values) {
+					return NodeClassFactory.instance.createUnionTypeNode(...Object.keys(def.values).map((p) => factory.createLiteralTypeNode(factory.createNumericLiteral(p))));
+				}
 
-			//   return factory.createUnionTypeNode(
-			//     Object.values(def.values).map((p) => factory.createTypeReferenceNode(
-			//   factory.createQualifiedName(
-			//     factory.createIdentifier("UnitOfMeasure"),
-			//     factory.createIdentifier(UnitOfMeasure)
-			//   ),
-			//   undefined
-			// )))
+				//   return NodeClassFactory.instance.createUnionTypeNode(...
+				//     Object.values(def.values).map((p) => factory.createTypeReferenceNode(
+				//   factory.createQualifiedName(
+				//     factory.createIdentifier("UnitOfMeasure"),
+				//     factory.createIdentifier(UnitOfMeasure)
+				//   ),
+				//   undefined
+				// )))
+			}
 		}
+		return factory.createKeywordTypeNode(ts.SyntaxKind.NumberKeyword);
 	}
-	return factory.createKeywordTypeNode(ts.SyntaxKind.NumberKeyword);
-}
 
-function createCommandSignature(def: CommandDefinition) {
-	return factory.createPropertySignature(
-		undefined,
-		factory.createIdentifier(def.id),
-		undefined,
-		factory.createIntersectionTypeNode([
-			factory.createParenthesizedType(
-				factory.createFunctionTypeNode(
-					undefined,
-					def.parameters ? Object.values(def.parameters).map(createParameterSignature) : [],
+	createCommandSignature(def: CommandDefinition) {
+		const that = this;
+		return factory.createPropertySignature(
+			undefined,
+			factory.createIdentifier(def.id),
+			undefined,
+			factory.createIntersectionTypeNode([
+				factory.createParenthesizedType(
+					factory.createFunctionTypeNode(
+						undefined,
+						def.parameters ? Object.values(def.parameters).map(p => NodeClassFactory.instance.createParameterSignature(p)) : [],
 
-					factory.createTypeReferenceNode(factory.createIdentifier('Promise'), [factory.createKeywordTypeNode(ts.SyntaxKind.BooleanKeyword)])
-				)
-			),
-			factory.createTypeLiteralNode([
-				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)))
+						factory.createTypeReferenceNode(factory.createIdentifier('Promise'), [factory.createKeywordTypeNode(ts.SyntaxKind.BooleanKeyword)])
+					)
+				),
+				factory.createTypeLiteralNode([
+					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)))
+				])
 			])
-		])
-	);
-}
+		);
+	}
 
-function createDriverGetDeclaration(def: DriverDefinition) {
-	return factory.createGetAccessorDeclaration(
-		[factory.createToken(ts.SyntaxKind.PublicKeyword)],
-		factory.createIdentifier(def.name),
-		[],
-		factory.createUnionTypeNode(Object.values(def.dataType).map((p) => createDriverPropertyReturnType(p, def))),
-		factory.createBlock(
-			[
-				factory.createReturnStatement(
-					factory.createPropertyAccessChain(
-						factory.createPropertyAccessExpression(factory.createPropertyAccessExpression(factory.createThis(), factory.createIdentifier('drivers')), factory.createIdentifier(def.id)),
-						factory.createToken(ts.SyntaxKind.QuestionDotToken),
-						factory.createIdentifier('value')
+	createDriverGetDeclaration(def: DriverDefinition) {
+		return factory.createGetAccessorDeclaration(
+			[factory.createToken(ts.SyntaxKind.PublicKeyword)],
+			factory.createIdentifier(def.name),
+			[],
+			NodeClassFactory.instance.createUnionTypeNode(...Object.values(def.dataType).map((p) => NodeClassFactory.instance.createDriverPropertyReturnType(p, def))),
+			factory.createBlock(
+				[
+					factory.createReturnStatement(
+						factory.createPropertyAccessChain(
+							factory.createPropertyAccessExpression(factory.createPropertyAccessExpression(factory.createThis(), factory.createIdentifier('drivers')), factory.createIdentifier(def.id)),
+							factory.createToken(ts.SyntaxKind.QuestionDotToken),
+							factory.createIdentifier('value')
+						)
 					)
-				)
-			],
-			true
-		)
-	);
-}
+				],
+				true
+			)
+		);
+	}
+
+	createDriverInitializationStatement(def: DriverDefinition): ts.Statement {
+		return factory.createExpressionStatement(
+			factory.createBinaryExpression(
+				factory.createPropertyAccessExpression(factory.createPropertyAccessExpression(factory.createThis(), factory.createIdentifier('drivers')), factory.createIdentifier(def.id)),
+				factory.createToken(ts.SyntaxKind.EqualsToken),
+				factory.createCallExpression(factory.createPropertyAccessExpression(factory.createIdentifier('Driver'), factory.createIdentifier('create')), undefined, [
+					factory.createStringLiteral(def.id),
+					factory.createThis(),
+					factory.createAsExpression(
+						factory.createPropertyAccessExpression(factory.createIdentifier('nodeInfo'), factory.createIdentifier('property')),
+						factory.createTypeReferenceNode(factory.createIdentifier('DriverState'), undefined)
+					),
+					factory.createObjectLiteralExpression(
+						[
+							factory.createPropertyAssignment(
+								factory.createIdentifier('uom'),
+								factory.createPropertyAccessExpression(factory.createIdentifier('UnitOfMeasure'), factory.createIdentifier(UnitOfMeasure[parseInt(Object.keys(def.dataType)[0])] ?? 'Unknown'))
+							),
+							factory.createPropertyAssignment(factory.createIdentifier('label'), factory.createStringLiteral(def.label)),
+							factory.createPropertyAssignment(factory.createIdentifier('name'), factory.createStringLiteral(def.name))
+						],
+						false
+					)
+				])
+			)
+		);
+	}
+
+	createDriverPropertyReturnType(def: DataTypeDefinition, parent: DriverDefinition): ts.TypeNode {
+		if (def.enum) {
+			{
+				if (EnumDefinitionMap.has(parent.classDef.family)) {
+					var enumDef = EnumDefinitionMap.get(parent.classDef.family)[def.indexId];
+
+					// ?? EnumDefinitionMap[Family.Global]?[def.indexId]
+					if (enumDef) {
+						return factory.createTypeReferenceNode(factory.createQualifiedName(factory.createIdentifier(Family[parent.classDef.family]), factory.createIdentifier(enumDef.name)), undefined);
+					}
+				}
+				if (def.values) {
+					return NodeClassFactory.instance.createUnionTypeNode(...Object.keys(def.values).map((p) => factory.createLiteralTypeNode(factory.createNumericLiteral(p))));
+				}
+
+				//   return NodeClassFactory.instance.createUnionTypeNode(...
+				//     Object.values(def.values).map((p) => factory.createTypeReferenceNode(
+				//   factory.createQualifiedName(
+				//     factory.createIdentifier("UnitOfMeasure"),
+				//     factory.createIdentifier(UnitOfMeasure)
+				//   ),
+				//   undefined
+				// )))
+			}
+		}
+		return factory.createKeywordTypeNode(ts.SyntaxKind.NumberKeyword);
+	}
 
-function createDriverInitializationStatement(def: DriverDefinition): ts.Statement {
-	return factory.createExpressionStatement(
-		factory.createBinaryExpression(
-			factory.createPropertyAccessExpression(factory.createPropertyAccessExpression(factory.createThis(), factory.createIdentifier('drivers')), factory.createIdentifier(def.id)),
-			factory.createToken(ts.SyntaxKind.EqualsToken),
-			factory.createCallExpression(factory.createPropertyAccessExpression(factory.createIdentifier('Driver'), factory.createIdentifier('create')), undefined, [
-				factory.createStringLiteral(def.id),
-				factory.createThis(),
-				factory.createAsExpression(
-					factory.createPropertyAccessExpression(factory.createIdentifier('nodeInfo'), factory.createIdentifier('property')),
-					factory.createTypeReferenceNode(factory.createIdentifier('DriverState'), undefined)
+	createDriverSignature(def: DriverDefinition) {
+		return factory.createPropertySignature(
+			undefined,
+			factory.createIdentifier(def.id),
+			undefined,
+			factory.createTypeLiteralNode([
+				factory.createPropertySignature(
+					undefined,
+					factory.createIdentifier('uom'),
+					undefined,
+					def.dataType ?
+						NodeClassFactory.instance.createUnionTypeNode(...Object.values(def.dataType).map((p) => NodeClassFactory.instance.createTypeNodeForUOM(p.uom)))
+					:	factory.createKeywordTypeNode(ts.SyntaxKind.NumberKeyword)
 				),
-				factory.createObjectLiteralExpression(
-					[
-						factory.createPropertyAssignment(
-							factory.createIdentifier('uom'),
-							factory.createPropertyAccessExpression(factory.createIdentifier('UnitOfMeasure'), factory.createIdentifier(UnitOfMeasure[parseInt(Object.keys(def.dataType)[0])] ?? 'Unknown'))
-						),
-						factory.createPropertyAssignment(factory.createIdentifier('label'), factory.createStringLiteral(def.label)),
-						factory.createPropertyAssignment(factory.createIdentifier('name'), factory.createStringLiteral(def.name))
-					],
-					false
-				)
+				factory.createPropertySignature(
+					undefined,
+					factory.createIdentifier('value'),
+					undefined,
+					def.dataType ?
+						NodeClassFactory.instance.createUnionTypeNode(...Object.values(def.dataType).map((p) => NodeClassFactory.instance.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)))
 			])
-		)
-	);
-}
+		);
+	}
 
-function createDriverPropertyReturnType(def: DataTypeDefinition, parent: DriverDefinition): ts.TypeNode {
-	if (def.enum) {
-		{
+	createDriverSignatureReturnType(def: DataTypeDefinition, parent: DriverDefinition): ts.TypeNode {
+		if (def.enum) {
 			if (EnumDefinitionMap.has(parent.classDef.family)) {
 				var enumDef = EnumDefinitionMap.get(parent.classDef.family)[def.indexId];
 
@@ -563,87 +735,44 @@ 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(
-			//     Object.values(def.values).map((p) => factory.createTypeReferenceNode(
-			//   factory.createQualifiedName(
-			//     factory.createIdentifier("UnitOfMeasure"),
-			//     factory.createIdentifier(UnitOfMeasure)
-			//   ),
-			//   undefined
-			// )))
 		}
+		return factory.createKeywordTypeNode(ts.SyntaxKind.NumberKeyword);
 	}
-	return factory.createKeywordTypeNode(ts.SyntaxKind.NumberKeyword);
-}
 
-function createDriverSignature(def: DriverDefinition) {
-	return factory.createPropertySignature(
-		undefined,
-		factory.createIdentifier(def.id),
-		undefined,
-		factory.createTypeLiteralNode([
-			factory.createPropertySignature(
-				undefined,
-				factory.createIdentifier('uom'),
-				undefined,
-				def.dataType ? factory.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)
-			),
-			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)))
-		])
-	);
-}
-
-function createDriverSignatureReturnType(def: DataTypeDefinition, parent: DriverDefinition): ts.TypeNode {
-	if (def.enum) {
-		if (EnumDefinitionMap.has(parent.classDef.family)) {
-			var enumDef = EnumDefinitionMap.get(parent.classDef.family)[def.indexId];
-
-			// ?? EnumDefinitionMap[Family.Global]?[def.indexId]
-			if (enumDef) {
-				return factory.createTypeReferenceNode(factory.createQualifiedName(factory.createIdentifier(Family[parent.classDef.family]), factory.createIdentifier(enumDef.name)), undefined);
-			}
-		}
-		if (def.values) {
-			return factory.createUnionTypeNode(Object.keys(def.values).map((p) => factory.createLiteralTypeNode(factory.createNumericLiteral(p))));
-		}
+	createParameterDeclarationSignature(def: ParameterDefinition) {
+		return factory.createParameterDeclaration(
+			undefined,
+			undefined,
+			factory.createIdentifier(def.name ?? 'value'),
+			def.optional ? factory.createToken(ts.SyntaxKind.QuestionToken) : undefined,
+			def.dataType ?
+				NodeClassFactory.instance.createUnionTypeNode(...Object.values(def.dataType).map((p) => NodeClassFactory.instance.createCommandParameterType(p, def)))
+			:	factory.createKeywordTypeNode(ts.SyntaxKind.NumberKeyword),
+			undefined
+		);
 	}
-	return factory.createKeywordTypeNode(ts.SyntaxKind.NumberKeyword);
-}
 
-function createParameterDeclarationSignature(def: ParameterDefinition) {
-	return factory.createParameterDeclaration(
-		undefined,
-		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),
-		undefined
-	);
-}
+	createParameterSignature(def: ParameterDefinition) {
+		return factory.createParameterDeclaration(
+			undefined,
+			undefined,
+			factory.createIdentifier(def.id ?? 'value'),
+			def.optional ? factory.createToken(ts.SyntaxKind.QuestionToken) : undefined,
+			def.dataType ?
+				NodeClassFactory.instance.createUnionTypeNode(...Object.values(def.dataType).map((p) => NodeClassFactory.instance.createCommandParameterType(p, def)))
+			:	factory.createKeywordTypeNode(ts.SyntaxKind.NumberKeyword),
+			undefined
+		);
+	}
 
-function createParameterSignature(def: ParameterDefinition) {
-	return factory.createParameterDeclaration(
-		undefined,
-		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),
-		undefined
-	);
-}
+	createTypeNodeForUOM(uom: number): ts.TypeNode {
+		return NodeClassFactory.instance.createTypeReferenceNode(UnitOfMeasure[uom] ?? 'Unknown', 'UnitOfMeasure');
+	}
 
-function createTypeNodeForUOM(uom: number): ts.TypeNode {
-	return factory.createTypeReferenceNode(factory.createQualifiedName(factory.createIdentifier('UnitOfMeasure'), factory.createIdentifier(UnitOfMeasure[uom] ?? 'Unknown')));
+	// #endregion Public Static Methods (4)
 }
 
+// #endregion Classes (1)
 // #endregion Functions (12)