Refactor th_helpers.js and fix 'extend' method handling

Author: vmutafov

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

@@ -1,6 +1,6 @@
 describe("Tests extended classes ", function () {
 
-	it("Instance_with_no_extension_shouldnt_use_previously_defined_implementation_object", function () {
+	it("Instance with no extension shouldn't use previously defined implementation object", function () {
 		var MyButton = com.tns.tests.Button1.extend({
 			toString: function () {
 				return "overriden toString method of chronometer instance";
@@ -21,8 +21,56 @@ describe("Tests extended classes ", function () {
 		expect(labelToString).not.toBe(labelToString1);
 		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 (){
+
+        /*  JS below the comment is generated from the following TS code
+
+        class Base{
+            static extend(){
+                return "expectedValue";
+            }
+        }
+
+        class Child extends Base{}
+
+        const superProto = Object.getPrototypeOf(Child.prototype)
+        const Super = superProto.constructor;
+        Super.extend();
+
+        var child = Object.create(Child);
+        child.extend();
+        Child.extend();
+
+        */
+
+        var Base = /** @class */ (function () {
+            function Base() {
+            }
+            Base.extend = function () {
+                return "expectedValue";
+            };
+            return Base;
+        }());
+        var Child = /** @class */ (function (_super) {
+            __extends(Child, _super);
+            function Child() {
+                return _super !== null && _super.apply(this, arguments) || this;
+            }
+            return Child;
+        }(Base));
+
+        var superProto = Object.getPrototypeOf(Child.prototype);
+        var Super = superProto.constructor;
+        expect(Super.extend()).toBe("expectedValue");
+
+        var child = Object.create(Child);
+        expect(child.extend()).toBe("expectedValue");
+
+        expect(Child.extend()).toBe("expectedValue");
+	});
 
-	it("Instance_with_extension_shouldnt_use_previously_defined_implementation_object", function () {
+	it("Instance with extension shouldn't use previously defined implementation object", function () {
 
 		var MyButton = com.tns.tests.Button1.extend({
 			toString: function () {
@@ -53,7 +101,7 @@ describe("Tests extended classes ", function () {
 		expect(labelgetIMAGE_ID_PROP).not.toBe(labelgetIMAGE_ID_PROP1);
 	});
 
-	it("Newly_created_instances_should_behave_the_same_and_not_use_previously_defined_implementation_objects", function () {
+	it("Newly created instances should behave the same and not use previously defined implementation objects", function () {
 
 		var button1 = new com.tns.tests.Button1();
 		var labelgetIMAGE_ID_PROP1 = button1.getIMAGE_ID_PROP();
@@ -74,7 +122,7 @@ describe("Tests extended classes ", function () {
 		expect(labelgetIMAGE_ID_PROP1).toBe(labelgetIMAGE_ID_PROP2);
 	});
 
-	it("should not crash with no exception when incorrectly calling extended class constructor", function () {
+	it("Should not crash with no exception when incorrectly calling extended class constructor", function () {
 	    let MyObj = java.lang.Object.extend({
                         toString: () => { return "It's MyObj" }
                     });

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

@@ -1,24 +1,4 @@
 (function() {
-	var __extends_ns = function (d, b) {
-		if (!b.extend) {
-			for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
-		}
-
-		function __() { this.constructor = d; }
-		__.prototype = b.prototype;
-		d.prototype = new __();
-	};
-
-	var extendStatics = Object.setPrototypeOf ||
-        ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
-        function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
-
-	var __extends_ts = function (d, b) {
-        extendStatics(d, b);
-        function __() { this.constructor = d; }
-        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
-    };
-
 
 	var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
 		var c = arguments.length;
@@ -70,7 +50,8 @@
 	};
 
 	var __extends = function(Child, Parent) {
-		var extendNativeClass = !!Parent.extend && /native/.test(Parent.extend.toString());
+		const NATIVE_CODE_REGEX = /\{\s*\[native code\]\s*\}/g;
+		var extendNativeClass = !!Parent.extend && NATIVE_CODE_REGEX.test(Parent.extend.toString());
 		if (!extendNativeClass)	{
 			__extends_ts(Child, Parent);
 			return;
@@ -131,6 +112,50 @@
 		Child.prototype.__child = Child;
 	}
 
+	var __extends_ts = function (child, parent) {
+		extendStaticFunctions(child, parent);
+		assignPrototypeFromParentToChild(parent, child);
+	};
+
+	var __extends_ns = function (child, parent) {
+		if (!parent.extend) {
+			assignPropertiesFromParentToChild(parent, child);
+		}
+
+		assignPrototypeFromParentToChild(parent, child);
+	};
+
+	var extendStaticFunctions =
+			Object.setPrototypeOf
+        	|| (hasInternalProtoProperty() && function (child, parent) { child.__proto__ = parent; })
+         	|| assignPropertiesFromParentToChild;
+
+	function hasInternalProtoProperty(){
+		return { __proto__: [] } instanceof Array;
+	}
+
+	function assignPropertiesFromParentToChild(parent, child){
+		for (var property in parent){
+			if (parent.hasOwnProperty(property)) {
+				child[property] = parent[property];
+			}
+		}
+	}
+
+	function assignPrototypeFromParentToChild(parent, child){
+		function __() {
+			this.constructor = child;
+		}
+
+		if(parent === null){
+			child.prototype = Object.create(null);
+		} else {
+			__.prototype = parent.prototype;
+		child.prototype = new __();
+		}
+	}
+
+
 	function JavaProxy(className) {
 		return function (target) {
 			var extended = target.extend(className, target.prototype)