Genese complexity report

<- refactorer.utils.ts
Methods : 3
Complexity index : 11.8
Cyclomatic complexity : 3
Cognitive complexity
100 % Correct 3/3
0 % Warning 0/3 (threshold : 10)
0 % Error 0/3 (threshold : 20)
Cyclomatic complexity
100 % Correct 3/3
0 % Warning 0/3 (threshold : 5)
0 % Error 0/3 (threshold : 10)
Methods of refactorer.utils.ts
createSimpleMethod Complexity Index 3.2 Cyclomatic complexity 1
                            
                                
            
                /**
                 * Simple way to create method node
                 * @param name the method name
                 * @param block the method block node
                 * @param parameters the method parameters
                 * @returns {ts.MethodDeclaration}
                 */
                static createSimpleMethod(name: string, block: ts.Block, parameters: ts.ParameterDeclaration[] = []): ts.MethodDeclaration { // ------- +1.2 Complexity index (+1.2 atomic)
                    return ts.createMethod([], [], undefined, name, undefined, undefined, parameters, undefined, block); // --------------------------- +2.0 Complexity index (+1.0 atomic, +1 structural)
                }
            
                            
                        
createSimpleParameter Complexity Index 2.5 Cyclomatic complexity 1
                            
                                
                
            
                /**
                 * Simple way to create a parameter
                 * @param identifier the parameter name
                 * @param type the parameter type
                 * @returns {ts.ParameterDeclaration}
                 */
                static createSimpleParameter(identifier: string, type: ts.TypeNode): ts.ParameterDeclaration { // ------- +0.8 Complexity index (+0.8 atomic)
                    return ts.createParameter([], [], undefined, identifier, undefined, type); // ----------------------- +1.7 Complexity index (+0.7 atomic, +1 structural)
                }
            
                            
                        
createMethodCall Complexity Index 6.1 Cyclomatic complexity 1
                            
                                
                
            
                /**
                 * Simple way to create a method call
                 * @param name the method to call name
                 * @param parameters the passed parameters
                 * @returns {ts.CallExpression}
                 */
                static createMethodCall(name: string, parameters: ts.Expression[] = []): ts.CallExpression { // ----------------------------------------- +0.9 Complexity index (+0.9 atomic)
                    return ts.createCall(ts.createPropertyAccessChain(ts.createThis(), undefined, ts.createIdentifier(name)), [], parameters); // ------- +5.2 Complexity index (+1.2 atomic, +4 structural)
                }