Merge pull request #11 from timocov/ctor-params

Added handling constructor parameters

src/properties-minifier.ts

@@ -42,17 +42,41 @@ export class PropertiesMinifier {
 	}
 
 	private visitNode(node: ts.Node, program: ts.Program): ts.Node {
-		if (isClassMember(node) && isPrivateNonStaticMember(node)) {
+		if (isClassMember(node) && isPrivateNonStatic(node)) {
 			return this.createNewClassMember(node, program);
 		} else if (isAccessExpression(node)) {
 			return this.createNewAccessExpression(node, program);
 		} else if (ts.isBindingElement(node)) {
 			return this.createNewBindingElement(node, program);
+		} else if (isConstructorParameter(node) && isPrivateNonStatic(node)) {
+			return this.createNewConstructorParameter(node, program);
 		}
 
 		return node;
 	}
 
+	private createNewConstructorParameter(oldParameter: ts.ParameterDeclaration, program: ts.Program): ts.ParameterDeclaration {
+		if (!ts.isIdentifier(oldParameter.name)) {
+			return oldParameter;
+		}
+
+		return this.createNewNode(
+			program,
+			oldParameter.name,
+			(newName: string) => {
+				return ts.createParameter(
+					oldParameter.decorators,
+					oldParameter.modifiers,
+					oldParameter.dotDotDotToken,
+					newName,
+					oldParameter.questionToken,
+					oldParameter.type,
+					oldParameter.initializer
+				);
+			}
+		);
+	}
+
 	private createNewClassMember(oldMember: ClassMember, program: ts.Program): ClassMember {
 		let creator: NodeCreator<ClassMember>;
 
@@ -191,11 +215,11 @@ export class PropertiesMinifier {
 	}
 }
 
-function isPrivateNonStaticMember(node: ClassMember): boolean {
+function isPrivateNonStatic(node: ClassMember | ts.ParameterDeclaration): boolean {
 	return hasPrivateKeyword(node) && !hasModifier(node, ts.SyntaxKind.StaticKeyword);
 }
 
-function hasPrivateKeyword(node: ClassMember): boolean {
+function hasPrivateKeyword(node: ClassMember | ts.ParameterDeclaration): boolean {
 	return hasModifier(node, ts.SyntaxKind.PrivateKeyword);
 }
 
@@ -215,6 +239,10 @@ function isClassMember(node: ts.Node): node is ClassMember {
 	return ts.isMethodDeclaration(node) || ts.isPropertyDeclaration(node);
 }
 
+function isConstructorParameter(node: ts.Node): node is ts.ParameterDeclaration {
+	return ts.isParameter(node) && ts.isConstructorDeclaration(node.parent as ts.Node);
+}
+
 function getClassName(classNode: ts.ClassLikeDeclaration): string {
 	if (classNode.name === undefined) {
 		return 'anonymous class';
@@ -229,5 +257,7 @@ function isPrivateNonStaticClassMember(symbol: ts.Symbol | undefined): boolean {
 		return false;
 	}
 
-	return symbol.declarations.some((x: ts.Declaration) => isClassMember(x) && isPrivateNonStaticMember(x));
+	return symbol.declarations.some((x: ts.Declaration) => {
+		return (isClassMember(x) || isConstructorParameter(x)) && isPrivateNonStatic(x);
+	});
 }

tests/test-cases/declaring-members-in-ctor-params/input.ts

@@ -0,0 +1,11 @@
+export class Class {
+	public constructor(
+		public publicField: number,
+		protected protectedField: number,
+		private privateField: number
+	) {}
+
+	public method(): void {
+		console.log(this.publicField, this.protectedField, this.privateField);
+	}
+}

tests/test-cases/declaring-members-in-ctor-params/output.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var Class = /** @class */ (function () {
+    function Class(publicField, protectedField, _private_privateField) {
+        this.publicField = publicField;
+        this.protectedField = protectedField;
+        this._private_privateField = _private_privateField;
+    }
+    Class.prototype.method = function () {
+        console.log(this.publicField, this.protectedField, this._private_privateField);
+    };
+    return Class;
+}());
+exports.Class = Class;