eslintrc.yaml

# use babel parser (requires babel-eslint)
parser: babel-eslint

env:
  # browser global variables
  browser: true

  # enable all ECMAScript 6 features (except for modules)
  es6: true

globals:
  __DEV__: false
  __CLIENT__: false
  __DEVTOOLS__: false
  module: false

# enable plugins
plugins:
  - react
  - babel
  - import
  - react-hooks

settings:
  import/resolver:
    eslint-config-ttn/resolver:
      alias:
        "~": src
  react:
    version: detect

# enable all language features
parserOptions:
  ecmaFeatures:
    # enable arrow functions
    arrowFunctions: true

    # enable binary literals
    binaryLiterals: true

    # enable let and const (aka block bindings)
    blockBindings: true

    # enable classes
    classes: true

    # enable default function parameters
    defaultParams: true

    # enable destructuring
    destructuring: true

    # enable for-of loops
    forOf: true

    # enable generators
    generators: true

    # enable modules and global strict mode
    modules: true

    # enable computed object literal property names
    objectLiteralComputedProperties: true

    # enable duplicate object literal properties in strict mode
    objectLiteralDuplicateProperties: true

    # enable object literal shorthand methods
    objectLiteralShorthandMethods: true

    # enable object literal shorthand properties
    objectLiteralShorthandProperties: true

    # enable octal literals
    octalLiterals: true

    # enable the regular expression u flag
    regexUFlag: true

    # enable the regular expression y flag
    regexYFlag: true

    # enable the rest parameters
    restParams: true

    # enable the spread operator
    spread: true

    # enable super references inside of functions
    superInFunctions: true

    # enable template strings
    templateStrings: true

    # enable code point escapes
    unicodeCodePointEscapes: true

    # allow return statements in the global scope
    globalReturn: true

    # enable JSX
    jsx: true

