Added base PropertyDefinition transformation

package.json

@@ -30,7 +30,7 @@
     "chance": "1.1.7",
     "class-validator": "0.13.1",
     "commander": "7.2.0",
-    "eslint-scope": "5.1.1",
+    "eslint-scope": "github:eslint/eslint-scope#ad618bc5001f02492fe9bdc6318fa1ae179b0260",
     "fast-deep-equal": "3.1.3",
     "inversify": "5.1.1",
     "js-string-escape": "1.0.1",

src/container/modules/node-transformers/ConvertingTransformersModule.ts

@@ -12,7 +12,7 @@ import { BasePropertiesExtractor } from '../../../node-transformers/converting-t
 import { BooleanLiteralTransformer } from '../../../node-transformers/converting-transformers/BooleanLiteralTransformer';
 import { ExportSpecifierTransformer } from '../../../node-transformers/converting-transformers/ExportSpecifierTransformer';
 import { MemberExpressionTransformer } from '../../../node-transformers/converting-transformers/MemberExpressionTransformer';
-import { MethodDefinitionTransformer } from '../../../node-transformers/converting-transformers/MethodDefinitionTransformer';
+import { MethodAndPropertyDefinitionTransformer } from '../../../node-transformers/converting-transformers/MethodAndPropertyDefinitionTransformer';
 import { NumberLiteralTransformer } from '../../../node-transformers/converting-transformers/NumberLiteralTransformer';
 import { NumberToNumericalExpressionTransformer } from '../../../node-transformers/converting-transformers/NumberToNumericalExpressionTransformer';
 import { ObjectExpressionKeysTransformer } from '../../../node-transformers/converting-transformers/ObjectExpressionKeysTransformer';
@@ -37,7 +37,7 @@ export const convertingTransformersModule: interfaces.ContainerModule = new Cont
         .whenTargetNamed(NodeTransformer.MemberExpressionTransformer);
 
     bind<INodeTransformer>(ServiceIdentifiers.INodeTransformer)
-        .to(MethodDefinitionTransformer)
+        .to(MethodAndPropertyDefinitionTransformer)
         .whenTargetNamed(NodeTransformer.MethodDefinitionTransformer);
 
     bind<INodeTransformer>(ServiceIdentifiers.INodeTransformer)

src/enums/node/NodeType.ts

