kecubung - npm Package Compare versions

Comparing version 0.4.0 to 0.5.0-alpha.695401af

lib/analyzers/astree/child-decorator-analyzer.js

 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-var H = require("./helper");
-var ChildDecoratorAnalyzer = (function () {
-    function ChildDecoratorAnalyzer(node) {
+const H = require("./helper");
+class ChildDecoratorAnalyzer {
+    constructor(node) {
         this.node = node;
     }
-    ChildDecoratorAnalyzer.prototype.isMethodDecorator = function () {
+    isMethodDecorator() {
         return !H.isReservedDecorator(this.node);
-    };
-    ChildDecoratorAnalyzer.prototype.isParameterDecorator = function () {
+    }
+    isParameterDecorator() {
         return H.getMethodNameFromCallee(this.node.callee) == "__param";
-    };
-    ChildDecoratorAnalyzer.prototype.getMethodName = function () {
+    }
+    getMethodName() {
         return H.getMethodNameFromCallee(this.node.callee);
-    };
-    ChildDecoratorAnalyzer.prototype.getMethodLocation = function () {
+    }
+    getMethodLocation() {
         return {
@@ -22,10 +22,10 @@ start: this.node.start,
         };
-    };
-    ChildDecoratorAnalyzer.prototype.getMethodParameters = function () {
-        return this.node.arguments.map(function (x) { return H.getDecoratorParameterName(x); });
-    };
-    ChildDecoratorAnalyzer.prototype.getParameterDecoratorName = function () {
+    }
+    getMethodParameters() {
+        return this.node.arguments.map((x) => H.getDecoratorParameterName(x));
+    }
+    getParameterDecoratorName() {
         return H.getMethodNameFromCallee(this.node.arguments[1].callee);
-    };
-    ChildDecoratorAnalyzer.prototype.getParameterDecoratorLocation = function () {
+    }
+    getParameterDecoratorLocation() {
         return {
@@ -35,9 +35,8 @@ start: this.node.start,
         };
-    };
-    ChildDecoratorAnalyzer.prototype.getParameterDecoratorParameters = function () {
+    }
+    getParameterDecoratorParameters() {
         return this.node.arguments[1].arguments
-            .map(function (x) { return H.getDecoratorParameterName(x); });
-    };
-    return ChildDecoratorAnalyzer;
-}());
+            .map((x) => H.getDecoratorParameterName(x));
+    }
+}
 exports.ChildDecoratorAnalyzer = ChildDecoratorAnalyzer;

lib/analyzers/astree/class-analyzer.js

 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-var core_1 = require("../../core");
-var ClassAnalyzer = (function () {
+const core_1 = require("../../core");
+class ClassAnalyzer {
     /**
      * expect VariableDeclaration, ExpressionStatement
      */
-    function ClassAnalyzer(node) {
+    constructor(node) {
         this.node = node;
@@ -14,8 +14,8 @@ }
      */
-    ClassAnalyzer.prototype.isExported = function (name, parentName) {
+    isExported(name, parentName) {
         return this.isExportedStatement()
             && (this.node.expression.left.object.name == parentName || this.node.expression.left.object.name == "exports")
             && this.node.expression.right.name == name;
-    };
-    ClassAnalyzer.prototype.getLocation = function () {
+    }
+    getLocation() {
         return {
@@ -25,11 +25,11 @@ start: this.node.start,
         };
-    };
+    }
     //constructors & methods
-    ClassAnalyzer.prototype.getMember = function () {
+    getMember() {
         return this.node.declarations[0].init.callee.body.body;
-    };
+    }
     /**
      * expect ExpressionStatement
      */
-    ClassAnalyzer.prototype.isExportedStatement = function () {
+    isExportedStatement() {
         return this.node.type == core_1.SyntaxKind.ExpressionStatement
@@ -39,4 +39,4 @@ && this.node.expression.type == core_1.SyntaxKind.AssignmentExpression
             && this.node.expression.right.type == core_1.SyntaxKind.Identifier;
-    };
-    ClassAnalyzer.prototype.getName = function () {
+    }
+    getName() {
         if (this.isExportedStatement())
@@ -48,4 +48,4 @@ return this.node.expression.right.name;
             return null;
-    };
-    ClassAnalyzer.prototype.getParentName = function () {
+    }
+    getParentName() {
         if (this.isExportedStatement())
@@ -55,4 +55,4 @@ return this.node.expression.left.object.name;
             return null;
-    };
-    ClassAnalyzer.prototype.isCandidate = function () {
+    }
+    isCandidate() {
         return this.node.type == core_1.SyntaxKind.VariableDeclaration
@@ -65,4 +65,4 @@ && this.node.declarations[0].type == core_1.SyntaxKind.VariableDeclarator
             && this.node.declarations[0].init.callee.id == null;
-    };
-    ClassAnalyzer.prototype.getBaseClass = function () {
+    }
+    getBaseClass() {
         if (this.isCandidate() && this.node.declarations[0].init.arguments.length > 0) {
@@ -75,5 +75,4 @@ if (this.node.declarations[0].init.arguments[0].type == core_1.SyntaxKind.MemberExpression)
         return null;
-    };
-    return ClassAnalyzer;
-}());
+    }
+}
 exports.ClassAnalyzer = ClassAnalyzer;

lib/analyzers/astree/constructor-analyser.js

 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-var Core = require("../../core");
-var ConstructorAnalyzer = (function () {
-    function ConstructorAnalyzer(node) {
+const Core = require("../../core");
+class ConstructorAnalyzer {
+    constructor(node) {
         this.node = node;
     }
-    ConstructorAnalyzer.prototype.isConstructor = function (className) {
+    isConstructor(className) {
         return this.node.type == Core.SyntaxKind.FunctionDeclaration
             && this.node.id.name == className;
-    };
-    ConstructorAnalyzer.prototype.getName = function () {
+    }
+    getName() {
         return this.node.id.name;
-    };
-    ConstructorAnalyzer.prototype.getLocation = function () {
+    }
+    getLocation() {
         return {
@@ -20,8 +20,7 @@ start: this.node.start,
         };
-    };
-    ConstructorAnalyzer.prototype.getParameters = function () {
+    }
+    getParameters() {
         return this.node.params;
-    };
-    return ConstructorAnalyzer;
-}());
+    }
+}
 exports.ConstructorAnalyzer = ConstructorAnalyzer;

lib/analyzers/astree/decorator-analyzer.js

 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-var core_1 = require("../../core");
-var HP = require("./helper");
-var DecoratorAnalyzer = (function () {
-    function DecoratorAnalyzer(node) {
+const core_1 = require("../../core");
+const HP = require("./helper");
+class DecoratorAnalyzer {
+    constructor(node) {
         this.node = node;
     }
-    DecoratorAnalyzer.prototype.isMethodDecorator = function () {
+    isMethodDecorator() {
         return this.node.type == core_1.SyntaxKind.ExpressionStatement
@@ -14,4 +14,4 @@ && HP.getMethodNameFromCallee(this.node.expression.callee) == "__decorate"
             && this.node.expression.arguments[3].type == core_1.SyntaxKind.NullLiteral;
-    };
-    DecoratorAnalyzer.prototype.isPropertyDecorator = function () {
+    }
+    isPropertyDecorator() {
         return this.node.type == core_1.SyntaxKind.ExpressionStatement
@@ -21,4 +21,4 @@ && HP.getMethodNameFromCallee(this.node.expression.callee) == "__decorate"
             && this.node.expression.arguments[3].type == core_1.SyntaxKind.UnaryExpression;
-    };
-    DecoratorAnalyzer.prototype.getClassName = function () {
+    }
+    getClassName() {
         if (this.isMethodDecorator() || this.isPropertyDecorator())
@@ -31,4 +31,4 @@ return this.node.expression.arguments[1].object.name;
             return null;
-    };
-    DecoratorAnalyzer.prototype.getMethodName = function () {
+    }
+    getMethodName() {
         if (this.isMethodDecorator() || this.isPropertyDecorator())
@@ -38,4 +38,4 @@ return this.node.expression.arguments[2].value;
             return null;
-    };
-    DecoratorAnalyzer.prototype.getChildren = function () {
+    }
+    getChildren() {
         if (this.isClassDecorator())
@@ -45,4 +45,4 @@ return this.node.expression.right.arguments[0].elements;
             return this.node.expression.arguments[0].elements;
-    };
-    DecoratorAnalyzer.prototype.isClassDecorator = function () {
+    }
+    isClassDecorator() {
         return this.node.type == core_1.SyntaxKind.ExpressionStatement
@@ -53,5 +53,4 @@ && this.node.expression.type == core_1.SyntaxKind.AssignmentExpression
             && HP.getMethodNameFromCallee(this.node.expression.right.callee) == "__decorate";
-    };
-    return DecoratorAnalyzer;
-}());
+    }
+}
 exports.DecoratorAnalyzer = DecoratorAnalyzer;

lib/analyzers/astree/es6-class-analyzer.js

 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-var tslib_1 = require("tslib");
-var core_1 = require("../../core");
-var class_analyzer_1 = require("./class-analyzer");
-var Es6ClassAnalyzer = (function (_super) {
-    tslib_1.__extends(Es6ClassAnalyzer, _super);
+const core_1 = require("../../core");
+const class_analyzer_1 = require("./class-analyzer");
+class Es6ClassAnalyzer extends class_analyzer_1.ClassAnalyzer {
     /**
      * expect VariableDeclaration, ExpressionStatement
      */
-    function Es6ClassAnalyzer(node) {
-        return _super.call(this, node) || this;
-    }
+    constructor(node) { super(node); }
     //constructors & methods
-    Es6ClassAnalyzer.prototype.getMember = function () {
+    getMember() {
         if (this.isClass())
@@ -20,4 +16,4 @@ return this.node.body.body;
             return this.node.declarations[0].init.body.body;
-    };
-    Es6ClassAnalyzer.prototype.getName = function () {
+    }
+    getName() {
         if (this.isClass())
@@ -27,15 +23,15 @@ return this.node.id.name;
             return this.node.declarations[0].init.id.name;
-    };
-    Es6ClassAnalyzer.prototype.isClass = function () {
+    }
+    isClass() {
         return this.node.type == core_1.SyntaxKind.ClassDeclaration;
-    };
-    Es6ClassAnalyzer.prototype.isVariableDeclaration = function () {
+    }
+    isVariableDeclaration() {
         return this.node.type == core_1.SyntaxKind.VariableDeclaration &&
             this.node.declarations[0].init &&
             this.node.declarations[0].init.type == core_1.SyntaxKind.ClassExpression;
-    };
-    Es6ClassAnalyzer.prototype.isCandidate = function () {
+    }
+    isCandidate() {
         return this.isClass() || this.isVariableDeclaration();
-    };
-    Es6ClassAnalyzer.prototype.getBaseClassSimple = function () {
+    }
+    getBaseClassSimple() {
         if (!this.node.superClass)
@@ -47,4 +43,4 @@ return;
             return this.node.superClass.name;
-    };
-    Es6ClassAnalyzer.prototype.getBaseClassWithDeclaration = function () {
+    }
+    getBaseClassWithDeclaration() {
         if (!this.node.declarations[0].init.superClass)
@@ -56,4 +52,4 @@ return;
             return this.node.declarations[0].init.superClass.name;
-    };
-    Es6ClassAnalyzer.prototype.getBaseClass = function () {
+    }
+    getBaseClass() {
         if (this.isClass())
@@ -63,5 +59,4 @@ return this.getBaseClassSimple();
             return this.getBaseClassWithDeclaration();
-    };
-    return Es6ClassAnalyzer;
-}(class_analyzer_1.ClassAnalyzer));
+    }
+}
 exports.Es6ClassAnalyzer = Es6ClassAnalyzer;

lib/analyzers/astree/es6-member-analyzer.js

 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-var core_1 = require("../../core");
-var Es6MemberAnalyzer = (function () {
-    function Es6MemberAnalyzer(node) {
+const core_1 = require("../../core");
+class Es6MemberAnalyzer {
+    constructor(node) {
         this.node = node;
     }
-    Es6MemberAnalyzer.prototype.getParameters = function () {
+    getParameters() {
         return this.node.params;
-    };
-    Es6MemberAnalyzer.prototype.getType = function () {
+    }
+    getType() {
         switch (this.node.kind) {
@@ -18,10 +18,10 @@ case "constructor":
         }
-    };
-    Es6MemberAnalyzer.prototype.getName = function () {
+    }
+    getName() {
         return this.node.key.name;
-    };
-    Es6MemberAnalyzer.prototype.isCandidate = function () {
+    }
+    isCandidate() {
         return this.node.type == core_1.SyntaxKind.ClassMethod;
-    };
-    Es6MemberAnalyzer.prototype.getLocation = function () {
+    }
+    getLocation() {
         return {
@@ -31,5 +31,4 @@ start: this.node.start,
         };
-    };
-    return Es6MemberAnalyzer;
-}());
+    }
+}
 exports.Es6MemberAnalyzer = Es6MemberAnalyzer;

lib/analyzers/astree/file-analyzer.js

 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-var FileAnalyzer = (function () {
-    function FileAnalyzer(node) {
+class FileAnalyzer {
+    constructor(node) {
         this.node = node;
     }
-    FileAnalyzer.prototype.getChildren = function () {
+    getChildren() {
         return this.node.program.body;
-    };
-    FileAnalyzer.prototype.getLocation = function () {
+    }
+    getLocation() {
         return {
@@ -15,5 +15,4 @@ start: this.node.start,
         };
-    };
-    return FileAnalyzer;
-}());
+    }
+}
 exports.FileAnalyzer = FileAnalyzer;

lib/analyzers/astree/helper.js

 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-var core_1 = require("../../core");
+const core_1 = require("../../core");
 /**
@@ -53,8 +53,7 @@ * require CallExpression.callee
 function getArrayParameter(param) {
-    var result = {
+    let result = {
         type: "Array",
         children: []
     };
-    for (var _i = 0, _a = param.elements; _i < _a.length; _i++) {
-        var item = _a[_i];
+    for (let item of param.elements) {
         result.children.push(getDecoratorParameterName(item));
@@ -65,3 +64,3 @@ }
 function getPropertyParameter(param) {
-    var value = getDecoratorParameterName(param.value);
+    let value = getDecoratorParameterName(param.value);
     return {
@@ -74,8 +73,7 @@ type: value.type,
 function getObjectParameter(param) {
-    var result = {
+    let result = {
         type: "Object",
         properties: []
     };
-    for (var _i = 0, _a = param.properties; _i < _a.length; _i++) {
-        var item = _a[_i];
+    for (let item of param.properties) {
         result.properties.push(getPropertyParameter(item));
@@ -82,0 +80,0 @@ }

lib/analyzers/astree/index.js

 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-var baseclasses_1 = require("../baseclasses");
-var child_decorator_analyzer_1 = require("./child-decorator-analyzer");
+const baseclasses_1 = require("../baseclasses");
+const child_decorator_analyzer_1 = require("./child-decorator-analyzer");
 exports.ChildDecoratorAnalyzer = child_decorator_analyzer_1.ChildDecoratorAnalyzer;
-var class_analyzer_1 = require("./class-analyzer");
+const class_analyzer_1 = require("./class-analyzer");
 exports.ClassAnalyzer = class_analyzer_1.ClassAnalyzer;
-var constructor_analyser_1 = require("./constructor-analyser");
+const constructor_analyser_1 = require("./constructor-analyser");
 exports.ConstructorAnalyzer = constructor_analyser_1.ConstructorAnalyzer;
-var decorator_analyzer_1 = require("./decorator-analyzer");
+const decorator_analyzer_1 = require("./decorator-analyzer");
 exports.DecoratorAnalyzer = decorator_analyzer_1.DecoratorAnalyzer;
-var file_analyzer_1 = require("./file-analyzer");
+const file_analyzer_1 = require("./file-analyzer");
 exports.FileAnalyzer = file_analyzer_1.FileAnalyzer;
-var method_analyzer_1 = require("./method-analyzer");
+const method_analyzer_1 = require("./method-analyzer");
 exports.MethodAnalyzer = method_analyzer_1.MethodAnalyzer;
-var module_analyzer_1 = require("./module-analyzer");
+const module_analyzer_1 = require("./module-analyzer");
 exports.ModuleAnalyzer = module_analyzer_1.ModuleAnalyzer;
-var parameter_analyzer_1 = require("./parameter-analyzer");
+const parameter_analyzer_1 = require("./parameter-analyzer");
 exports.ParameterAnalyzer = parameter_analyzer_1.ParameterAnalyzer;
-var es6_class_analyzer_1 = require("./es6-class-analyzer");
+const es6_class_analyzer_1 = require("./es6-class-analyzer");
 exports.Es6ClassAnalyzer = es6_class_analyzer_1.Es6ClassAnalyzer;
-var es6_member_analyzer_1 = require("./es6-member-analyzer");
+const es6_member_analyzer_1 = require("./es6-member-analyzer");
 exports.Es6MemberAnalyzer = es6_member_analyzer_1.Es6MemberAnalyzer;
@@ -24,0 +24,0 @@ function get(type, node) {

lib/analyzers/astree/method-analyzer.js

 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-var core_1 = require("../../core");
-var MethodAnalyzer = (function () {
+const core_1 = require("../../core");
+class MethodAnalyzer {
     /**
      * expect ExpressionStatement
      */
-    function MethodAnalyzer(node) {
+    constructor(node) {
         this.node = node;
     }
-    MethodAnalyzer.prototype.isMethod = function (className) {
+    isMethod(className) {
         return this.isMethodStatement()
             && this.node.expression.left.object.object.name == className;
-    };
-    MethodAnalyzer.prototype.isMethodStatement = function () {
+    }
+    isMethodStatement() {
         return this.node.type == core_1.SyntaxKind.ExpressionStatement
@@ -22,4 +22,4 @@ && this.node.expression.type == core_1.SyntaxKind.AssignmentExpression
             && this.node.expression.right.type == core_1.SyntaxKind.FunctionExpression;
-    };
-    MethodAnalyzer.prototype.getName = function () {
+    }
+    getName() {
         if (this.isMethodStatement())
@@ -29,4 +29,4 @@ return this.node.expression.left.property.name;
             return null;
-    };
-    MethodAnalyzer.prototype.getClassName = function () {
+    }
+    getClassName() {
         if (this.isMethodStatement())
@@ -36,4 +36,4 @@ return this.node.expression.left.object.object.name;
             return null;
-    };
-    MethodAnalyzer.prototype.getLocation = function () {
+    }
+    getLocation() {
         return {
@@ -43,14 +43,13 @@ start: this.node.start,
         };
-    };
-    MethodAnalyzer.prototype.getParameters = function () {
+    }
+    getParameters() {
         return this.node.expression.right.params;
-    };
-    MethodAnalyzer.prototype.getParams = function () {
+    }
+    getParams() {
         if (this.isMethodStatement())
-            return this.node.expression.right.params.map(function (x) { return x.name; });
+            return this.node.expression.right.params.map((x) => x.name);
         else
             return null;
-    };
-    return MethodAnalyzer;
-}());
+    }
+}
 exports.MethodAnalyzer = MethodAnalyzer;

lib/analyzers/astree/module-analyzer.js

 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-var core_1 = require("../../core");
-var ModuleAnalyzer = (function () {
+const core_1 = require("../../core");
+class ModuleAnalyzer {
     /**
      * require ExpressionStatement
      */
-    function ModuleAnalyzer(node) {
+    constructor(node) {
         this.node = node;
     }
-    ModuleAnalyzer.prototype.isCandidate = function () {
+    isCandidate() {
         /*
@@ -23,7 +23,7 @@ (function(ModuleName){})(ModuleName = (<any>.ModuleName) || ())
             && this.node.expression.arguments[0].left.name == this.node.expression.callee.params[0].name;
-    };
-    ModuleAnalyzer.prototype.getBody = function () {
+    }
+    getBody() {
         return this.node.expression.callee.body.body;
-    };
-    ModuleAnalyzer.prototype.getName = function () {
+    }
+    getName() {
         if (this.isCandidate())
@@ -33,4 +33,4 @@ return this.node.expression.arguments[0].left.name;
             return null;
-    };
-    ModuleAnalyzer.prototype.getLocation = function () {
+    }
+    getLocation() {
         return {
@@ -40,4 +40,4 @@ start: this.node.start,
         };
-    };
-    ModuleAnalyzer.prototype.isExported = function (parentName) {
+    }
+    isExported(parentName) {
         //(function(Children){})(Children = (Parent.Children) || ())
@@ -50,5 +50,4 @@ //(function(Children){})(Children = (exports.Children) || ())
                 || this.node.expression.arguments[0].right.left.object.name == "exports");
-    };
-    return ModuleAnalyzer;
-}());
+    }
+}
 exports.ModuleAnalyzer = ModuleAnalyzer;

lib/analyzers/astree/parameter-analyzer.js

 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-var core_1 = require("../../core");
-var ParameterAnalyzer = (function () {
-    function ParameterAnalyzer(node) {
+const core_1 = require("../../core");
+class ParameterAnalyzer {
+    constructor(node) {
         this.node = node;
     }
-    ParameterAnalyzer.prototype.withDefaultValue = function () {
+    withDefaultValue() {
         return this.node.type == core_1.SyntaxKind.AssignmentPattern;
-    };
-    ParameterAnalyzer.prototype.getName = function () {
+    }
+    getName() {
         if (this.withDefaultValue())
@@ -16,4 +16,4 @@ return this.node.left.name;
             return this.node.name;
-    };
-    ParameterAnalyzer.prototype.getLocation = function () {
+    }
+    getLocation() {
         return {
@@ -23,5 +23,4 @@ start: this.node.start,
         };
-    };
-    return ParameterAnalyzer;
-}());
+    }
+}
 exports.ParameterAnalyzer = ParameterAnalyzer;

lib/analyzers/index.js

 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-var AsTree = require("./astree");
+const AsTree = require("./astree");
 function get(parser, type, node) {
@@ -5,0 +5,0 @@ return AsTree.get(type, node);

lib/core.js

@@ -49,3 +49,3 @@ "use strict";
 (function (Call) {
-    var META_DATA_KEY = "kamboja:Call.when";
+    const META_DATA_KEY = "kamboja:Call.when";
     function when(kind) {
@@ -58,3 +58,3 @@ return function (target, method, descriptor) {
     function getWhen(target, methodName) {
-        var result = Reflect.getMetadata(META_DATA_KEY, target, methodName);
+        let result = Reflect.getMetadata(META_DATA_KEY, target, methodName);
         if (typeof result == "undefined")
@@ -66,31 +66,22 @@ throw new Error("Unable to get metadata identifier, try to re-install refrect-metadata module");
 })(Call = exports.Call || (exports.Call = {}));
-var TransformerBase = (function () {
-    function TransformerBase() {
-    }
-    TransformerBase.prototype.traverse = function (children, metaData, transformers) {
-        var calls = this.getCalls(transformers);
-        var _loop_1 = function (child) {
-            if (calls.some(function (x) { return x == child.type; })) {
-                for (var _i = 0, transformers_1 = transformers; _i < transformers_1.length; _i++) {
-                    var transformer = transformers_1[_i];
+class TransformerBase {
+    traverse(children, metaData, transformers) {
+        let calls = this.getCalls(transformers);
+        for (let child of children) {
+            if (calls.some(x => x == child.type)) {
+                for (let transformer of transformers) {
                     transformer.transform(child, metaData);
                 }
             }
-        };
-        for (var _i = 0, children_1 = children; _i < children_1.length; _i++) {
-            var child = children_1[_i];
-            _loop_1(child);
         }
-    };
-    TransformerBase.prototype.getCalls = function (traversers) {
-        var calls = [];
-        for (var _i = 0, traversers_1 = traversers; _i < traversers_1.length; _i++) {
-            var traverser = traversers_1[_i];
-            var cal = Call.getWhen(traverser, "transform");
+    }
+    getCalls(traversers) {
+        let calls = [];
+        for (let traverser of traversers) {
+            let cal = Call.getWhen(traverser, "transform");
             calls.push(cal);
         }
         return calls;
-    };
-    return TransformerBase;
-}());
+    }
+}
 exports.TransformerBase = TransformerBase;

lib/index.js

 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-var transformer_1 = require("./transformer");
+const transformer_1 = require("./transformer");
 var core_1 = require("./core");
@@ -10,5 +10,5 @@ exports.AnalysisType = core_1.AnalysisType;
 function transform(parser, ast, fileName) {
-    var transformer = new transformer_1.Transformer(fileName, parser);
+    let transformer = new transformer_1.Transformer(fileName, parser);
     return transformer.transform(ast);
 }
 exports.transform = transform;

lib/transformer.js

 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-var tslib_1 = require("tslib");
-var Analyzer = require("./analyzers");
-var core_1 = require("./core");
-var ts_class_1 = require("./transformers/ts-class");
-var ts_module_1 = require("./transformers/ts-module");
-var ts_decorator_1 = require("./transformers/ts-decorator");
-var ts_class_export_1 = require("./transformers/ts-class-export");
-var es6_class_1 = require("./transformers/es6-class");
-var Transformer = (function () {
-    function Transformer(fileName, parser) {
+const Analyzer = require("./analyzers");
+const core_1 = require("./core");
+const ts_class_1 = require("./transformers/ts-class");
+const ts_module_1 = require("./transformers/ts-module");
+const ts_decorator_1 = require("./transformers/ts-decorator");
+const ts_class_export_1 = require("./transformers/ts-class-export");
+const es6_class_1 = require("./transformers/es6-class");
+class Transformer {
+    constructor(fileName, parser) {
         this.fileName = fileName;
         this.parser = parser;
     }
-    Transformer.prototype.transform = function (ast) {
-        var analyzer = Analyzer
+    transform(ast) {
+        let analyzer = Analyzer
             .get(this.parser, Analyzer.AnalyzerType.File, ast);
-        var file = {
+        let file = {
             type: "File",
@@ -26,18 +25,15 @@ name: this.fileName,
         };
-        var fileTransformer = new FileTransformer(this.parser);
+        let fileTransformer = new FileTransformer(this.parser);
         fileTransformer.transform(ast, file);
         return file;
-    };
-    return Transformer;
-}());
+    }
+}
 exports.Transformer = Transformer;
-var FileTransformer = (function (_super) {
-    tslib_1.__extends(FileTransformer, _super);
-    function FileTransformer(parserType) {
-        var _this = _super.call(this) || this;
-        _this.parserType = parserType;
-        return _this;
+class FileTransformer extends core_1.TransformerBase {
+    constructor(parserType) {
+        super();
+        this.parserType = parserType;
     }
-    FileTransformer.prototype.transform = function (node, parent) {
-        var analyzer = Analyzer
+    transform(node, parent) {
+        let analyzer = Analyzer
             .get(this.parserType, Analyzer.AnalyzerType.File, node);
@@ -51,4 +47,3 @@ this.traverse(analyzer.getChildren(), parent, [
         ]);
-    };
-    return FileTransformer;
-}(core_1.TransformerBase));
+    }
+}

lib/transformers/constructor.js

 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-var tslib_1 = require("tslib");
-var Analyzer = require("../analyzers");
-var parameter_1 = require("./parameter");
-var Core = require("../core");
-var ConstructorTransformer = (function (_super) {
-    tslib_1.__extends(ConstructorTransformer, _super);
-    function ConstructorTransformer(parserType) {
-        var _this = _super.call(this) || this;
-        _this.parserType = parserType;
-        return _this;
+const tslib_1 = require("tslib");
+const Analyzer = require("../analyzers");
+const parameter_1 = require("./parameter");
+const Core = require("../core");
+class ConstructorTransformer extends Core.TransformerBase {
+    constructor(parserType) {
+        super();
+        this.parserType = parserType;
     }
-    ConstructorTransformer.prototype.transform = function (node, parent) {
-        var analyser = Analyzer
+    transform(node, parent) {
+        let analyser = Analyzer
             .get(this.parserType, Analyzer.AnalyzerType.Constructor, node);
         if (analyser.isConstructor(parent.name)) {
-            var constructor = {
+            let constructor = {
                 type: "Constructor",
@@ -30,8 +28,7 @@ name: analyser.getName(),
         }
-    };
-    tslib_1.__decorate([
-        Core.Call.when(Core.SyntaxKind.FunctionDeclaration)
-    ], ConstructorTransformer.prototype, "transform", null);
-    return ConstructorTransformer;
-}(Core.TransformerBase));
+    }
+}
+tslib_1.__decorate([
+    Core.Call.when(Core.SyntaxKind.FunctionDeclaration)
+], ConstructorTransformer.prototype, "transform", null);
 exports.ConstructorTransformer = ConstructorTransformer;

lib/transformers/es6-class-member.js

 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-var tslib_1 = require("tslib");
-var Analyzer = require("../analyzers");
-var parameter_1 = require("./parameter");
-var parameter_with_default_1 = require("./parameter-with-default");
-var Core = require("../core");
-var Es6ClassMember = (function (_super) {
-    tslib_1.__extends(Es6ClassMember, _super);
-    function Es6ClassMember(parserType) {
-        var _this = _super.call(this) || this;
-        _this.parserType = parserType;
-        return _this;
+const tslib_1 = require("tslib");
+const Analyzer = require("../analyzers");
+const parameter_1 = require("./parameter");
+const parameter_with_default_1 = require("./parameter-with-default");
+const Core = require("../core");
+class Es6ClassMember extends Core.TransformerBase {
+    constructor(parserType) {
+        super();
+        this.parserType = parserType;
     }
-    Es6ClassMember.prototype.transform = function (node, parent) {
-        var analyser = Analyzer
+    transform(node, parent) {
+        let analyser = Analyzer
             .get(this.parserType, Analyzer.AnalyzerType.Es6ClassMember, node);
-        var type = analyser.getType();
+        let type = analyser.getType();
         if (analyser.isCandidate()) {
-            var method = {
+            let method = {
                 type: type,
@@ -38,8 +36,7 @@ name: analyser.getName(),
         }
-    };
-    tslib_1.__decorate([
-        Core.Call.when(Core.SyntaxKind.ClassMethod)
-    ], Es6ClassMember.prototype, "transform", null);
-    return Es6ClassMember;
-}(Core.TransformerBase));
+    }
+}
+tslib_1.__decorate([
+    Core.Call.when(Core.SyntaxKind.ClassMethod)
+], Es6ClassMember.prototype, "transform", null);
 exports.Es6ClassMember = Es6ClassMember;

lib/transformers/es6-class.js

 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-var tslib_1 = require("tslib");
-var Analyzer = require("../analyzers");
-var es6_class_member_1 = require("./es6-class-member");
-var Core = require("../core");
-var Es6ClassTransformer = (function (_super) {
-    tslib_1.__extends(Es6ClassTransformer, _super);
-    function Es6ClassTransformer(parserType) {
-        var _this = _super.call(this) || this;
-        _this.parserType = parserType;
-        return _this;
+const tslib_1 = require("tslib");
+const Analyzer = require("../analyzers");
+const es6_class_member_1 = require("./es6-class-member");
+const Core = require("../core");
+class Es6ClassTransformer extends Core.TransformerBase {
+    constructor(parserType) {
+        super();
+        this.parserType = parserType;
     }
-    Es6ClassTransformer.prototype.transform = function (node, parent) {
-        var analyzer = Analyzer
+    transform(node, parent) {
+        let analyzer = Analyzer
             .get(this.parserType, Analyzer.AnalyzerType.Es6Class, node);
         if (analyzer.isCandidate()) {
-            var clazz = {
+            let clazz = {
                 type: "Class",
@@ -31,4 +29,4 @@ name: analyzer.getName(),
         }
-    };
-    Es6ClassTransformer.prototype.analyse = function (clazz, parent, analyzer) {
+    }
+    analyse(clazz, parent, analyzer) {
         /*
@@ -39,11 +37,10 @@ TS class is not valid *YET* here,
         clazz.analysis |= Core.AnalysisType.HasConstructor;
-        var hasMethods = clazz.methods && clazz.methods.length > 0;
+        let hasMethods = clazz.methods && clazz.methods.length > 0;
         if (hasMethods)
             clazz.analysis |= Core.AnalysisType.HasMethod;
-    };
-    tslib_1.__decorate([
-        Core.Call.when(Core.SyntaxKind.ClassDeclaration)
-    ], Es6ClassTransformer.prototype, "transform", null);
-    return Es6ClassTransformer;
-}(Core.TransformerBase));
+    }
+}
+tslib_1.__decorate([
+    Core.Call.when(Core.SyntaxKind.ClassDeclaration)
+], Es6ClassTransformer.prototype, "transform", null);
 exports.Es6ClassTransformer = Es6ClassTransformer;

lib/transformers/method.js

 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-var tslib_1 = require("tslib");
-var Analyzer = require("../analyzers");
-var parameter_1 = require("./parameter");
-var Core = require("../core");
-var MethodTransformer = (function (_super) {
-    tslib_1.__extends(MethodTransformer, _super);
-    function MethodTransformer(parserType) {
-        var _this = _super.call(this) || this;
-        _this.parserType = parserType;
-        return _this;
+const tslib_1 = require("tslib");
+const Analyzer = require("../analyzers");
+const parameter_1 = require("./parameter");
+const Core = require("../core");
+class MethodTransformer extends Core.TransformerBase {
+    constructor(parserType) {
+        super();
+        this.parserType = parserType;
     }
-    MethodTransformer.prototype.transform = function (node, parent) {
-        var analyser = Analyzer
+    transform(node, parent) {
+        let analyser = Analyzer
             .get(this.parserType, Analyzer.AnalyzerType.Method, node);
         if (analyser.isMethod(parent.name)) {
-            var method = {
+            let method = {
                 type: "Method",
@@ -32,8 +30,7 @@ name: analyser.getName(),
         }
-    };
-    tslib_1.__decorate([
-        Core.Call.when(Core.SyntaxKind.ExpressionStatement)
-    ], MethodTransformer.prototype, "transform", null);
-    return MethodTransformer;
-}(Core.TransformerBase));
+    }
+}
+tslib_1.__decorate([
+    Core.Call.when(Core.SyntaxKind.ExpressionStatement)
+], MethodTransformer.prototype, "transform", null);
 exports.MethodTransformer = MethodTransformer;

lib/transformers/parameter-with-default.js

 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-var tslib_1 = require("tslib");
-var Core = require("../core");
-var Analyzer = require("../analyzers");
-var ParameterWithDefaultTransformer = (function (_super) {
-    tslib_1.__extends(ParameterWithDefaultTransformer, _super);
-    function ParameterWithDefaultTransformer(parserType) {
-        var _this = _super.call(this) || this;
-        _this.parserType = parserType;
-        return _this;
+const tslib_1 = require("tslib");
+const Core = require("../core");
+const Analyzer = require("../analyzers");
+class ParameterWithDefaultTransformer extends Core.TransformerBase {
+    constructor(parserType) {
+        super();
+        this.parserType = parserType;
     }
-    ParameterWithDefaultTransformer.prototype.transform = function (node, parent) {
-        var analyzer = Analyzer
+    transform(node, parent) {
+        let analyzer = Analyzer
             .get(this.parserType, Analyzer.AnalyzerType.Parameter, node);
@@ -24,8 +22,7 @@ if (!analyzer.withDefaultValue())
         });
-    };
-    tslib_1.__decorate([
-        Core.Call.when(Core.SyntaxKind.AssignmentPattern)
-    ], ParameterWithDefaultTransformer.prototype, "transform", null);
-    return ParameterWithDefaultTransformer;
-}(Core.TransformerBase));
+    }
+}
+tslib_1.__decorate([
+    Core.Call.when(Core.SyntaxKind.AssignmentPattern)
+], ParameterWithDefaultTransformer.prototype, "transform", null);
 exports.ParameterWithDefaultTransformer = ParameterWithDefaultTransformer;

lib/transformers/parameter.js

 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-var tslib_1 = require("tslib");
-var Core = require("../core");
-var Analyzer = require("../analyzers");
-var ParameterTransformer = (function (_super) {
-    tslib_1.__extends(ParameterTransformer, _super);
-    function ParameterTransformer(parserType) {
-        var _this = _super.call(this) || this;
-        _this.parserType = parserType;
-        return _this;
+const tslib_1 = require("tslib");
+const Core = require("../core");
+const Analyzer = require("../analyzers");
+class ParameterTransformer extends Core.TransformerBase {
+    constructor(parserType) {
+        super();
+        this.parserType = parserType;
     }
-    ParameterTransformer.prototype.transform = function (node, parent) {
-        var analyzer = Analyzer
+    transform(node, parent) {
+        let analyzer = Analyzer
             .get(this.parserType, Analyzer.AnalyzerType.Parameter, node);
@@ -24,8 +22,7 @@ if (analyzer.withDefaultValue())
         });
-    };
-    tslib_1.__decorate([
-        Core.Call.when(Core.SyntaxKind.Identifier)
-    ], ParameterTransformer.prototype, "transform", null);
-    return ParameterTransformer;
-}(Core.TransformerBase));
+    }
+}
+tslib_1.__decorate([
+    Core.Call.when(Core.SyntaxKind.Identifier)
+], ParameterTransformer.prototype, "transform", null);
 exports.ParameterTransformer = ParameterTransformer;

lib/transformers/ts-child-decorator.js

 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-var tslib_1 = require("tslib");
-var Analyzer = require("../analyzers");
-var Core = require("../core");
-var TsChildDecoratorTransformer = (function (_super) {
-    tslib_1.__extends(TsChildDecoratorTransformer, _super);
-    function TsChildDecoratorTransformer(parserType) {
-        var _this = _super.call(this) || this;
-        _this.parserType = parserType;
-        return _this;
+const tslib_1 = require("tslib");
+const Analyzer = require("../analyzers");
+const Core = require("../core");
+class TsChildDecoratorTransformer extends Core.TransformerBase {
+    constructor(parserType) {
+        super();
+        this.parserType = parserType;
     }
-    TsChildDecoratorTransformer.prototype.transform = function (node, parent) {
-        var analyzers = Analyzer
+    transform(node, parent) {
+        let analyzers = Analyzer
             .get(this.parserType, Analyzer.AnalyzerType.ChildDecorator, node);
@@ -22,8 +20,8 @@ if (analyzers.isMethodDecorator()) {
             && parent.parameters.length > 0) {
-            var parameter = parent.parameters[parseInt(node.arguments[0].value)];
+            let parameter = parent.parameters[parseInt(node.arguments[0].value)];
             this.transformParameter(analyzers, parameter);
         }
-    };
-    TsChildDecoratorTransformer.prototype.transformMethod = function (analyzer, parent) {
-        var method = {
+    }
+    transformMethod(analyzer, parent) {
+        let method = {
             type: "Decorator",
@@ -38,5 +36,5 @@ name: analyzer.getMethodName(),
         parent.decorators.push(method);
-    };
-    TsChildDecoratorTransformer.prototype.transformParameter = function (analyzer, parameter) {
-        var decorator = {
+    }
+    transformParameter(analyzer, parameter) {
+        let decorator = {
             type: "Decorator",
@@ -51,8 +49,7 @@ name: analyzer.getParameterDecoratorName(),
         parameter.decorators.push(decorator);
-    };
-    tslib_1.__decorate([
-        Core.Call.when(Core.SyntaxKind.CallExpression)
-    ], TsChildDecoratorTransformer.prototype, "transform", null);
-    return TsChildDecoratorTransformer;
-}(Core.TransformerBase));
+    }
+}
+tslib_1.__decorate([
+    Core.Call.when(Core.SyntaxKind.CallExpression)
+], TsChildDecoratorTransformer.prototype, "transform", null);
 exports.TsChildDecoratorTransformer = TsChildDecoratorTransformer;

lib/transformers/ts-class-export.js

 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-var tslib_1 = require("tslib");
-var Analyzer = require("../analyzers");
-var Core = require("../core");
-var TsClassExporterTransformer = (function (_super) {
-    tslib_1.__extends(TsClassExporterTransformer, _super);
-    function TsClassExporterTransformer(parserType) {
-        var _this = _super.call(this) || this;
-        _this.parserType = parserType;
-        return _this;
+const tslib_1 = require("tslib");
+const Analyzer = require("../analyzers");
+const Core = require("../core");
+class TsClassExporterTransformer extends Core.TransformerBase {
+    constructor(parserType) {
+        super();
+        this.parserType = parserType;
     }
-    TsClassExporterTransformer.prototype.transform = function (node, parent) {
-        var analyzer = Analyzer
+    transform(node, parent) {
+        let analyzer = Analyzer
             .get(this.parserType, Analyzer.AnalyzerType.TSClass, node);
-        var parentName = analyzer.getParentName();
-        var className = analyzer.getName();
-        var clazz = parent.children.filter(function (x) { return x.name == className; })[0];
+        let parentName = analyzer.getParentName();
+        let className = analyzer.getName();
+        let clazz = parent.children.filter(x => x.name == className)[0];
         if (clazz && ((parent.type == "File" && parentName == "exports")
@@ -25,8 +23,7 @@ || (parent.type == "Module" && parentName == parent.name))) {
         }
-    };
-    tslib_1.__decorate([
-        Core.Call.when(Core.SyntaxKind.ExpressionStatement)
-    ], TsClassExporterTransformer.prototype, "transform", null);
-    return TsClassExporterTransformer;
-}(Core.TransformerBase));
+    }
+}
+tslib_1.__decorate([
+    Core.Call.when(Core.SyntaxKind.ExpressionStatement)
+], TsClassExporterTransformer.prototype, "transform", null);
 exports.TsClassExporterTransformer = TsClassExporterTransformer;

lib/transformers/ts-class.js

 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-var tslib_1 = require("tslib");
-var Analyzer = require("../analyzers");
-var method_1 = require("./method");
-var constructor_1 = require("./constructor");
-var ts_decorator_1 = require("./ts-decorator");
-var Core = require("../core");
-var TsClassTransformer = (function (_super) {
-    tslib_1.__extends(TsClassTransformer, _super);
-    function TsClassTransformer(parserType) {
-        var _this = _super.call(this) || this;
-        _this.parserType = parserType;
-        return _this;
+const tslib_1 = require("tslib");
+const Analyzer = require("../analyzers");
+const method_1 = require("./method");
+const constructor_1 = require("./constructor");
+const ts_decorator_1 = require("./ts-decorator");
+const Core = require("../core");
+class TsClassTransformer extends Core.TransformerBase {
+    constructor(parserType) {
+        super();
+        this.parserType = parserType;
     }
-    TsClassTransformer.prototype.transform = function (node, parent) {
-        var analyzer = Analyzer
+    transform(node, parent) {
+        let analyzer = Analyzer
             .get(this.parserType, Analyzer.AnalyzerType.TSClass, node);
         if (analyzer.isCandidate()) {
-            var clazz = {
+            let clazz = {
                 type: "Class",
@@ -35,4 +33,4 @@ name: analyzer.getName(),
         }
-    };
-    TsClassTransformer.prototype.analyse = function (clazz, parent, analyzer) {
+    }
+    analyse(clazz, parent, analyzer) {
         /*
@@ -42,4 +40,4 @@ TS class is not valid *YET* here,
         */
-        var hasConstructor = typeof clazz.constructor == "function" ? false : true;
-        var hasMethods = clazz.methods && clazz.methods.length > 0;
+        let hasConstructor = typeof clazz.constructor == "function" ? false : true;
+        let hasMethods = clazz.methods && clazz.methods.length > 0;
         if (hasConstructor)
@@ -49,8 +47,7 @@ clazz.analysis |= Core.AnalysisType.HasConstructor;
             clazz.analysis |= Core.AnalysisType.HasMethod;
-    };
-    tslib_1.__decorate([
-        Core.Call.when(Core.SyntaxKind.VariableDeclaration)
-    ], TsClassTransformer.prototype, "transform", null);
-    return TsClassTransformer;
-}(Core.TransformerBase));
+    }
+}
+tslib_1.__decorate([
+    Core.Call.when(Core.SyntaxKind.VariableDeclaration)
+], TsClassTransformer.prototype, "transform", null);
 exports.TsClassTransformer = TsClassTransformer;

lib/transformers/ts-decorator.js

 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-var tslib_1 = require("tslib");
-var Analyzer = require("../analyzers");
-var Core = require("../core");
-var ts_child_decorator_1 = require("./ts-child-decorator");
-var TsDecorator = (function (_super) {
-    tslib_1.__extends(TsDecorator, _super);
-    function TsDecorator(parserType) {
-        var _this = _super.call(this) || this;
-        _this.parserType = parserType;
-        return _this;
+const tslib_1 = require("tslib");
+const Analyzer = require("../analyzers");
+const Core = require("../core");
+const ts_child_decorator_1 = require("./ts-child-decorator");
+class TsDecorator extends Core.TransformerBase {
+    constructor(parserType) {
+        super();
+        this.parserType = parserType;
     }
-    TsDecorator.prototype.transform = function (node, parent) {
-        var analyzer = Analyzer
+    transform(node, parent) {
+        let analyzer = Analyzer
             .get(this.parserType, Analyzer.AnalyzerType.Decorator, node);
-        var clazz;
+        let clazz;
         if (parent.type == "Class")
@@ -23,3 +21,3 @@ clazz = parent;
         else
-            clazz = parent.children.filter(function (x) { return x.name == analyzer.getClassName(); })[0];
+            clazz = parent.children.filter(x => x.name == analyzer.getClassName())[0];
         if (analyzer.isMethodDecorator()) {
@@ -34,9 +32,9 @@ this.transformMethod(node, clazz, analyzer);
         }
-    };
-    TsDecorator.prototype.transformProperty = function (node, clazz, analyzer) {
-        var methodName = analyzer.getMethodName();
+    }
+    transformProperty(node, clazz, analyzer) {
+        let methodName = analyzer.getMethodName();
         if (clazz) {
             //property is special, because it only appears only on run time,
             //so here we add it manually
-            var property = {
+            let property = {
                 type: "Property",
@@ -57,7 +55,7 @@ name: analyzer.getMethodName(),
         }
-    };
-    TsDecorator.prototype.transformMethod = function (node, clazz, analyzer) {
-        var methodName = analyzer.getMethodName();
+    }
+    transformMethod(node, clazz, analyzer) {
+        let methodName = analyzer.getMethodName();
         if (clazz && clazz.methods) {
-            var method = clazz.methods.filter(function (x) { return x.name == methodName; })[0];
+            let method = clazz.methods.filter(x => x.name == methodName)[0];
             this.traverse(analyzer.getChildren(), method, [
@@ -67,4 +65,4 @@ new ts_child_decorator_1.TsChildDecoratorTransformer(this.parserType)
         }
-    };
-    TsDecorator.prototype.transformClass = function (node, clazz, analyzer) {
+    }
+    transformClass(node, clazz, analyzer) {
         if (clazz) {
@@ -75,8 +73,7 @@ this.traverse(analyzer.getChildren(), clazz, [
         }
-    };
-    tslib_1.__decorate([
-        Core.Call.when(Core.SyntaxKind.ExpressionStatement)
-    ], TsDecorator.prototype, "transform", null);
-    return TsDecorator;
-}(Core.TransformerBase));
+    }
+}
+tslib_1.__decorate([
+    Core.Call.when(Core.SyntaxKind.ExpressionStatement)
+], TsDecorator.prototype, "transform", null);
 exports.TsDecorator = TsDecorator;

lib/transformers/ts-module.js

 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-var tslib_1 = require("tslib");
-var Analyzer = require("../analyzers");
-var Core = require("../core");
-var ts_class_1 = require("./ts-class");
-var ts_decorator_1 = require("./ts-decorator");
-var ts_class_export_1 = require("./ts-class-export");
-var es6_class_1 = require("./es6-class");
-var TsModuleTransformer = (function (_super) {
-    tslib_1.__extends(TsModuleTransformer, _super);
-    function TsModuleTransformer(parserType) {
-        var _this = _super.call(this) || this;
-        _this.parserType = parserType;
-        return _this;
+const tslib_1 = require("tslib");
+const Analyzer = require("../analyzers");
+const Core = require("../core");
+const ts_class_1 = require("./ts-class");
+const ts_decorator_1 = require("./ts-decorator");
+const ts_class_export_1 = require("./ts-class-export");
+const es6_class_1 = require("./es6-class");
+class TsModuleTransformer extends Core.TransformerBase {
+    constructor(parserType) {
+        super();
+        this.parserType = parserType;
     }
-    TsModuleTransformer.prototype.transform = function (node, parent) {
-        var analyzer = Analyzer
+    transform(node, parent) {
+        let analyzer = Analyzer
             .get(this.parserType, Analyzer.AnalyzerType.TSModule, node);
         if (analyzer.isCandidate() && (parent.type == "Module" || parent.type == "File")) {
-            var module_1 = {
+            let module = {
                 type: "Module",
@@ -28,4 +26,4 @@ analysis: Core.AnalysisType.Candidate,
             };
-            parent.children.push(module_1);
-            this.traverse(analyzer.getBody(), module_1, [
+            parent.children.push(module);
+            this.traverse(analyzer.getBody(), module, [
                 new es6_class_1.Es6ClassTransformer(this.parserType),
@@ -37,9 +35,9 @@ new ts_class_1.TsClassTransformer(this.parserType),
             ]);
-            this.analyse(module_1, parent, analyzer);
+            this.analyse(module, parent, analyzer);
         }
-    };
-    TsModuleTransformer.prototype.analyse = function (module, parent, analyzer) {
-        var connected = module.children.length > 0
-            && module.children.some(function (x) { return Core.flag(x.analysis, Core.AnalysisType.Valid); });
-        var exported = analyzer.isExported(parent.type == "File" ? "exports" : parent.name);
+    }
+    analyse(module, parent, analyzer) {
+        let connected = module.children.length > 0
+            && module.children.some(x => Core.flag(x.analysis, Core.AnalysisType.Valid));
+        let exported = analyzer.isExported(parent.type == "File" ? "exports" : parent.name);
         if (exported)
@@ -51,8 +49,7 @@ module.analysis |= Core.AnalysisType.Exported;
             module.analysis |= Core.AnalysisType.Valid;
-    };
-    tslib_1.__decorate([
-        Core.Call.when(Core.SyntaxKind.ExpressionStatement)
-    ], TsModuleTransformer.prototype, "transform", null);
-    return TsModuleTransformer;
-}(Core.TransformerBase));
+    }
+}
+tslib_1.__decorate([
+    Core.Call.when(Core.SyntaxKind.ExpressionStatement)
+], TsModuleTransformer.prototype, "transform", null);
 exports.TsModuleTransformer = TsModuleTransformer;

lib/transformers/value.js

 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-var tslib_1 = require("tslib");
-var Analyzer = require("../analyzers");
-var Core = require("../core");
-var BooleanValueTransformer = (function (_super) {
-    tslib_1.__extends(BooleanValueTransformer, _super);
-    function BooleanValueTransformer(parserType) {
-        var _this = _super.call(this) || this;
-        _this.parserType = parserType;
-        return _this;
+const tslib_1 = require("tslib");
+const Analyzer = require("../analyzers");
+const Core = require("../core");
+class BooleanValueTransformer extends Core.TransformerBase {
+    constructor(parserType) {
+        super();
+        this.parserType = parserType;
     }
-    BooleanValueTransformer.prototype.transform = function (node, parent) {
-        var analyser = Analyzer
+    transform(node, parent) {
+        let analyser = Analyzer
             .get(this.parserType, Analyzer.AnalyzerType.ValueAnalyzer, node);
@@ -24,18 +22,15 @@ if (analyser.isPrimitive()) {
         }
-    };
-    tslib_1.__decorate([
-        Core.Call.when(Core.SyntaxKind.BooleanLiteral)
-    ], BooleanValueTransformer.prototype, "transform", null);
-    return BooleanValueTransformer;
-}(Core.TransformerBase));
+    }
+}
+tslib_1.__decorate([
+    Core.Call.when(Core.SyntaxKind.BooleanLiteral)
+], BooleanValueTransformer.prototype, "transform", null);
 exports.BooleanValueTransformer = BooleanValueTransformer;
-var StringValueTransformer = (function (_super) {
-    tslib_1.__extends(StringValueTransformer, _super);
-    function StringValueTransformer(parserType) {
-        var _this = _super.call(this) || this;
-        _this.parserType = parserType;
-        return _this;
+class StringValueTransformer extends Core.TransformerBase {
+    constructor(parserType) {
+        super();
+        this.parserType = parserType;
     }
-    StringValueTransformer.prototype.transform = function (node, parent) {
-        var analyser = Analyzer
+    transform(node, parent) {
+        let analyser = Analyzer
             .get(this.parserType, Analyzer.AnalyzerType.ValueAnalyzer, node);
@@ -50,18 +45,15 @@ if (analyser.isPrimitive()) {
         }
-    };
-    tslib_1.__decorate([
-        Core.Call.when(Core.SyntaxKind.StringLiteral)
-    ], StringValueTransformer.prototype, "transform", null);
-    return StringValueTransformer;
-}(Core.TransformerBase));
+    }
+}
+tslib_1.__decorate([
+    Core.Call.when(Core.SyntaxKind.StringLiteral)
+], StringValueTransformer.prototype, "transform", null);
 exports.StringValueTransformer = StringValueTransformer;
-var NumberValueTransformer = (function (_super) {
-    tslib_1.__extends(NumberValueTransformer, _super);
-    function NumberValueTransformer(parserType) {
-        var _this = _super.call(this) || this;
-        _this.parserType = parserType;
-        return _this;
+class NumberValueTransformer extends Core.TransformerBase {
+    constructor(parserType) {
+        super();
+        this.parserType = parserType;
     }
-    NumberValueTransformer.prototype.transform = function (node, parent) {
-        var analyser = Analyzer
+    transform(node, parent) {
+        let analyser = Analyzer
             .get(this.parserType, Analyzer.AnalyzerType.ValueAnalyzer, node);
@@ -76,18 +68,15 @@ if (analyser.isPrimitive()) {
         }
-    };
-    tslib_1.__decorate([
-        Core.Call.when(Core.SyntaxKind.NumericLiteral)
-    ], NumberValueTransformer.prototype, "transform", null);
-    return NumberValueTransformer;
-}(Core.TransformerBase));
+    }
+}
+tslib_1.__decorate([
+    Core.Call.when(Core.SyntaxKind.NumericLiteral)
+], NumberValueTransformer.prototype, "transform", null);
 exports.NumberValueTransformer = NumberValueTransformer;
-var NullValueTransformer = (function (_super) {
-    tslib_1.__extends(NullValueTransformer, _super);
-    function NullValueTransformer(parserType) {
-        var _this = _super.call(this) || this;
-        _this.parserType = parserType;
-        return _this;
+class NullValueTransformer extends Core.TransformerBase {
+    constructor(parserType) {
+        super();
+        this.parserType = parserType;
     }
-    NullValueTransformer.prototype.transform = function (node, parent) {
-        var analyser = Analyzer
+    transform(node, parent) {
+        let analyser = Analyzer
             .get(this.parserType, Analyzer.AnalyzerType.ValueAnalyzer, node);
@@ -102,8 +91,7 @@ if (analyser.isNull()) {
         }
-    };
-    tslib_1.__decorate([
-        Core.Call.when(Core.SyntaxKind.NullLiteral)
-    ], NullValueTransformer.prototype, "transform", null);
-    return NullValueTransformer;
-}(Core.TransformerBase));
+    }
+}
+tslib_1.__decorate([
+    Core.Call.when(Core.SyntaxKind.NullLiteral)
+], NullValueTransformer.prototype, "transform", null);
 exports.NullValueTransformer = NullValueTransformer;

package.json

 {
   "name": "kecubung",
-  "version": "0.4.0",
+  "version": "0.5.0-alpha.695401af",
   "description": "Javascript transformer to Type Metadata",
@@ -20,3 +20,3 @@ "main": "lib/index.js",
   "dependencies": {
-    "@types/node": "^8.0.19",
+    "@types/node": "^8.0.28",
     "reflect-metadata": "^0.1.10",
@@ -27,7 +27,7 @@ "tslib": "^1.7.1"
     "@types/babylon": "^6.16.2",
-    "@types/chai": "^4.0.2",
-    "@types/express": "^4.0.36",
-    "@types/mocha": "^2.2.41",
-    "babylon": "^6.17.4",
-    "chai": "^4.1.0",
+    "@types/chai": "^4.0.4",
+    "@types/express": "^4.0.37",
+    "@types/mocha": "^2.2.43",
+    "babylon": "^6.18.0",
+    "chai": "^4.1.2",
     "coveralls": "^2.13.1",
@@ -38,7 +38,7 @@ "del": "^3.0.0",
     "gulp-mocha": "^3.0.1",
-    "gulp-typescript": "^3.2.1",
-    "mocha": "^3.5.0",
+    "gulp-typescript": "^3.2.2",
+    "mocha": "^3.5.3",
     "run-sequence": "^2.1.0",
-    "typescript": "^2.4.2"
+    "typescript": "^2.5.2"
   }
 }

No alert changes

Worsened metrics

Total package byte prevSize

65254

decreased by-10.53%

Lines of code

1751

decreased by-4.11%

Dependency changes

• Updated@types/node@^8.0.28