Improve test of extending logic and format code

Author: vmutafov

test-app/app/src/main/assets/app/tests/extendedClassesTests.js

@@ -22,25 +22,30 @@ describe("Tests extended classes ", function () {
 		expect(labelgetIMAGE_ID_PROP).not.toBe(labelgetIMAGE_ID_PROP1);
 	});
 
-	it("Having a class with static method named 'extend' and overriding it in a child class shouldn't  crash the app", function (){
+	it("Having a class with static method named 'extend' and extending it in a child class shouldn't crash the app", function (){
 
         /*  JS below the comment is generated from the following TS code
 
-        class Base{
-            static extend(){
-                return "expectedValue";
+            class Base{
+                static extend(){
+                    return "expectedValue";
+                }
+            }
+            class Child extends Base{
             }
-        }
 
-        class Child extends Base{}
+            class SecondChild extends Child{
+            }
 
-        const superProto = Object.getPrototypeOf(Child.prototype)
-        const Super = superProto.constructor;
-        Super.extend();
 
-        var child = Object.create(Child);
-        child.extend();
-        Child.extend();
+            const superProto = Object.getPrototypeOf(Child.prototype)
+            const Super = superProto.constructor;
+            //console.log(Super.extend());
+
+            var child = Object.create(Child);
+            //console.log(child.extend());
+
+            //console.log(Child.extend());
 
         */
 
@@ -59,6 +64,13 @@ describe("Tests extended classes ", function () {
             }
             return Child;
         }(Base));
+        var SecondChild = /** @class */ (function (_super) {
+            __extends(SecondChild, _super);
+            function SecondChild() {
+                return _super !== null && _super.apply(this, arguments) || this;
+            }
+            return SecondChild;
+        }(Child));
 
         var superProto = Object.getPrototypeOf(Child.prototype);
         var Super = superProto.constructor;

test-app/app/src/main/assets/internal/ts_helpers.js

@@ -1,4 +1,4 @@
-(function() {
+(function () {
 
 	var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
 		var c = arguments.length;
@@ -18,45 +18,43 @@
 	};
 
 	// For backward compatibility.
-	var __native = function(thiz) {
-	    // we are setting the __container__ property to the base class when the super method is called
-    	// if the constructor returns the __native(this) call we will use the old implementation
-    	// copying all the properties to the result
-    	// otherwise if we are using the result from the super() method call we won't need such logic
-    	// as thiz already contains the parent properties
-    	// this way we now support both implementations in typescript generated constructors:
-    	// 1: super(); return __native(this);
-    	// 2: return super() || this;
-	    if(thiz.__container__) {
-            var result = thiz.__proto__;
-
-            for (var prop in thiz)
-            {
-                if (thiz.hasOwnProperty(prop))
-                {
-                    thiz.__proto__[prop] = thiz[prop];
-                    delete thiz[prop];
-                }
-            }
-
-            thiz.constructor = undefined;
-            thiz.__proto__ = undefined;
-            Object.freeze(thiz);
-            Object.preventExtensions(thiz);
-            return result;
+	var __native = function (thiz) {
+		// we are setting the __container__ property to the base class when the super method is called
+		// if the constructor returns the __native(this) call we will use the old implementation
+		// copying all the properties to the result
+		// otherwise if we are using the result from the super() method call we won't need such logic
+		// as thiz already contains the parent properties
+		// this way we now support both implementations in typescript generated constructors:
+		// 1: super(); return __native(this);
+		// 2: return super() || this;
+		if (thiz.__container__) {
+			var result = thiz.__proto__;
+
+			for (var prop in thiz) {
+				if (thiz.hasOwnProperty(prop)) {
+					thiz.__proto__[prop] = thiz[prop];
+					delete thiz[prop];
+				}
+			}
+
+			thiz.constructor = undefined;
+			thiz.__proto__ = undefined;
+			Object.freeze(thiz);
+			Object.preventExtensions(thiz);
+			return result;
 		} else {
-            return thiz;
+			return thiz;
 		}
 	};
 
-	var __extends = function(Child, Parent) {
+	var __extends = function (Child, Parent) {
 		const NATIVE_CODE_REGEX = /\{\s*\[native code\]\s*\}/g;
 		var extendNativeClass = !!Parent.extend && NATIVE_CODE_REGEX.test(Parent.extend.toString());
-		if (!extendNativeClass)	{
+		if (!extendNativeClass) {
 			__extends_ts(Child, Parent);
 			return;
 		}
-		if	(Parent.__isPrototypeImplementationObject) {
+		if (Parent.__isPrototypeImplementationObject) {
 			throw new Error("Can not extend an already extended native object.");
 		}
 
@@ -66,41 +64,37 @@
 				var parent = thiz.__proto__.__parent;
 				child.__extended = parent.extend(child.name, child.prototype, true);
 				// This will deal with "i instanceof child"
-				child[Symbol.hasInstance] = function(instance) {
+				child[Symbol.hasInstance] = function (instance) {
 					return instance instanceof this.__extended;
 				}
 			}
 			return child.__extended;
 		};
 
-		Parent.__activityExtend = function(parent, name, implementationObject) {
+		Parent.__activityExtend = function (parent, name, implementationObject) {
 			__log("__activityExtend called");
 			return parent.extend(name, implementationObject);
 		};
 
-		Parent.call = function(thiz) {
+		Parent.call = function (thiz) {
 			var Extended = extend(thiz);
 			thiz.__container__ = true;
-			if (arguments.length > 1)
-			{
+			if (arguments.length > 1) {
 				thiz.__proto__ = new (Function.prototype.bind.apply(Extended, [null].concat(Array.prototype.slice.call(arguments, 1))));
 			}
-			else
-			{
+			else {
 				thiz.__proto__ = new Extended()
 			}
 			return thiz.__proto__;
 		};
 
-		Parent.apply = function(thiz, args) {
+		Parent.apply = function (thiz, args) {
 			var Extended = extend(thiz);
 			thiz.__container__ = true;
-			if (args && args.length > 0)
-			{
+			if (args && args.length > 0) {
 				thiz.__proto__ = new (Function.prototype.bind.apply(Extended, [null].concat(args)));
 			}
-			else
-			{
+			else {
 				thiz.__proto__ = new Extended();
 			}
 			return thiz.__proto__;
@@ -126,32 +120,32 @@
 	};
 
 	var extendStaticFunctions =
-			Object.setPrototypeOf
-        	|| (hasInternalProtoProperty() && function (child, parent) { child.__proto__ = parent; })
-         	|| assignPropertiesFromParentToChild;
+		Object.setPrototypeOf
+		|| (hasInternalProtoProperty() && function (child, parent) { child.__proto__ = parent; })
+		|| assignPropertiesFromParentToChild;
 
-	function hasInternalProtoProperty(){
+	function hasInternalProtoProperty() {
 		return { __proto__: [] } instanceof Array;
 	}
 
-	function assignPropertiesFromParentToChild(parent, child){
-		for (var property in parent){
+	function assignPropertiesFromParentToChild(parent, child) {
+		for (var property in parent) {
 			if (parent.hasOwnProperty(property)) {
 				child[property] = parent[property];
 			}
 		}
 	}
 
-	function assignPrototypeFromParentToChild(parent, child){
+	function assignPrototypeFromParentToChild(parent, child) {
 		function __() {
 			this.constructor = child;
 		}
 
-		if(parent === null){
+		if (parent === null) {
 			child.prototype = Object.create(null);
 		} else {
 			__.prototype = parent.prototype;
-		child.prototype = new __();
+			child.prototype = new __();
 		}
 	}
 
@@ -166,7 +160,7 @@
 
 	function Interfaces(interfacesArr) {
 		return function (target) {
-			if(interfacesArr instanceof Array) {
+			if (interfacesArr instanceof Array) {
 				// attach interfaces: [] to the object
 				target.prototype.interfaces = interfacesArr;
 			}