.eslintrc

 ---

   
  env:
    browser: true
    node: true
    es6: true

  ecmaFeatures:
    modules: true

  rules:
    #Possible Errors
    comma-dangle: 0             # - disallow or enforce trailing commas (recommended)
    no-cond-assign: 2           # - disallow assignment in conditional expressions (recommended)
    no-console: 1               # - disallow use of console in the node environment (recommended)
    no-constant-condition: 2    # - disallow use of constant expressions in conditions (recommended)
    no-control-regex: 2         # - disallow control characters in regular expressions (recommended)
    no-debugger: 2              # - disallow use of debugger (recommended)
    no-dupe-args: 2             # - disallow duplicate arguments in functions (recommended)
    no-dupe-keys: 2             # - disallow duplicate keys when creating object literals (recommended)
    no-duplicate-case: 2        # - disallow a duplicate case label. (recommended)
    no-empty-character-class: 2 # - disallow the use of empty character classes in regular expressions (recommended)
    no-empty: 2                 # - disallow empty statements (recommended)
    no-ex-assign: 2             # - disallow assigning to the exception in a catch block (recommended)
    no-extra-boolean-cast: 2    # - disallow double-negation boolean casts in a boolean context (recommended)
    no-extra-parens: 0          # - disallow unnecessary parentheses
    no-extra-semi: 2            # - disallow unnecessary semicolons (recommended) (fixable)
    no-func-assign: 2           # - disallow overwriting functions written as function declarations (recommended)
    no-inner-declarations: 2    # - disallow function or variable declarations in nested blocks (recommended)
    no-invalid-regexp: 2        # - disallow invalid regular expression strings in the RegExp constructor (recommended)
    no-irregular-whitespace: 2  # - disallow irregular whitespace outside of strings and comments (recommended)
    no-negated-in-lhs: 2        # - disallow negation of the left operand of an in expression (recommended)
    no-obj-calls: 2             # - disallow the use of object properties of the global object (Math and JSON) as functions (recommended)
    no-regex-spaces: 2          # - disallow multiple spaces in a regular expression literal (recommended)
    no-sparse-arrays: 2         # - disallow sparse arrays (recommended)
    no-unreachable: 2           # - disallow unreachable statements after a return, throw, continue, or break statement (recommended)
    use-isnan: 2                # - disallow comparisons with the value NaN (recommended)
    valid-jsdoc: 2              # - Ensure JSDoc comments are valid
    valid-typeof: 2             # - Ensure that the results of typeof are compared against a valid string (recommended)
    no-unexpected-multiline: 2  # - Avoid code that looks like two expressions but is actually one

    #Best Practices
    accessor-pairs: 1        # - Enforces getter/setter pairs in objects
    block-scoped-var: 1      # - treat var statements as if they were block scoped
    complexity: 1            # - specify the maximum cyclomatic complexity allowed in a program
    consistent-return: 1     # - require return statements to either always or never specify values
    curly:                   # - specify curly brace conventions for all control statements
      - 1
      - multi-line
    default-case: 1          # - require default case in switch statements
    dot-notation: 1          # - encourages use of dot notation whenever possible
    dot-location:            # - enforces consistent newlines before or after dots
      - 1
      - "property"
    eqeqeq: 1                # - require the use of === and !== (fixable)
    guard-for-in: 1          # - make sure for-in loops have an if statement
    no-alert: 1              # - disallow the use of alert, confirm, and prompt
    no-caller: 1             # - disallow use of arguments.caller or arguments.callee
    no-div-regex: 1          # - disallow division operators explicitly at beginning of regular expression
    no-else-return: 1        # - disallow else after a return in an if
    no-empty-label: 1        # - disallow use of labels for anything other than loops and switches
    no-eq-null: 1            # - disallow comparisons to null without a type-checking operator
    no-eval: 1               # - disallow use of eval()
    no-extend-native: 1      # - disallow adding to native types
    no-extra-bind: 1         # - disallow unnecessary function binding
    no-fallthrough: 1        # - disallow fallthrough of case statements (recommended)
    no-floating-decimal: 1   # - disallow the use of leading or trailing decimal points in numeric literals
    no-implicit-coercion: 1  # - disallow the type conversions with shorter notations
    no-implied-eval: 1       # - disallow use of eval()-like methods
    no-invalid-this: 1       # - disallow this keywords outside of classes or class-like objects
    no-iterator: 1           # - disallow usage of __iterator__ property
    no-labels: 1             # - disallow use of labeled statements
    no-lone-blocks: 1        # - disallow unnecessary nested blocks
    no-loop-func: 1          # - disallow creation of functions within loops
    no-multi-spaces: 1       # - disallow use of multiple spaces (fixable)
    no-multi-str: 1          # - disallow use of multiline strings
    no-native-reassign: 1    # - disallow reassignments of native objects
    no-new-func: 1           # - disallow use of new operator for Function object
    no-new-wrappers: 1       # - disallows creating new instances of String,Number, and Boolean
    no-new: 1                # - disallow use of the new operator when not part of an assignment or comparison
    no-octal-escape: 1       # - disallow use of octal escape sequences in string literals, such as var foo = "Copyright \251";
    no-octal: 1              # - disallow use of octal literals (recommended)
    no-param-reassign: 1     # - disallow reassignment of function parameters
    no-process-env: 1        # - disallow use of process.env
    no-proto: 1              # - disallow usage of __proto__ property
    no-redeclare: 1          # - disallow declaring the same variable more than once (recommended)
    no-return-assign: 1      # - disallow use of assignment in return statement
    no-script-url: 1         # - disallow use of javascript: urls.
    no-self-compare: 1       # - disallow comparisons where both sides are exactly the same
    no-sequences: 1          # - disallow use of the comma operator
    no-throw-literal: 1      # - restrict what can be thrown as an exception
    no-unused-expressions: 1 # - disallow usage of expressions in statement position
    no-useless-call: 1       # - disallow unnecessary .call() and .apply()
    no-useless-concat: 1     # - disallow unnecessary concatenation of literals or template literals
    no-void: 1               # - disallow use of the void operator
    no-warning-comments: 1   # - disallow usage of configurable warning terms in comments - e.g. TODO or FIXME
    no-with: 1               # - disallow use of the with statement
    radix: 1                 # - require use of the second argument for parseInt()
    vars-on-top: 1           # - require declaration of all vars at the top of their containing scope
    wrap-iife: 1             # - require immediate function invocation to be wrapped in parentheses
    yoda: 1                  # - require or disallow Yoda conditions

    #Strict
    strict: 2

    #Variables
    init-declarations: 2          # - enforce or disallow variable initializations at definition
    no-catch-shadow: 2            # - disallow the catch clause parameter name being the same as a variable in the outer scope
    no-delete-var: 2              # - disallow deletion of variables (recommended)
    no-label-var: 2               # - disallow labels that share a name with a variable
    no-shadow-restricted-names: 2 # - disallow shadowing of names such as arguments
    no-shadow: 2                  # - disallow declaration of variables already declared in the outer scope
    no-undef-init: 2              # - disallow use of undefined when initializing variables
    no-undef: 2                   # - disallow use of undeclared variables unless mentioned in a /*global */ block (recommended)
    no-undefined: 0               # - disallow use of undefined variable
    no-unused-vars: 2             # - disallow declaration of variables that are not used in the code (recommended)
    no-use-before-define: 2       # - disallow use of variables before they are defined

    #NodeJS and CommonJS
    callback-return: 2       # - enforce return after a callback
    global-require: 2        # - disallow require() outside of the top-level module scope
    handle-callback-err: 2   # - enforce error handling in callbacks
    no-mixed-requires: 2     # - disallow mixing regular variable and require decla2ations
    no-new-require: 2        # - disallow use of new operator with the require func4ion
    no-path-concat: 2        # - disallow string concatenation with __dirname and __filename
    no-process-exit: 2       # - disallow process.exit()
    no-restricted-modules: 2 # - restrict usage of specified node modules
    no-sync: 2               # - disallow use of synchronous methods

    #Style
    array-bracket-spacing: 1       # - enforce spacing inside array brackets (fixable)
    block-spacing: 1               # - disallow or enforce spaces inside of single line blocks (fixable)
    brace-style: 1                 # - enforce one true brace style
    camelcase: 1                   # - require camel case names
    comma-spacing: 1               # - enforce spacing before and after comma
    comma-style: 1                 # - enforce one true comma style
    computed-property-spacing: 1   # - require or disallow padding inside computed properties (fixable)
    consistent-this: 1             # - enforce consistent naming when capturing the current execution context
    eol-last: 1                    # - enforce newline at the end of file, with no multiple empty lines (fixable)
    func-names: 1                  # - require function expressions to have a name
    func-style: 1                  # - enforce use of function declarations or expressions
    id-length: 0                   # - this option enforces minimum and maximum identifier lengths (variable names, property names etc.)
    id-match: 1                    # - require identifiers to match the provided regular expression
    indent:                        # - specify tab or space width for your code (fixable)
      - 2
      - 2
    jsx-quotes: 1                  # - specify whether double or single quotes should be used in JSX attributes
    key-spacing: 1                 # - enforce spacing between keys and values in object literal properties
    lines-around-comment: 1        # - enforce empty lines around comments
    linebreak-style: 1             # - disallow mixed 'LF' and 'CRLF' as linebreaks
    max-nested-callbacks: 1        # - specify the maximum depth callbacks can be nested
    new-cap: 1                     # - require a capital letter for constructors
    new-parens: 1                  # - disallow the omission of parentheses when invoking a constructor with no arguments
    newline-after-var: 0           # - require or disallow an empty newline after variable declarations
    no-array-constructor: 1        # - disallow use of the Array constructor
    no-continue: 1                 # - disallow use of the continue statement
    no-inline-comments: 0          # - disallow comments inline after code
    no-lonely-if: 1                # - disallow if as the only statement in an else block
    no-mixed-spaces-and-tabs: 1    # - disallow mixed spaces and tabs for indentation (recommended)
    no-multiple-empty-lines: 1     # - disallow multiple empty lines
    no-nested-ternary: 1           # - disallow nested ternary expressions
    no-negated-condition: 0        # - disallow negated conditions
    no-new-object: 1               # - disallow the use of the Object constructor
    no-restricted-syntax: 1        # - disallow use of certain syntax in code
    no-spaced-func: 1              # - disallow space between function identifier and application (fixable)
    no-ternary: 0                  # - disallow the use of ternary operators
    no-trailing-spaces: 1          # - disallow trailing whitespace at the end of lines (fixable)
    no-underscore-dangle: 0        # - disallow dangling underscores in identifiers
    no-unneeded-ternary: 1         # - disallow the use of ternary operators when a simpler alternative exists
    object-curly-spacing: 1        # - require or disallow padding inside curly braces (fixable)
    one-var: 0                     # - require or disallow one variable declaration per function
    operator-assignment: 1         # - require assignment operator shorthand where possible or prohibit it entirely
    operator-linebreak: 1          # - enforce operators to be placed before or after line breaks
    padded-blocks: 0               # - enforce padding within blocks
    quote-props: 0                 # - require quotes around object literal property names
    quotes: 0                      # - specify whether backticks, double or single quotes should be used (fixable)
    require-jsdoc: 1               # - Require JSDoc comment
    semi-spacing: 1                # - enforce spacing before and after semicolons
    semi:                          # - require or disallow use of semicolons instead of ASI (fixable)
      - 1
      - never
    sort-vars: 1                   # - sort variables within the same declaration block
    space-after-keywords: 1        # - require a space after certain keywords (fixable)
    space-before-keywords: 1       # - require a space before certain keywords (fixable)
    space-before-blocks: 1         # - require or disallow a space before blocks (fixable)
    space-before-function-paren: 1 # - require or disallow a space before function opening parenthesis (fixable)
    space-in-parens: 1             # - require or disallow spaces inside parentheses
    space-infix-ops: 1             # - require spaces around operators (fixable)
    space-return-throw-case: 1     # - require a space after return, throw, and case (fixable)
    space-unary-ops: 1             # - require or disallow spaces before/after unary operators (fixable)
    spaced-comment: 1              # - require or disallow a space immediately following the // or /* in a comment
    wrap-regex: 1                  # - require regex literals to be wrapped in parentheses

    #ES6
    arrow-parens:             # - require parens in arrow function arguments
      - 1
      - as-needed
    arrow-spacing: 2          # - require space before/after arrow function's arrow (fixable)
    constructor-super: 2      # - verify calls of super() in constructors
    generator-star-spacing: 2 # - enforce spacing around the * in generator functions (fixable)
    no-class-assign: 2        # - disallow modifying variables of class declarations
    no-const-assign: 2        # - disallow modifying variables that are declared using const
    no-dupe-class-members: 2  # - disallow duplicate name in class members
    no-this-before-super: 2   # - disallow use of this/super before calling super() in constructors.
    no-var: 2                 # - require let or const instead of var
    object-shorthand: 2       # - require method and property shorthand syntax for object literals
    prefer-arrow-callback: 2  # - suggest using arrow functions as callbacks
    prefer-const: 2           # - suggest using const declaration for variables that are never modified after declared
    prefer-spread: 2          # - suggest using the spread operator instead of .apply().
    prefer-reflect: 0         # - suggest using Reflect methods where applicable
    prefer-template: 2        # - suggest using template literals instead of strings concatenation
    require-yield: 2          # - disallow generator functions that do not have yield

    #Legacy
    max-depth: 2      # - specify the maximum depth that blocks can be nested
    max-len:
    - 2
    -  120        # - specify the maximum length of a line in your program
    max-params:       # - limits the number of parameters that can be used in the function declaration.
      - 2
      - 4
    max-statements: 2 # - specify the maximum number of statement allowed in a function
    no-bitwise: 2     # - disallow use of bitwise operators
    no-plusplus: 2    # - disallow use of unary operators, ++ and --


  globals:
    React: false
    console: false
    logger: true
    R: false
    Promise: false
    describe : false
    before: false
    beforeEach: false
    afterEach : false
    after : false
    it : false