@plumile/eslint-config-typescript 0.1.5

package/index.js

@@ -0,0 +1,1464 @@
+import jsdoc from 'eslint-plugin-jsdoc';
+import n from 'eslint-plugin-n';
+import reactHooksPlugin from 'eslint-plugin-react-hooks';
+import sonarjs from 'eslint-plugin-sonarjs';
+import stylistic from '@stylistic/eslint-plugin';
+import typescript from '@typescript-eslint/eslint-plugin';
+import typescriptParser from '@typescript-eslint/parser';
+
+import confusingBrowserGlobals from './src/rules/confusingBrowserGlobals.js';
+
+export default [
+  // Global exclusion
+  {
+    ignores: [
+      // Common ignores
+      '.storybook/**',
+      '**/__generated__/**',
+      '**/__mocks__/**',
+      '**/__snapshots__/**',
+      '**/coverage/**',
+      '**/dist/**',
+      '**/generated/**',
+      '**/i18next-parser.config.cjs',
+      '**/lint-staged.config.cjs',
+      '**/node_modules/**',
+      '**/packages/**/lib/**',
+      '**/pino-pretty.config.js',
+      '**/schema/**',
+      '**/storybook-static/**',
+      '**/.docusaurus/**',
+      '/website/**',
+      '/.build-*/**',
+      '/data',
+      '/docker',
+      'tools/**',
+    ],
+  },
+  {
+    plugins: {
+      '@typescript-eslint': typescript,
+      '@stylistic-eslint': stylistic,
+      sonarjs,
+      jsdoc,
+    },
+    languageOptions: {
+      ecmaVersion: 6,
+      sourceType: 'module',
+      parser: typescriptParser,
+      parserOptions: {
+        project: './tsconfig.eslint.json',
+        ecmaFeatures: {
+          jsx: true,
+        },
+      },
+    },
+    linterOptions: {
+      reportUnusedDisableDirectives: true,
+    },
+
+    settings: {
+      n: {
+        typescriptExtensionMap: [
+          ['', '.js'],
+          ['.ts', '.js'],
+          ['.cts', '.cjs'],
+          ['.mts', '.mjs'],
+          ['.tsx', '.js'],
+        ],
+      },
+    },
+    /* Rules applicable to all files (https://eslint.org/docs/rules) */
+    rules: {
+      /* Enforce best practices rules */
+      'accessor-pairs': 'off', // enforces getter/setter pairs in objects
+
+      'array-callback-return': ['error', { allowImplicit: true }], // enforces return statements in callbacks of array's methods
+
+      'block-scoped-var': 'error', // treat var statements as if they were block scoped
+
+      complexity: ['off', 20], // specify the maximum cyclomatic complexity allowed in a program
+
+      // enforce that class methods use "this"
+      'class-methods-use-this': [
+        2,
+        {
+          exceptMethods: [],
+        },
+      ],
+
+      // require return statements to either always or never specify values
+      'consistent-return': 'error',
+
+      // specify curly brace conventions for all control statements
+      curly: ['error', 'multi-line'], // multiline
+
+      // require default case in switch statements
+      'default-case': ['error', { commentPattern: '^no default$' }],
+
+      'default-case-last': 'error', // Enforce default clauses in switch statements to be last
+
+      'default-param-last': 'error',
+
+      'dot-notation': ['error', { allowKeywords: true }], // encourages use of dot notation whenever possible
+
+      'dot-location': ['error', 'property'], // enforces consistent newlines before or after dots
+
+      eqeqeq: ['error', 'always', { null: 'ignore' }], // require the use of === and !==
+
+      // Require grouped accessor pairs in object literals and classes
+      'grouped-accessor-pairs': 'error',
+
+      // make sure for-in loops have an if statement
+      'guard-for-in': 0,
+
+      'max-classes-per-file': ['error', 1], // enforce a maximum number of classes per file
+
+      'no-alert': 2, // disallow the use of alert, confirm, and prompt
+
+      'no-caller': 'error', // disallow use of arguments.caller or arguments.callee
+
+      'no-case-declarations': 'error', // disallow lexical declarations in case/default clauses
+
+      'no-constructor-return': 'error', // Disallow returning value in constructor
+
+      // disallow division operators explicitly at beginning of regular expression
+      'no-div-regex': 'off',
+
+      // disallow else after a return in an if
+      'no-else-return': ['error', { allowElseIf: false }],
+
+      'no-empty-function': 0, // disallow empty functions,- handle by typescript-eslint
+
+      'no-empty-pattern': 'error', // disallow empty destructuring patterns
+
+      'no-eq-null': 'off', // disallow comparisons to null without a type-checking operator
+
+      'no-eval': 'error', // disallow use of eval()
+
+      'no-extend-native': 'error', // disallow adding to native types
+
+      'no-extra-bind': 'error', // disallow unnecessary function binding
+
+      'no-extra-label': 'error', // disallow Unnecessary Labels
+
+      'no-fallthrough': 'error', // disallow fallthrough of case statements
+
+      // disallow the use of leading or trailing decimal points in numeric literals
+      'no-floating-decimal': 'error',
+
+      // disallow reassignments of native objects or read-only globals
+      'no-global-assign': ['error', { exceptions: [] }],
+
+      // disallow implicit type conversions
+      'no-implicit-coercion': [
+        'off',
+        {
+          boolean: false,
+          number: true,
+          string: true,
+          allow: [],
+        },
+      ],
+
+      'no-implicit-globals': 'off', // disallow var and named functions in global scope
+
+      'no-implied-eval': 0, // disallow use of eval()-like methods
+
+      // disallow this keywords outside of classes or class-like objects - checked by TS compiler
+      'no-invalid-this': 'off',
+
+      'no-iterator': 'error', // disallow usage of __iterator__ property
+
+      // disallow use of labels for anything other than loops and switches
+      'no-labels': ['error', { allowLoop: false, allowSwitch: false }],
+
+      'no-lone-blocks': 'error', // disallow unnecessary nested blocks
+
+      'no-loop-func': 'error', // disallow creation of functions within loops
+
+      // disallow use of multiple spaces
+      'no-multi-spaces': [
+        'error',
+        {
+          ignoreEOLComments: false,
+        },
+      ],
+
+      'no-multi-str': 'error', // disallow use of multiline strings
+
+      'no-new': 'error', // disallow use of new operator when not part of the assignment or comparison
+
+      'no-new-func': 'error', // disallow use of new operator for Function object
+
+      // disallows creating new instances of String, Number, and Boolean
+      'no-new-wrappers': 'error',
+
+      // Disallow \8 and \9 escape sequences in string literals
+      'no-nonoctal-decimal-escape': 'error',
+
+      'no-octal': 'error', // disallow use of (old style) octal literals
+
+      // disallow use of octal escape sequences in string literals, such as
+      // var foo = 'Copyright \251';
+      'no-octal-escape': 'error',
+
+      // disallow reassignment of function parameters
+      // disallow parameter object manipulation except for specific exclusions
+      'no-param-reassign': [
+        'error',
+        {
+          props: true,
+          ignorePropertyModificationsFor: [
+            'acc', // for reduce accumulators
+            'accumulator', // for reduce accumulators
+            'e', // for e.returnvalue
+            'ctx', // for Koa routing
+            'context', // for Koa routing
+            'req', // for Express requests
+            'request', // for Express requests
+            'res', // for Express responses
+            'response', // for Express responses
+            '$scope', // for Angular 1 scopes
+            'staticContext', // for ReactRouter context
+          ],
+        },
+      ],
+
+      'no-proto': 'error', // disallow usage of __proto__ property
+
+      'no-redeclare': 'error', // disallow declaring the same variable more than once
+
+      // disallow certain object properties
+      'no-restricted-properties': [
+        'error',
+        {
+          object: 'arguments',
+          property: 'callee',
+          message: 'arguments.callee is deprecated',
+        },
+        {
+          object: 'global',
+          property: 'isFinite',
+          message: 'Please use Number.isFinite instead',
+        },
+        {
+          object: 'self',
+          property: 'isFinite',
+          message: 'Please use Number.isFinite instead',
+        },
+        {
+          object: 'window',
+          property: 'isFinite',
+          message: 'Please use Number.isFinite instead',
+        },
+        {
+          object: 'global',
+          property: 'isNaN',
+          message: 'Please use Number.isNaN instead',
+        },
+        {
+          object: 'self',
+          property: 'isNaN',
+          message: 'Please use Number.isNaN instead',
+        },
+        {
+          object: 'window',
+          property: 'isNaN',
+          message: 'Please use Number.isNaN instead',
+        },
+        {
+          property: '__defineGetter__',
+          message: 'Please use Object.defineProperty instead.',
+        },
+        {
+          property: '__defineSetter__',
+          message: 'Please use Object.defineProperty instead.',
+        },
+        {
+          object: 'Math',
+          property: 'pow',
+          message: 'Use the exponentiation operator (**) instead.',
+        },
+      ],
+
+      // disallow use of assignment in return statement
+      'no-return-assign': ['error', 'always'],
+
+      'no-return-await': 'error', // disallow redundant `return await`
+
+      'no-script-url': 'error', // disallow use of `javascript:` urls.
+
+      // disallow self assignment
+      'no-self-assign': [
+        'error',
+        {
+          props: true,
+        },
+      ],
+
+      'no-self-compare': 'error', // disallow comparisons where both sides are exactly the same
+
+      'no-sequences': 'error', // disallow use of comma operator
+
+      // restrict what can be thrown as an exception - handle by typescript-eslint
+      'no-throw-literal': 'off', // handle by only-throw-error in typescript-eslint
+
+      // disallow unmodified conditions of loops
+      'no-unmodified-loop-condition': 'off',
+
+      // disallow usage of expressions in statement position - handle by typescript-eslint
+      'no-unused-expressions': 0,
+
+      'no-unused-labels': 'error', // disallow unused labels
+
+      'no-useless-call': 'off', // disallow unnecessary .call() and .apply()
+
+      'no-useless-catch': 'error', // Disallow unnecessary catch clauses
+
+      'no-useless-concat': 'error', // disallow useless string concatenation
+
+      'no-useless-escape': 'error', // disallow unnecessary string escaping
+
+      'no-useless-return': 'error', // disallow redundant return; keywords
+
+      'no-void': 'error', // disallow use of void operator
+
+      // disallow usage of configurable warning terms in comments: e.g. todo
+      'no-warning-comments': [
+        'off',
+        { terms: ['todo', 'fixme', 'xxx'], location: 'start' },
+      ],
+
+      'no-with': 'error', // disallow use of the with statement
+
+      // require using Error objects as Promise rejection reasons
+      'prefer-promise-reject-errors': ['error', { allowEmptyReject: true }],
+
+      // Suggest using named capture group in regular expression
+      'prefer-named-capture-group': 'off',
+
+      // Prefer Object.hasOwn() over Object.prototype.hasOwnProperty.call()
+      // TODO: semver-major: enable thus rule, once eslint v8.5.0 is required
+      'prefer-object-has-own': 'off',
+
+      // Disallow use of the RegExp constructor in favor of regular expression literals
+      'prefer-regex-literals': [
+        'error',
+        {
+          disallowRedundantWrapping: true,
+        },
+      ],
+
+      radix: 'error', // require use of the second argument for parseInt()
+
+      // require `await` in `async function` (note: this is a horrible rule that should never be used)
+      'require-await': 'off',
+
+      // Enforce the use of u flag on RegExp
+      'require-unicode-regexp': 'off',
+
+      'vars-on-top': 'error', // requires to declare all vars on top of their containing scope
+
+      // require immediate function invocation to be wrapped in parentheses
+      'wrap-iife': ['error', 'outside', { functionPrototypeMethods: false }],
+
+      yoda: 'error', // require or disallow Yoda conditions
+
+      /* Enforce Errors rules */
+
+      'for-direction': 'error', // Enforce “for” loop update clause moving the counter in the right direction
+
+      'getter-return': ['error', { allowImplicit: true }], // Enforces that a return statement is present in property getters
+
+      'no-async-promise-executor': 'error', // disallow using an async function as a Promise executor
+
+      'no-await-in-loop': 0, // Disallow await inside of loops
+
+      'no-compare-neg-zero': 'error', // Disallow comparisons to negative zero
+
+      'no-cond-assign': ['error', 'always'], // disallow assignment in conditional expressions
+
+      'no-console': 'warn', // disallow use of console
+
+      'no-constant-binary-expression': 2, // Disallows expressions where the operation doesn't affect the value
+
+      'no-constant-condition': 'warn', // disallow use of constant expressions in conditions
+
+      'no-control-regex': 'error', // disallow control characters in regular expressions
+
+      'no-debugger': 'error', // disallow use of debugger
+
+      'no-dupe-args': 'error', // disallow duplicate arguments in functions
+
+      'no-dupe-else-if': 'error', // Disallow duplicate conditions in if-else-if chains
+
+      'no-dupe-keys': 'error', // disallow duplicate keys when creating object literals
+
+      'no-duplicate-case': 'error', // disallow a duplicate case label.
+
+      'no-empty': 'error', // disallow empty statements
+
+      // disallow the use of empty character classes in regular expressions
+      'no-empty-character-class': 'error',
+
+      // disallow assigning to the exception in a catch block
+      'no-ex-assign': 'error',
+
+      // disallow double-negation boolean casts in a boolean context
+      'no-extra-boolean-cast': 'error',
+
+      'no-func-assign': 'error', // disallow overwriting functions written as function declarations
+
+      'no-import-assign': 'error', // Disallow assigning to imported bindings
+
+      'no-inner-declarations': 'error', // disallow function or variable declarations in nested blocks
+
+      'no-invalid-regexp': 'error', // disallow invalid regular expression strings in the RegExp constructor
+
+      'no-irregular-whitespace': 'error', // disallow irregular whitespace outside of strings and comments
+
+      'no-loss-of-precision': 'error', // Disallow Number Literals That Lose Precision
+
+      // Disallow characters which are made with multiple code points in character class syntax
+      'no-misleading-character-class': 'error',
+
+      // disallow the use of object properties of the global object (Math and JSON) as functions
+      'no-obj-calls': 'error',
+
+      // Disallow returning values from Promise executor functions
+      'no-promise-executor-return': 'error',
+
+      // disallow use of Object.prototypes builtins directly
+      'no-prototype-builtins': 'error',
+
+      'no-regex-spaces': 'error', // disallow multiple spaces in a regular expression literal
+
+      'no-setter-return': 'error', // Disallow returning values from setters
+
+      'no-sparse-arrays': 'error', // disallow sparse arrays
+
+      // Disallow template literal placeholder syntax in regular strings
+      'no-template-curly-in-string': 'error',
+
+      // Avoid code that looks like two expressions but is actually one
+      'no-unexpected-multiline': 'error',
+
+      // disallow unreachable statements after a return, throw, continue, or break statement
+      'no-unreachable': 'error',
+
+      // Disallow loops with a body that allows only one iteration
+      'no-unreachable-loop': [
+        'error',
+        {
+          // WhileStatement, DoWhileStatement, ForStatement, ForInStatement, ForOfStatement
+          ignore: [],
+        },
+      ],
+
+      'no-unsafe-finally': 'error', // disallow return/throw/break/continue inside finally blocks
+
+      // disallow negating the left operand of relational operators
+      'no-unsafe-negation': 'error',
+
+      // disallow use of optional chaining in contexts where the undefined value is not allowed
+      'no-unsafe-optional-chaining': [
+        'error',
+        { disallowArithmeticOperators: true },
+      ],
+
+      'no-unused-private-class-members': 1, // Disallow Unused Private Class Members
+
+      'no-useless-backreference': 'error', // Disallow useless backreferences in regular expressions
+
+      // Disallow assignments that can lead to race conditions due to usage of await or yield
+      // note: not enabled because it is very buggy
+      'require-atomic-updates': 0,
+
+      'use-isnan': 'error', // disallow comparisons with the value NaN
+
+      // ensure that the results of typeof are compared against a valid string
+      'valid-typeof': ['error', { requireStringLiterals: true }],
+
+      /* Enforce  es6 rules */
+      // enforces no braces where they can be omitted
+      'arrow-body-style': ['error', 'always'],
+
+      'arrow-parens': ['error', 'always'], // require parens in arrow function arguments
+
+      // require space before/after arrow function's arrow
+      'arrow-spacing': ['error', { before: true, after: true }],
+
+      'constructor-super': 'error', // verify super() callings in constructors
+
+      // enforce the spacing around the * in generator functions
+      'generator-star-spacing': ['error', { before: false, after: true }],
+
+      'no-class-assign': 'error', // disallow modifying variables of class declarations
+
+      // disallow arrow functions where they could be confused with comparisons
+      'no-confusing-arrow': [
+        'error',
+        {
+          allowParens: true,
+        },
+      ],
+
+      'no-const-assign': 'error', // disallow modifying variables that are declared using const
+
+      'no-dupe-class-members': 0, // disallow duplicate class members - handle by typescript-eslint
+
+      'no-duplicate-imports': 2, // disallow importing from the same path more than once
+
+      'no-new-symbol': 'error', // disallow symbol constructor
+
+      // Disallow specified names in exports
+      'no-restricted-exports': [
+        'error',
+        {
+          restrictedNamedExports: [
+            'default', // use `export default` to provide a default export
+            'then', // this will cause tons of confusion when your module is dynamically `import()`ed, and will break in most node ESM versions
+          ],
+        },
+      ],
+
+      // disallow specific imports
+      'no-restricted-imports': [
+        'off',
+        {
+          paths: [],
+          patterns: [],
+        },
+      ],
+
+      'no-this-before-super': 'error', // disallow to use this/super before super() calling in constructors.
+
+      'no-useless-computed-key': 'error', // disallow useless computed property keys
+
+      'no-useless-constructor': 0, // disallow unnecessary constructor - handle by typescript-eslint
+
+      // disallow renaming import, export, and destructured assignments to the same name
+      'no-useless-rename': [
+        'error',
+        {
+          ignoreDestructuring: false,
+          ignoreImport: false,
+          ignoreExport: false,
+        },
+      ],
+
+      'no-var': 'error', // require let or const instead of var
+
+      // require method and property shorthand syntax for object literals
+      'object-shorthand': [
+        'error',
+        'always',
+        {
+          ignoreConstructors: false,
+          avoidQuotes: true,
+        },
+      ],
+
+      // suggest using arrow functions as callbacks
+      'prefer-arrow-callback': [
+        'error',
+        {
+          allowNamedFunctions: false,
+          allowUnboundThis: true,
+        },
+      ],
+
+      // suggest using of const declaration for variables that are never modified after declared
+      'prefer-const': [
+        'error',
+        {
+          destructuring: 'any',
+          ignoreReadBeforeAssign: true,
+        },
+      ],
+
+      // Prefer destructuring from arrays and objects
+      'prefer-destructuring': [
+        'error',
+        {
+          VariableDeclarator: {
+            array: false,
+            object: true,
+          },
+          AssignmentExpression: {
+            array: true,
+            object: false,
+          },
+        },
+        {
+          enforceForRenamedProperties: false,
+        },
+      ],
+
+      'prefer-numeric-literals': 'error', // disallow parseInt() in favor of binary, octal, and hexadecimal literals
+
+      'prefer-reflect': 'off', // suggest using Reflect methods where applicable
+
+      'prefer-rest-params': 'error', // use rest parameters instead of arguments
+
+      'prefer-spread': 'error', // suggest using the spread syntax instead of .apply()
+
+      'prefer-template': 'error', // suggest using template literals instead of string concatenation
+
+      'require-yield': 'error', // disallow generator functions that do not have yield
+
+      'rest-spread-spacing': ['error', 'never'], // enforce spacing between object rest-spread
+
+      // import sorting
+      'sort-imports': [
+        'off',
+        {
+          ignoreCase: false,
+          ignoreDeclarationSort: false,
+          ignoreMemberSort: false,
+          memberSyntaxSortOrder: ['none', 'all', 'multiple', 'single'],
+        },
+      ],
+
+      'symbol-description': 'error', // require a Symbol description
+
+      'template-curly-spacing': 'error', // enforce usage of spacing in template strings
+
+      'yield-star-spacing': ['error', 'after'], // enforce spacing around the * in yield* expressions
+
+      /* Enforce node rules://eslint - https://eslint.org/docs/latest/rules/ */
+
+      'callback-return': 'off', // enforce return after a callback
+
+      'global-require': 'error', // require all requires be top-level
+
+      'handle-callback-err': 'off', // enforces error handling in callbacks (node environment)
+
+      'no-buffer-constructor': 'error', // disallow use of the Buffer() constructor
+
+      'no-mixed-requires': ['off', false], // disallow mixing regular variable and require declarations
+
+      'no-new-require': 'error', // disallow use of new operator with the require function
+
+      'no-path-concat': 'error', // disallow string concatenation with __dirname and __filename
+
+      'no-process-env': 'off', // disallow use of process.env
+
+      'no-process-exit': 'off', // disallow process.exit()
+
+      'no-restricted-modules': 'off', // restrict usage of specified node modules
+
+      'no-sync': 'off', // disallow use of synchronous methods (off by default)
+
+      /* Enforce strict rules */
+
+      strict: ['error', 'never'], // babel inserts `'use strict';` for us
+
+      /* Enforce style rules */
+
+      'no-ternary': ['error'], // disallow the use of ternary operators
+
+      // disallow trailing whitespace at the end of lines
+      'no-trailing-spaces': [
+        'error',
+        {
+          skipBlankLines: false,
+          ignoreComments: false,
+        },
+      ],
+
+      // disallow dangling underscores in identifiers
+      'no-underscore-dangle': [
+        0,
+        {
+          allow: [],
+          allowAfterThis: false,
+          allowAfterSuper: false,
+          enforceInMethodNames: true,
+        },
+      ],
+
+      // disallow the use of Boolean literals in conditional expressions
+      // also, prefer `a || b` over `a ? a : b`
+      'no-unneeded-ternary': ['error', { defaultAssignment: false }],
+
+      // disallow whitespace before properties
+      '@stylistic-eslint/no-whitespace-before-property': 2,
+
+      // enforce the location of single-line statements
+      'nonblock-statement-body-position': [
+        'error',
+        'beside',
+        { overrides: {} },
+      ],
+
+      '@stylistic-eslint/object-curly-spacing': ['error', 'always'], // require padding inside curly braces
+
+      // enforce line breaks between braces
+      'object-curly-newline': [
+        0,
+        {
+          ObjectExpression: {
+            minProperties: 4,
+            multiline: true,
+            consistent: true,
+          },
+          ObjectPattern: {
+            minProperties: 4,
+            multiline: true,
+            consistent: true,
+          },
+          ImportDeclaration: {
+            minProperties: 4,
+            multiline: true,
+            consistent: true,
+          },
+          ExportDeclaration: {
+            minProperties: 4,
+            multiline: true,
+            consistent: true,
+          },
+        },
+      ],
+
+      // enforce "same line" or "multiple line" on object properties.
+      'object-property-newline': [
+        'error',
+        {
+          allowAllPropertiesOnSameLine: true,
+        },
+      ],
+
+      'one-var': ['error', 'never'], // allow just one var statement per function
+
+      'one-var-declaration-per-line': ['error', 'always'], // require a newline around variable declaration
+
+      // require assignment operator shorthand where possible or prohibit it entirely
+      'operator-assignment': ['error', 'always'],
+
+      // Requires operator at the beginning of the line in multiline statements
+      '@stylistic-eslint/operator-linebreak': [
+        'error',
+        'after',
+        { overrides: { '?': 'before', ':': 'before' } },
+      ],
+
+      // disallow padding within blocks
+      '@stylistic-eslint/padded-blocks': [
+        'error',
+        {
+          blocks: 'never',
+          classes: 'never',
+          switches: 'never',
+        },
+        {
+          allowSingleLineBlocks: true,
+        },
+      ],
+
+      // Require or disallow padding lines between statements
+      '@stylistic-eslint/padding-line-between-statements': 'off',
+
+      // Disallow the use of Math.pow in favor of the ** operator
+      'prefer-exponentiation-operator': 'error',
+
+      'prefer-object-spread': 'error', // Prefer use of an object spread over Object.assign
+
+      // require quotes around object literal property names
+      '@stylistic-eslint/quote-props': [
+        'error',
+        'as-needed',
+        { keywords: false, unnecessary: true, numbers: false },
+      ],
+
+      // specify whether double or single quotes should be used
+      '@stylistic-eslint/quotes': ['error', 'single', { avoidEscape: true }],
+
+      // require or disallow use of semicolons instead of ASI
+      '@stylistic-eslint/semi': ['error', 'always'],
+
+      '@stylistic-eslint/no-extra-semi': 'error',
+
+      // enforce spacing before and after semicolons
+      '@stylistic-eslint/semi-spacing': [
+        'error',
+        { before: false, after: true },
+      ],
+
+      '@stylistic-eslint/semi-style': ['error', 'last'], // Enforce location of semicolons
+
+      // requires object keys to be sorted
+      'sort-keys': ['off', 'asc', { caseSensitive: false, natural: true }],
+
+      'sort-vars': 'off', // sort variables within the same declaration block
+
+      // require or disallow space before blocks
+      '@stylistic-eslint/space-before-blocks': 'error',
+
+      // require or disallow space before function opening parenthesis
+      '@stylistic-eslint/space-before-function-paren': [
+        'error',
+        {
+          anonymous: 'always',
+          named: 'never',
+          asyncArrow: 'always',
+        },
+      ],
+
+      // require or disallow spaces inside parentheses
+      '@stylistic-eslint/space-in-parens': ['error', 'never'],
+
+      '@stylistic-eslint/space-infix-ops': 'error', // require spaces around operators
+
+      // Require or disallow spaces before/after unary operators
+      '@stylistic-eslint/space-unary-ops': [
+        'error',
+        {
+          words: true,
+          nonwords: false,
+          overrides: {},
+        },
+      ],
+
+      // require or disallow a space immediately following the // or /* in a comment
+      '@stylistic-eslint/spaced-comment': [
+        'error',
+        'always',
+        {
+          line: {
+            exceptions: ['-', '+'],
+            markers: ['=', '!', '/'], // space here to support sprockets directives, slash for TS /// comments
+          },
+          block: {
+            exceptions: ['-', '+'],
+            markers: ['=', '!', ':', '::'], // space here to support sprockets directives and flow comment types
+            balanced: true,
+          },
+        },
+      ],
+
+      // Enforce spacing around colons of switch statements
+      '@stylistic-eslint/switch-colon-spacing': [
+        'error',
+        { after: true, before: false },
+      ],
+
+      // Require or disallow spacing between template tags and their literals
+      '@stylistic-eslint/template-tag-spacing': ['error', 'never'],
+
+      'unicode-bom': ['error', 'never'], // require or disallow the Unicode Byte Order Mark
+
+      '@stylistic-eslint/wrap-regex': 'off', // require regex literals to be wrapped in parentheses
+
+      /* Enforce variables rules */
+      'init-declarations': 'off',
+      'no-array-constructor': 'off', // disallow use of the Array constructor - handle by typescript-eslint
+      'no-catch-shadow': 'off',
+      'no-delete-var': 'error',
+      'no-label-var': 'error',
+      'no-restricted-globals': [
+        'error',
+        {
+          name: 'isFinite',
+          message:
+            'Use Number.isFinite instead https://github.com/airbnb/javascript#standard-library--isfinite',
+        },
+        {
+          name: 'isNaN',
+          message:
+            'Use Number.isNaN instead https://github.com/airbnb/javascript#standard-library--isnan',
+        },
+      ].concat(confusingBrowserGlobals),
+
+      'no-shadow': 0, // disallow declaration of variables already declared in the outer scope
+
+      'no-shadow-restricted-names': 'error', // disallow shadowing of names such as arguments
+
+      'no-undef': 'error', // disallow use of undeclared variables unless mentioned in a /*global */ block
+
+      'no-undef-init': 'error', // disallow use of undefined when initializing variables
+
+      // Alternative with no-undef-init , no-shadow-restricted-names, no-global-assign activated
+      'no-undefined': 'off', // disallow use of undefined variable
+
+      // disallow declaration of variables that are not used in the code - handle by typescript-eslint
+      'no-unused-vars': 'off',
+
+      // disallow use of variables before they are defined - handle by typescript-eslint
+      'no-use-before-define': 'off',
+
+      'no-restricted-syntax': [
+        'error',
+        {
+          selector:
+            "CallExpression[callee.name='setTimeout'][arguments.length!=2]",
+          message: 'setTimeout must always be invoked with two arguments.',
+        },
+        {
+          selector: 'LabeledStatement',
+          message:
+            'Labels are a form of GOTO; using them makes code confusing and hard to maintain and understand.',
+        },
+        {
+          selector: 'WithStatement',
+          message:
+            '`with` is disallowed in strict mode because it makes code impossible to predict and optimize.',
+        },
+      ],
+
+      '@stylistic-eslint/comma-dangle': [
+        'error',
+        {
+          arrays: 'always-multiline',
+          enums: 'always-multiline',
+          exports: 'always-multiline',
+          functions: 'always-multiline',
+          generics: 'always-multiline',
+          imports: 'always-multiline',
+          objects: 'always-multiline',
+          tuples: 'always-multiline',
+        },
+      ],
+
+      '@stylistic-eslint/max-len': [
+        'error',
+        {
+          code: 100,
+          comments: 110,
+          ignoreTemplateLiterals: true,
+          ignoreStrings: true,
+        },
+      ],
+      '@typescript-eslint/naming-convention': [
+        'error',
+        {
+          selector: 'default',
+          format: ['camelCase'],
+        },
+        {
+          selector: 'default',
+          format: ['camelCase'],
+          modifiers: ['unused'],
+          leadingUnderscore: 'allow',
+        },
+        {
+          selector: 'variable', // variables that does not include _id or __ properties
+          format: ['camelCase', 'UPPER_CASE', 'PascalCase'],
+          filter: {
+            regex: "^(?!.*(__|'*_id)).*$",
+            match: true,
+          },
+        },
+        {
+          selector: 'variable', // variable with leadingUnderscore: 'allow',
+          format: null,
+          prefix: ['__'],
+          filter: {
+            regex: '^__',
+            match: true,
+          },
+        },
+        {
+          selector: 'variable', // _id or _id.index... variables
+          custom: {
+            regex: '^_id(\\.[a-z]+([A-Z][a-z]+)*)*',
+            match: true,
+          },
+          format: null,
+        },
+        {
+          selector: 'enumMember',
+          format: ['PascalCase'],
+        },
+        {
+          selector: 'enum',
+          format: ['PascalCase'],
+        },
+        {
+          selector: 'variable',
+          types: ['boolean'],
+          format: ['PascalCase'],
+          prefix: ['is', 'should', 'has', 'can', 'did', 'will'],
+        },
+        {
+          selector: 'parameter',
+          format: ['camelCase', 'PascalCase'],
+          leadingUnderscore: 'allow',
+        },
+        {
+          selector: 'parameterProperty',
+          format: ['camelCase', 'UPPER_CASE', 'PascalCase'],
+          leadingUnderscore: 'allow',
+        },
+        {
+          selector: 'memberLike', // leadingUnderscore: 'allow',
+          modifiers: ['protected'],
+          format: ['camelCase'],
+          prefix: ['_'],
+          filter: {
+            regex: '^_',
+            match: true,
+          },
+        },
+        {
+          selector: 'memberLike', // leadingUnderscore: 'allow',
+          modifiers: ['private'],
+          format: ['camelCase'],
+          prefix: ['__'],
+          filter: {
+            regex: '^__',
+            match: true,
+          },
+        },
+        {
+          selector: 'memberLike', // all that is not including _id or __ properties
+          format: ['camelCase', 'PascalCase'],
+          filter: {
+            regex: "^(?!.*(__|\\.|'*_id)).*$",
+            match: true,
+          },
+        },
+        {
+          selector: 'memberLike', // _id or _id.index... properties
+          custom: {
+            regex:
+              '((?<_idProperties>^_id(\\.[a-z]+([A-Z][a-z]+)*)*)|(?<double_snake>^([a-zA-Z0-9]+)(__([a-zA-Z0-9]+))+))',
+            match: true,
+          },
+          format: null,
+        },
+        {
+          selector: 'property', // Properties camelCase.camelCase
+          format: null,
+          filter: {
+            regex:
+              '(?<dot_camelCase>[a-z]+([A-Z][a-z]+)*(\\.[a-z]+([A-Z][a-z]+)*)*)',
+            match: true,
+          },
+        },
+        {
+          selector: 'objectLiteralProperty', // object propertie  .camelCase properties
+          format: null,
+          filter: {
+            regex: '(?<start_with_dot_camelCase>(^\\.[a-z]+([A-Z][a-z]+)*)*)',
+            match: true,
+          },
+        },
+        {
+          selector: 'objectLiteralProperty', // object propertie  /camelCase properties
+          format: null,
+          filter: {
+            regex: '(?<slash_camelCase>(^/[a-z]+([A-Z][a-z]+)*)*)',
+            match: true,
+          },
+        },
+        {
+          selector: 'property',
+          filter: {
+            regex: '(?<At_Properties>^@[a-zA-Z0-9]+(_[a-zA-Z0-9]+)*)',
+            match: true,
+          },
+          format: null,
+        },
+        {
+          selector: 'property', // Properties $operator
+          filter: {
+            regex: '(?<$_operator>^$([a-zA-Z0-9]+))',
+            match: true,
+          },
+          format: null,
+        },
+        {
+          selector: 'property',
+          filter: {
+            regex:
+              '(?<snake_extendedCamelCase>^([a-zA-Z0-9]+)(_([a-zA-Z0-9]+))*)',
+            match: true,
+          },
+          format: null,
+        },
+        {
+          selector: 'classProperty',
+          format: ['camelCase'],
+          prefix: ['__'],
+          filter: {
+            regex: '^__',
+            match: true,
+          },
+        },
+        {
+          selector: 'typeLike',
+          format: ['PascalCase'],
+        },
+        {
+          selector: 'import',
+          format: null,
+        },
+      ],
+
+      '@typescript-eslint/strict-boolean-expressions': [
+        'error',
+        {
+          allowString: false,
+          allowNumber: false,
+          allowNullableObject: false,
+          allowNullableBoolean: true,
+          allowNullableString: false,
+          allowNullableNumber: false,
+          allowAny: false,
+          allowRuleToRunWithoutStrictNullChecksIKnowWhatIAmDoing: false,
+        },
+      ],
+      '@stylistic-eslint/no-extra-parens': [
+        'off',
+        'all',
+        {
+          conditionalAssign: true,
+          nestedBinaryExpressions: false,
+          returnAssign: false,
+          ignoreJSX: 'all', // delegate to eslint-plugin-react
+          enforceForArrowConditionals: false,
+        },
+      ],
+      '@typescript-eslint/no-empty-function': [
+        'error',
+        {
+          allow: ['arrowFunctions', 'functions', 'methods'],
+        },
+      ],
+      '@stylistic-eslint/no-magic-numbers': [
+        'off',
+        {
+          ignore: [],
+          ignoreArrayIndexes: true,
+          enforceConst: true,
+          detectObjects: false,
+        },
+      ],
+      '@typescript-eslint/no-unused-expressions': [
+        'error',
+        {
+          allowShortCircuit: false,
+          allowTernary: false,
+          allowTaggedTemplates: false,
+        },
+      ],
+      '@typescript-eslint/no-unused-vars': [
+        'error',
+        { vars: 'all', args: 'after-used', ignoreRestSiblings: true },
+      ],
+      '@typescript-eslint/no-use-before-define': [
+        'error',
+        { functions: true, classes: true, variables: true },
+      ],
+
+      '@stylistic-eslint/adjacent-overload-signatures': 'off',
+      '@typescript-eslint/array-type': ['error'],
+      '@typescript-eslint/await-thenable': ['error'],
+      '@typescript-eslint/ban-ts-comment': [
+        'error',
+        {
+          'ts-expect-error': 'allow-with-description',
+          minimumDescriptionLength: 3,
+        },
+      ],
+      '@typescript-eslint/ban-tslint-comment': ['error'],
+      '@typescript-eslint/no-restricted-types': 2,
+      '@typescript-eslint/no-empty-object-type': 2,
+      '@typescript-eslint/no-unsafe-function-type': 2,
+      '@typescript-eslint/no-wrapper-object-types': 2,
+      '@stylistic-eslint/brace-style': 'off',
+      '@stylistic-eslint/class-literal-property-style': 'off',
+      '@stylistic-eslint/comma-spacing': [
+        'error',
+        { before: false, after: true },
+      ],
+      '@typescript-eslint/consistent-generic-constructors': ['error'],
+      '@typescript-eslint/consistent-indexed-object-style': ['error', 'record'],
+      '@typescript-eslint/consistent-type-assertions': ['error'],
+      '@typescript-eslint/consistent-type-definitions': 'off',
+      '@typescript-eslint/consistent-type-exports': 'off',
+      '@typescript-eslint/consistent-type-imports': 'off',
+      // Activate explicit-module-boundary-type as an alternative
+      '@typescript-eslint/explicit-function-return-type': 'off',
+      '@typescript-eslint/explicit-member-accessibility': ['error'],
+      '@typescript-eslint/explicit-module-boundary-types': 2,
+      '@stylistic-eslint/func-call-spacing': ['error', 'never'],
+      '@stylistic-eslint/indent': 0,
+      '@stylistic-eslint/member-delimiter-style': ['error'],
+      '@typescript-eslint/member-ordering': ['error'],
+      '@typescript-eslint/method-signature-style': ['error'],
+      '@typescript-eslint/no-array-constructor': 'error',
+      '@typescript-eslint/no-base-to-string': ['error'],
+      '@typescript-eslint/no-confusing-non-null-assertion': ['error'],
+      '@typescript-eslint/no-confusing-void-expression': ['error'],
+      '@typescript-eslint/no-duplicate-enum-values': ['error'],
+      '@typescript-eslint/no-dupe-class-members': 0, // automatically checked by the TypeScript compiler
+      '@typescript-eslint/no-dynamic-delete': ['error'],
+      '@typescript-eslint/no-empty-interface': ['error'],
+      '@typescript-eslint/no-explicit-any': [2],
+      '@typescript-eslint/no-extra-non-null-assertion': ['error'],
+      '@typescript-eslint/no-extraneous-class': ['error'],
+      '@typescript-eslint/no-floating-promises': ['error'],
+      '@typescript-eslint/no-for-in-array': ['error'],
+      '@typescript-eslint/no-implied-eval': 'error',
+      '@typescript-eslint/no-inferrable-types': ['error'],
+      '@typescript-eslint/no-invalid-void-type': ['error'],
+      '@typescript-eslint/no-meaningless-void-operator': ['error'],
+      '@typescript-eslint/no-misused-new': ['error'],
+      '@typescript-eslint/no-misused-promises': ['error'],
+      '@typescript-eslint/no-namespace': ['error'],
+      '@typescript-eslint/no-non-null-asserted-nullish-coalescing': ['error'],
+      '@typescript-eslint/no-non-null-asserted-optional-chain': ['error'],
+      '@typescript-eslint/no-non-null-assertion': ['error'],
+      '@typescript-eslint/no-redundant-type-constituents': 'error',
+      '@typescript-eslint/no-require-imports': 'off',
+      '@typescript-eslint/no-this-alias': ['error'],
+      '@typescript-eslint/only-throw-error': 'error',
+      '@typescript-eslint/no-unnecessary-boolean-literal-compare': ['error'],
+      '@typescript-eslint/no-unnecessary-condition': ['error'],
+      '@typescript-eslint/no-unnecessary-qualifier': ['error'],
+      '@typescript-eslint/no-unnecessary-type-arguments': ['error'],
+      '@typescript-eslint/no-unnecessary-type-assertion': ['error'],
+      '@typescript-eslint/no-unnecessary-type-constraint': ['error'],
+      '@typescript-eslint/no-unsafe-argument': 'off',
+      '@typescript-eslint/no-unsafe-assignment': 0,
+      '@typescript-eslint/no-unsafe-call': ['warn'],
+      '@typescript-eslint/no-unsafe-member-access': [1],
+      '@typescript-eslint/no-unsafe-return': ['warn'],
+      '@typescript-eslint/no-useless-empty-export': 'off',
+      '@typescript-eslint/no-useless-constructor': 'error',
+      '@typescript-eslint/no-var-requires': 'off',
+      '@typescript-eslint/non-nullable-type-assertion-style': ['error'],
+      '@typescript-eslint/parameter-properties': 'off',
+      '@typescript-eslint/prefer-as-const': ['error'],
+      '@typescript-eslint/prefer-enum-initializers': ['error'],
+      '@typescript-eslint/prefer-for-of': ['error'],
+      '@typescript-eslint/prefer-function-type': ['error'],
+      '@typescript-eslint/prefer-includes': ['error'],
+      '@typescript-eslint/prefer-literal-enum-member': ['error'],
+      '@typescript-eslint/prefer-namespace-keyword': ['error'],
+      '@typescript-eslint/prefer-nullish-coalescing': ['error'],
+      '@typescript-eslint/prefer-optional-chain': ['error'],
+      '@typescript-eslint/prefer-readonly-parameter-types': 'off', // ['error'],
+      '@typescript-eslint/prefer-readonly': 'off',
+      '@typescript-eslint/prefer-reduce-type-parameter': ['error'],
+      '@typescript-eslint/prefer-regexp-exec': ['error'],
+      '@typescript-eslint/prefer-return-this-type': ['error'],
+      '@typescript-eslint/prefer-string-starts-ends-with': ['error'],
+      '@typescript-eslint/promise-function-async': ['error'],
+      '@typescript-eslint/require-array-sort-compare': ['error'],
+      '@typescript-eslint/restrict-plus-operands': ['error'],
+      '@typescript-eslint/restrict-template-expressions': ['error'],
+      '@typescript-eslint/switch-exhaustiveness-check': ['error'],
+      '@typescript-eslint/triple-slash-reference': ['error'],
+      '@stylistic-eslint/type-annotation-spacing': ['error'],
+      '@typescript-eslint/typedef': 'off',
+      '@typescript-eslint/unbound-method': ['error'],
+      '@typescript-eslint/unified-signatures': ['error'],
+
+      'brace-style': 'off',
+      'func-style': ['error', 'declaration'],
+
+      'no-continue': 1,
+
+      'jsdoc/require-param-description': 0,
+      'jsdoc/require-param-type': 0,
+      'jsdoc/require-param': 0,
+      'jsdoc/require-returns-type': 0,
+      'jsdoc/require-returns': 0,
+      'jsdoc/require-yields': 0,
+
+      camelcase: 'off',
+
+      indent: 'off',
+
+      'sonarjs/no-duplicate-string': 'error',
+      // Lot of new rules, we disable them for now
+      'sonarjs/concise-regex': 0,
+      'sonarjs/default-param-last': 0,
+      'sonarjs/deprecation': 0,
+      'sonarjs/duplicates-in-character-class': 0,
+      'sonarjs/function-return-type': 0,
+      'sonarjs/hashing': 0,
+      'sonarjs/no-base-to-string': 0,
+      'sonarjs/no-commented-code': 0,
+      'sonarjs/no-dead-store': 0,
+      'sonarjs/no-duplicate-string': 1,
+      'sonarjs/no-empty-function': 0,
+      'sonarjs/no-hardcoded-credentials': 0,
+      'sonarjs/no-ignored-exceptions': 0,
+      'sonarjs/no-incomplete-assertions': 0,
+      'sonarjs/no-misused-promises': 0,
+      'sonarjs/no-nested-functions': 0,
+      'sonarjs/no-redundant-optional': 0,
+      'sonarjs/no-redundant-type-constituents': 0,
+      'sonarjs/no-useless-intersection': 0,
+      'sonarjs/prefer-for-of': 0,
+      'sonarjs/pseudo-random': 0,
+      'sonarjs/redundant-type-aliases': 0,
+      'sonarjs/single-character-alternation': 0,
+      'sonarjs/slow-regex': 0,
+      'sonarjs/sonar-no-control-regex': 0,
+      'sonarjs/sonar-no-unused-vars': 0,
+      'sonarjs/todo-tag': 0,
+    },
+  },
+  {
+    files: ['**/*.js', '**/*.ts', '**/*.tsx'],
+    plugins: {
+      '@typescript-eslint': typescript,
+      jsdoc,
+      '@stylistic-eslint': stylistic,
+      'react-hooks': reactHooksPlugin,
+      sonarjs,
+    },
+    rules: {
+      // Disable `no-undef` rule within TypeScript files because it incorrectly
+      // errors when exporting default interfaces
+      // https://github.com/iamturns/eslint-config-airbnb-typescript/issues/50
+      // This will be caught by TypeScript compiler if `strictNullChecks` (or `strict`) is enabled
+      'no-undef': 'off',
+
+      /* Using TypeScript makes it safe enough to disable the checks below */
+
+      '@typescript-eslint/default-param-last': 'error',
+      'dot-notation': 0,
+      '@typescript-eslint/dot-notation': 'error',
+      '@typescript-eslint/no-misused-promises': 'error',
+      'default-param-last': 0,
+      'implicit-arrow-linebreak': 'error',
+
+      'jsdoc/check-tag-names': 0,
+      'jsdoc/no-undefined-types': 0,
+      'jsdoc/require-jsdoc': 2,
+      'jsdoc/require-param-description': 0,
+      'jsdoc/require-param-type': 0,
+      'jsdoc/require-param': 0,
+      'jsdoc/require-property-name': 0,
+      'jsdoc/require-property-type': 0,
+      'jsdoc/require-returns': 0,
+      '@stylistic-eslint/jsx-one-expression-per-line': 0,
+      '@stylistic-eslint/jsx-props-no-spreading': 0,
+
+      'react-hooks/exhaustive-deps': 'error',
+      'react-hooks/rules-of-hooks': 'error',
+      'sonarjs/no-identical-functions': 'error',
+      'sonarjs/no-redundant-jump': 'error',
+      'sonarjs/no-collapsible-if': 'error',
+    },
+  },
+  {
+    files: [
+      '**/*.config.js',
+      '**/*.config.cjs',
+      '**/packages/eslint-config-*/index.js',
+    ],
+    plugins: {
+      '@typescript-eslint': typescript,
+      '@stylistic-eslint': stylistic,
+      sonarjs,
+    },
+    rules: {
+      '@stylistic-eslint/max-len': 0,
+      '@typescript-eslint/naming-convention': 0,
+      'sonarjs/no-duplicate-string': 0,
+      'no-dupe-keys': 0,
+      'no-undef': 0,
+    },
+  },
+  {
+    files: ['**/*.tsx'],
+    rules: {
+      'func-style': 0,
+    },
+  },
+  // Additional for projects or packages files
+  {
+    files: [
+      'packages/**/*.ts',
+      'packages/**/*.tsx',
+      'projects/**/*.js',
+      'projects/**/*.ts',
+      'projects/**/*.tsx',
+      'vite.config.ts',
+    ],
+    plugins: {
+      n,
+      '@typescript-eslint': typescript,
+      '@stylistic-eslint': stylistic,
+      jsdoc,
+    },
+    ignores: ['**/*.test.ts'],
+    rules: {
+      '@stylistic-eslint/function-paren-newline': [
+        'error',
+        'multiline-arguments',
+      ],
+      'n/file-extension-in-import': ['error', 'always'],
+
+      '@typescript-eslint/camelcase': 0,
+      '@typescript-eslint/consistent-indexed-object-style': ['error', 'record'],
+      '@typescript-eslint/no-unsafe-return': 0,
+      'jsdoc/require-param-description': 0,
+      'jsdoc/require-param-type': 0,
+      'jsdoc/require-param': 0,
+      'jsdoc/require-returns-type': 0,
+      'jsdoc/require-returns': 0,
+      'jsdoc/require-yields': 0,
+      '@stylistic-eslint/jsx-one-expression-per-line': 0,
+      '@typescript-eslint/no-misused-promises': ['error'],
+      '@typescript-eslint/no-unsafe-call': 2,
+      '@typescript-eslint/consistent-type-exports': 'error',
+      '@typescript-eslint/consistent-type-imports': [
+        2,
+        {
+          fixStyle: 'inline-type-imports',
+        },
+      ],
+    },
+  },
+
+  // Additional config for test files
+  {
+    files: ['**/*.test.tsx', '**/*.test.ts'],
+    plugins: {
+      sonarjs,
+      jsdoc,
+    },
+    rules: {
+      'jsdoc/require-jsdoc': 2,
+      'jsdoc/check-tag-names': 0,
+      'sonarjs/no-duplicate-string': 1,
+      'no-undef': 0,
+    },
+  },
+  {
+    files: [
+      '**/__mocks__/**/*.ts',
+      'src/backend/mongodb/seeds/collections/*.ts',
+    ],
+    rules: {
+      'jsdoc/require-jsdoc': 0,
+    },
+  },
+  // Additionnal for css files
+  {
+    files: ['**/*.css.ts'],
+    plugins: {
+      '@typescript-eslint': typescript,
+    },
+    rules: {
+      '@typescript-eslint/no-unsafe-call': 0,
+    },
+  },
+  // Additional for storybook files
+  {
+    files: ['stories/**'],
+    rules: {
+      'implicit-arrow-linebreak': 0,
+      'arrow-body-style': 0,
+    },
+  },
+];