@@ -39,6 +39,7 @@ export enum NodeType {
     ObjectPattern = 'ObjectPattern',
     Program = 'Program',
     Property = 'Property',
+    PropertyDefinition = 'PropertyDefinition',
     RestElement = 'RestElement',
     ReturnStatement = 'ReturnStatement',
     SequenceExpression = 'SequenceExpression',

src/node-transformers/converting-transformers/MethodDefinitionTransformer.ts → src/node-transformers/converting-transformers/MethodAndPropertyDefinitionTransformer.ts

@@ -21,12 +21,12 @@ import { NodeGuards } from '../../node/NodeGuards';
  *     'foo' () { //... };
  *
  * on:
- *     ['foo'] { //... };
+ *     ['foo'] () { //... };
  *
  * Literal node will be obfuscated by LiteralTransformer
  */
 @injectable()
-export class MethodDefinitionTransformer extends AbstractNodeTransformer {
+export class MethodAndPropertyDefinitionTransformer extends AbstractNodeTransformer {
     /**
      * @type {string[]}
      */
@@ -52,7 +52,13 @@ export class MethodDefinitionTransformer extends AbstractNodeTransformer {
             case NodeTransformationStage.Converting:
                 return {
                     enter: (node: ESTree.Node, parentNode: ESTree.Node | null): ESTree.Node | undefined => {
-                        if (parentNode && NodeGuards.isMethodDefinitionNode(node)) {
+                        if (
+                            parentNode
+                            && (
+                                NodeGuards.isMethodDefinitionNode(node)
+                                || NodeGuards.isPropertyDefinitionNode(node)
+                            )
+                        ) {
                             return this.transformNode(node, parentNode);
                         }
                     }
@@ -64,69 +70,65 @@ export class MethodDefinitionTransformer extends AbstractNodeTransformer {
     }
 
     /**
-     * replaces:
-     *     object.identifier = 1;
+     * TODO: remove all casts after @types/estree update
+     * TODO: make `classFieldNode` types just as `ESTree.MethodDefinition | ESTree.PropertyDefinition`
      *
-     * on:
-     *     object['identifier'] = 1;
-     *
-     * and skip:
-     *     object[identifier] = 1;
-     * Literal node will be obfuscated by LiteralTransformer
-     *
-     * @param {MethodDefinition} methodDefinitionNode
+     * @param {MethodDefinition | PropertyDefinition} classFieldNode
      * @param {NodeGuards} parentNode
      * @returns {NodeGuards}
      */
-    public transformNode (methodDefinitionNode: ESTree.MethodDefinition, parentNode: ESTree.Node): ESTree.Node {
-        if (NodeGuards.isIdentifierNode(methodDefinitionNode.key)) {
-            return this.replaceIdentifierKey(methodDefinitionNode, methodDefinitionNode.key);
+    public transformNode (
+        classFieldNode: ESTree.Node & (ESTree.MethodDefinition | ESTree.PropertyDefinition),
+        parentNode: ESTree.Node
+    ): ESTree.Node {
+        if (NodeGuards.isIdentifierNode(classFieldNode.key)) {
+            return this.replaceIdentifierKey(classFieldNode, classFieldNode.key);
         }
 
-        if (NodeGuards.isLiteralNode(methodDefinitionNode.key)) {
-            return this.replaceLiteralKey(methodDefinitionNode, methodDefinitionNode.key);
+        if (NodeGuards.isLiteralNode(classFieldNode.key)) {
+            return this.replaceLiteralKey(classFieldNode, classFieldNode.key);
         }
 
-        return methodDefinitionNode;
+        return classFieldNode;
     }
 
     /**
-     * @param {MethodDefinition} methodDefinitionNode
+     * @param {MethodDefinition | PropertyDefinition} classFieldNode
      * @param {Identifier} keyNode
-     * @returns {MethodDefinition}
+     * @returns {MethodDefinition | PropertyDefinition}
      */
     private replaceIdentifierKey (
-        methodDefinitionNode: ESTree.MethodDefinition,
+        classFieldNode: ESTree.MethodDefinition | ESTree.PropertyDefinition,
         keyNode: ESTree.Identifier
-    ): ESTree.MethodDefinition {
+    ): ESTree.MethodDefinition | ESTree.PropertyDefinition {
         if (
-            !MethodDefinitionTransformer.ignoredNames.includes(keyNode.name)
-            && !methodDefinitionNode.computed
+            !MethodAndPropertyDefinitionTransformer.ignoredNames.includes(keyNode.name)
+            && !classFieldNode.computed
         ) {
-            methodDefinitionNode.computed = true;
-            methodDefinitionNode.key = NodeFactory.literalNode(keyNode.name);
+            classFieldNode.computed = true;
+            classFieldNode.key = NodeFactory.literalNode(keyNode.name);
         }
 
-        return methodDefinitionNode;
+        return classFieldNode;
     }
 
     /**
-     * @param {MethodDefinition} methodDefinitionNode
+     * @param {MethodDefinition | PropertyDefinition} classFieldNode
      * @param {Literal} keyNode
-     * @returns {MethodDefinition}
+     * @returns {MethodDefinition | PropertyDefinition}
      */
     private replaceLiteralKey (
-        methodDefinitionNode: ESTree.MethodDefinition,
+        classFieldNode: ESTree.MethodDefinition | ESTree.PropertyDefinition,
         keyNode: ESTree.Literal
-    ): ESTree.MethodDefinition {
+    ): ESTree.MethodDefinition | ESTree.PropertyDefinition {
         if (
             typeof keyNode.value === 'string'
-            && !MethodDefinitionTransformer.ignoredNames.includes(keyNode.value)
-            && !methodDefinitionNode.computed
+            && !MethodAndPropertyDefinitionTransformer.ignoredNames.includes(keyNode.value)
+            && !classFieldNode.computed
         ) {
-            methodDefinitionNode.computed = true;
+            classFieldNode.computed = true;
         }
 
-        return methodDefinitionNode;
+        return classFieldNode;
     }
 }

src/node-transformers/converting-transformers/object-expression-extractors/BasePropertiesExtractor.ts

@@ -20,7 +20,7 @@ export class BasePropertiesExtractor implements IObjectExpressionExtractor {
      * @returns {string | null}
      */
     private static getPropertyNodeKeyName (propertyNode: ESTree.Property): string | null {
-        const propertyKeyNode: ESTree.Expression = propertyNode.key;
+        const propertyKeyNode: ESTree.Expression | ESTree.PrivateIdentifier = propertyNode.key;
 
         if (
             NodeGuards.isLiteralNode(propertyKeyNode)

src/node-transformers/rename-properties-transformers/RenamePropertiesTransformer.ts

@@ -46,7 +46,7 @@ export class RenamePropertiesTransformer extends AbstractNodeTransformer {
         TNode extends ESTree.Property | ESTree.MemberExpression | ESTree.MethodDefinition
     > (
         propertyNode: TNode,
-        propertyKeyNode: ESTree.Expression
+        propertyKeyNode: ESTree.Expression | ESTree.PrivateIdentifier
     ): propertyKeyNode is ESTree.Identifier | ESTree.Literal {
         if (NodeGuards.isIdentifierNode(propertyKeyNode) && propertyNode.computed) {
             return false;
@@ -123,7 +123,7 @@ export class RenamePropertiesTransformer extends AbstractNodeTransformer {
      * @returns {Property}
      */
     private transformPropertyNode (propertyNode: ESTree.Property): ESTree.Property {
-        const propertyKeyNode: ESTree.Expression = propertyNode.key;
+        const propertyKeyNode: ESTree.Expression | ESTree.PrivateIdentifier = propertyNode.key;
 
         if (RenamePropertiesTransformer.isValidPropertyNode(propertyNode, propertyKeyNode)) {
             propertyNode.key = this.renamePropertiesReplacer.replace(propertyKeyNode);
@@ -138,7 +138,7 @@ export class RenamePropertiesTransformer extends AbstractNodeTransformer {
      * @returns {Property}
      */
     private transformMemberExpressionNode (memberExpressionNode: ESTree.MemberExpression): ESTree.MemberExpression {
-        const propertyKeyNode: ESTree.Expression = memberExpressionNode.property;
+        const propertyKeyNode: ESTree.Expression | ESTree.PrivateIdentifier = memberExpressionNode.property;
 
         if (RenamePropertiesTransformer.isValidPropertyNode(memberExpressionNode, propertyKeyNode)) {
             memberExpressionNode.property = this.renamePropertiesReplacer.replace(propertyKeyNode);
@@ -152,7 +152,7 @@ export class RenamePropertiesTransformer extends AbstractNodeTransformer {
      * @returns {MethodDefinition}
      */
     private transformMethodDefinitionNode (methodDefinitionNode: ESTree.MethodDefinition): ESTree.MethodDefinition {
-        const propertyKeyNode: ESTree.Expression = methodDefinitionNode.key;
+        const propertyKeyNode: ESTree.Expression | ESTree.PrivateIdentifier = methodDefinitionNode.key;
 
         if (RenamePropertiesTransformer.isValidPropertyNode(methodDefinitionNode, propertyKeyNode)) {
             methodDefinitionNode.key = this.renamePropertiesReplacer.replace(propertyKeyNode);

src/node/NodeGuards.ts

@@ -418,6 +418,14 @@ export class NodeGuards {
         return node.type === NodeType.Property;
     }
 
+    /**
+     * @param {Node} node
+     * @returns {boolean}
+     */
+    public static isPropertyDefinitionNode (node: ESTree.Node): node is ESTree.PropertyDefinition {
+        return node.type === NodeType.PropertyDefinition;
+    }
+
     /**
      * @param {Node} node
      * @returns {boolean}

test/dev/dev.ts

@@ -7,24 +7,32 @@ import { NO_ADDITIONAL_NODES_PRESET } from '../../src/options/presets/NoCustomNo
 
     let obfuscatedCode: string = JavaScriptObfuscator.obfuscate(
         `
-            var variable1 = '5' - 3;
-            var variable2 = '5' + 3;
-            var variable3 = '5' + - '2';
-            var variable4 = ['10','10','10','10','10'].map(parseInt);
-            var variable5 = 'foo ' + 1 + 1;
-            console.log(variable1);
-            console.log(variable2);
-            console.log(variable3);
-            console.log(variable4);
-            console.log(variable5);
+            class Test {
+                constructor () {
+                    let test = {}
+                }
+                
+                methodA = () => {
+                    console.log('methodA');
+                }
+                
+                methodB () {
+                    console.log('methodB');
+                    
+                    this.methodA();
+                }
+            }
+            
+            const instance = new Test();
+            
+            instance.methodA();
+            instance.methodB();
         `,
         {
             ...NO_ADDITIONAL_NODES_PRESET,
             compact: false,
             stringArray: true,
-            stringArrayThreshold: 1,
-            rotateStringArray: true,
-            stringArrayWrappersCount: 3
+            stringArrayThreshold: 1
         }
     ).getObfuscatedCode();
 

yarn.lock

@@ -1891,10 +1891,9 @@ [email protected]:
     esrecurse "^4.1.0"
     estraverse "^4.1.1"
 
-eslint-scope@5.1.1, eslint-scope@^5.0.0, eslint-scope@^5.1.1:
+eslint-scope@^5.0.0, eslint-scope@^5.1.1, "eslint-scope@github:eslint/eslint-scope#ad618bc5001f02492fe9bdc6318fa1ae179b0260":
   version "5.1.1"
-  resolved "https://registry.npmjs.org/eslint-scope/-/eslint-scope-5.1.1.tgz"
-  integrity sha512-2NxwbF/hZ0KpepYN0cNbo+FN6XoK7GaHlQhgx/hIZl6Va0bF45RQOOwhLIy8lQDbuCiadSLCBnH2CFYquit5bw==
+  resolved "https://codeload.github.com/eslint/eslint-scope/tar.gz/ad618bc5001f02492fe9bdc6318fa1ae179b0260"
   dependencies:
     esrecurse "^4.3.0"
     estraverse "^4.1.1"