# configure rules
rules:
  # Handles destructuring arrays with flow type in function parameters
  array-bracket-spacing:
    - off

  # Enforce return statements in callbacks of array’s methods
  array-callback-return:
    - error

  # Consistent arrow bodies
  arrow-body-style:
    - error
    - never

  # Force parentheses only when needed in arrow functions
  arrow-parens:
    - error
    - as-needed

  # Force arrow bodies to be simple
  arrow-spacing:
    - error

  # Correct spacing inside objects
  babel/object-curly-spacing:
    - off

  # Guard against awaiting async functions inside of a loop
  no-await-in-loop:
    - warn

  # Force spacing in single line blocks
  block-spacing:
    - error
    - always

  # Force the one true brace style
  brace-style:
    - error
    - 1tbs

  # Do not force camel-case
  camelcase:
    - off

  # Force dangling commas
  comma-dangle:
    - error
    - always-multiline

  # Enforce spacing and after comma
  comma-spacing:
    - error

  # Enforce one true comma style
  comma-style:
    - error
    - last

  # Require or disallow padding inside computed properties
  computed-property-spacing:
    - error

  # Specify curly brace conventions for all control statements
  curly:
    - error
    - all

  # Enforce consistent newlines before or after dots
  dot-location:
    - error
    - property

  # Encourage use of dot notation whenever possible
  dot-notation:
    - error

  # Require use of === and !==
  eqeqeq:
    - error

  # Force consistent spacing when calling functions
  func-call-spacing:
    - error
    - never

  # Force space around generator stars
  generator-star-spacing:
    - error
    - both

  # Consisten indentation
  indent:
    - error
    - 2
    - SwitchCase: 0
      MemberExpression: 1

  # Make sure default is present when required
  import/default:
    - error

  # Put all imports first
  import/first:
    - error

  # Report invalid exports
  import/export:
    - error

  # Avoid amd-style import/export
  import/no-amd:
    - error

  # Make sure names exist
  import/named:
    - error

  # Make sure deferenced items of a namespace import exist
  import/namespace:
    - error

  # Avoid commonjs style import/export
  import/no-commonjs:
    - error

  # Avoid duplicate imports of the same module
  import/no-duplicates:
    - error

  # Avoid unresolvable imports
  import/no-unresolved:
    - error

  # Warn about import order
  import/order:
    - warn

  # Avoid/force extensions
  import/extensions:
    - error
    - always
    - js: never

  # Prefer defaul export for single export
  import/prefer-default-export:
    - warn

  # Use double quotes in jsx
  jsx-quotes:
    - error
    - prefer-double

  # Consistent object key spacing
  key-spacing:
    - error
    - beforeColon: false
      afterColon: true
      mode: strict

  # Enforce spacing before and after keywords
  keyword-spacing:
    - error

  # Disallow alert
  no-alert:
    - error

  # Disallow if (true) and if (false)
  no-constant-condition:
    - error

  # Disallow duplicate fn arguments
  no-dupe-args:
    - error

  # Disallow duplicate object keys
  no-dupe-keys:
    - error

  # Disallow duplicate case statements
  no-duplicate-case:
    - error

  # Prevent duplicate imports
  no-duplicate-imports:
    - error

  # Simplify if-else when possible
  no-else-return:
    - error

  # Disallow eval
  no-eval:
    - error

  # Avoid unnecessary binds
  no-extra-bind:
    - error

  # Disallow faulty function assignments
  no-func-assign:
    - error

  # Disallow assigning to globals
  no-global-assign:
    - error

  # Avoid implied eval
  no-implied-eval:
    - error

  # Avoid implicit globals
  no-implicit-globals:
    - error

  # Disallow decalring functions inside nested block
  no-inner-declarations:
    - warn

  # Prevent invalid regexes
  no-invalid-regexp:
    - error

  # Avoid invalid this references
  no-invalid-this:
    - error

  # Prevent spacing characters other than space
  no-irregular-whitespace:
    - error

  # Avoid lonely ifs in else blocks
  no-lonely-if:
    - error

  # Prevent !a in b instead of !(a in b) bug
  no-negated-in-lhs:
    -  error

  # Avoid creating wrappers for String, Boolean, ...
  no-new-wrappers:
    - error

  # Disallow mixed spaces and tabs for indentation
  no-mixed-spaces-and-tabs:
    - error

  # Disallow use of multiple spaces
  no-multi-spaces:
    - error

  # Prevent the accidental calling of global objects as functions
  no-obj-calls:
    - error

  # Disallow reassignment of function parameters
  no-param-reassign:
    - error

  # Forbid __proto__
  no-proto:
    - error

  # Forbid x === x
  no-self-compare:
    - error

  # Disallow assignments where both sides are exactly the same
  no-self-assign:
    - error

  # disallow space between function identifier and application
  no-spaced-func:
    - error

  # Disallow [,,]
  no-sparse-arrays:
    - error

  # disallow trailing whitespace at the end of lines
  no-trailing-spaces:
    - error

  # Avoid unnecessary ternaries
  no-unneeded-ternary:
    - error

  # Disallow unreachable code
  no-unreachable:
    - error

  # Disallow unsafe negations
  no-unsafe-negation:
    - error

  no-unused-expressions:
    - error

  # Disallow unused variables
  no-unused-vars:
    - error
    - args: none
      caughtErrors: none
      ignoreRestSiblings: true

  no-useless-call:
    - error

  no-useless-computed-key:
    - error

  no-useless-constructor:
    - error

  no-useless-escape:
    - error

  no-useless-rename:
    - error

  # Disallow use of undefined
  no-undefined:
    - off

  # Disallow use of undefined variables
  no-undef:
    - error

  # Disallow use of variables before they are defined
  no-use-before-define:
    - warn
    - functions: false
      variables: false

  # Disallow var
  no-var:
    - error

  # Disallow whit blocks
  no-with:
    - error

  # Disallow whitespace before object properties
  no-whitespace-before-property:
    - error

  # Consistent object newlines
  object-curly-newline:
    - error
    - multiline: true
      consistent: true

  # doesn't fail when using object spread (...obj)
  object-shorthand:
    - error

  # Allow only one declaration per line
  one-var-declaration-per-line:
    - error

  # Force operator shorthands when possible
  operator-assignment:
    - error
    - always

  # Enforce operators to be placed before or after line breaks
  operator-linebreak:
    - error
    - before
    - overrides:
       =: after

  # Suggest using const declaration for variables that are never reassigned after declared
  prefer-const:
    -  warn

  # Suggest using the rest parameters instead of arguments
  prefer-rest-params:
    - error

  # Suggest using the spread operator instead of .apply()
  prefer-spread:
    - error

  # Prefer template strings instead of concatenation
  prefer-template:
    - warn

  # Avoid useless string concatenation
  no-useless-concat:
    - error

  # Require quotes around object literal property names
  quote-props:
    - error
    - as-needed
    - keywords: true

  # Specify whether backticks, double or single quotes should be used
  quotes:
    - error
    - single
    - avoidEscape: true
      allowTemplateLiterals: true

  # Prevent usage of deprecated methods
  react/no-deprecated:
    - error

  # Prevent direct mutation of this.state
  react/no-direct-mutation-state:
    - error

  # Prevent usage of unknown DOM property (fixable)
  react/no-unknown-property:
    - error

  # Enforce ES5 or ES6 class for React Components
  react/prefer-es6-class:
    - error

  # Prevent missing React when using JSX
  react/react-in-jsx-scope:
    - error

  # Prevent extra closing tags for components without children
  react/self-closing-comp:
    - warn

  # Prevent missing parentheses around multilines JSX (fixable)
  react/jsx-wrap-multilines:
    - error

  # Enforce boolean attributes notation in JSX (fixable)
  react/jsx-boolean-value:
    - error

  # Validate closing bracket location in JSX (fixable)
  react/jsx-closing-bracket-location:
    - error

  # Enforce or disallow spaces inside of curly braces in JSX attributes (fixable)
  react/jsx-curly-spacing:
    - error

  # Validate props indentation in JSX (fixable)
  react/jsx-indent-props:
    - error
    - 2

  # Validate JSX indentation
  react/jsx-indent:
    - error
    - 2

  # Validate JSX has key prop when in array or iterator
  react/jsx-key:
    - error

  # Prevent usage of .bind() and arrow functions in JSX props
  react/jsx-no-bind:
    - warn

  # Prevent duplicate props in JSX
  react/jsx-no-duplicate-props:
    - error

  # Make react spacing consistent
  react/jsx-tag-spacing:
    - error
    - closingSlash: never
      beforeSelfClosing: always
      afterOpening: never

  # Prevent React to be incorrectly marked as unused
  react/jsx-uses-react: 1

  # Prevent variables used in JSX to be incorrectly marked as unused
  react/jsx-uses-vars: 1

  # Consistent spacing of the rest operator
  rest-spread-spacing:
    - error
    - never

  # Require or disallow use of semicolons instead of ASI
  semi:
    - error
    - never

  # Require or disallow a space before blocks
  space-before-blocks:
    - error

  # Require or disallow a space before function opening parenthesis
  space-before-function-paren:
    - error

  space-infix-ops:
    - error

  space-unary-ops:
    - error
    - nonwords: false
      words: true

  # Require or disallow a space immediately following the // or /* in a comment
  spaced-comment:
    - error

  # Consistent spacing in template string
  template-curly-spacing:
    - error

  # Never compare to NaN
  use-isnan:
    - error

  # Ensure string compared to typeof is valid
  valid-typeof:
    - error

  # enforce spacing around the * in yield* expressions
  yield-star-spacing:
    - error
    - both

  # checks rules of hooks
  react-hooks/rules-of-hooks: error

  # checks effect dependencies
  react-hooks/exhaustive-deps: warn

# vim: ft=yaml