@petbee/eslint-config 1.0.1-alpha-1.0 → 1.0.2

package/index.js

@@ -1,74 +1,28 @@
 module.exports = {
-  parser: '@typescript-eslint/parser',
   parserOptions: {
     project: 'tsconfig.json',
     sourceType: 'module',
-    warnOnUnsupportedTypeScriptVersion: false,
   },
   plugins: ['@typescript-eslint/eslint-plugin'],
   extends: [
-    'plugin:@typescript-eslint/eslint-recommended',
-    'plugin:@typescript-eslint/recommended',
-    'plugin:react/recommended',
-    'prettier',
+    'eslint:recommended',
+    './rules/prettier.js',
+    './rules/errors.js',
+    './rules/node.js',
+    './rules/style.js',
+    './rules/variables.js',
+    './rules/best-practices.js',
+    './rules/imports.js',
+    './rules/typescript.js',
+    './rules/tests.js',
   ],
   root: true,
   env: {
     node: true,
     jest: true,
+    es6: true,
   },
-  rules: {
-    // Don't require a weird naming convention for interfaces
-    '@typescript-eslint/interface-name-prefix': 'off',
-
-    // Allow inferring types for functions
-    '@typescript-eslint/explicit-function-return-type': 'off',
-
-    // Allow inferring types for exported things
-    '@typescript-eslint/explicit-module-boundary-types': 'off',
-
-    // Don't allow "any" at all
-    '@typescript-eslint/no-explicit-any': 'error',
-
-    // Make sure we are awaiting or explicitly voiding all Promises
-    '@typescript-eslint/no-floating-promises': 'error',
-
-    // Allow using functions that are defined later in the file (fine thanks to hoisting)
-    '@typescript-eslint/no-use-before-define': [
-      'error',
-      { functions: false, classes: false, variables: true },
-    ],
-
-    // This rule makes no difference - ' and " are fine, > and } are already compile errors
-    'react/no-unescaped-entities': 'off',
-
-    // Disable validation of prop types, because we use TS instead and it gets confused
-    'react/prop-types': 'off',
-
-    // Make sure comments are starting with an uppercase letter, to encourage correct grammar
-    'capitalized-comments': [
-      'warn',
-      'always',
-      {
-        ignorePattern: 'prettier|c8',
-        ignoreConsecutiveComments: true,
-      },
-    ],
-
-    // Disable specific syntax features
-    'no-restricted-syntax': [
-      'error',
-      // Don't allow TS enums at all, since they have multiple unintuitive footguns
-      {
-        selector: 'TSEnumDeclaration',
-        message:
-          'Unexpected enum. Use a literal string union or a const object instead.',
-      },
-    ],
-  },
-  settings: {
-    react: {
-      version: 'detect',
-    },
+  globals: {
+    __DEV__: true,
   },
 }

package/lib/utils.js

@@ -0,0 +1,11 @@
+/* eslint-disable node/global-require */
+
+exports.hasPackage = (pkg) => {
+  try {
+    require(pkg)
+
+    return true
+  } catch (e) {
+    return false
+  }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@petbee/eslint-config",
-  "version": "1.0.1-alpha-1.0",
+  "version": "1.0.2",
   "description": "Petbee's eslint config",
   "keywords": [
     "eslint",
@@ -11,7 +11,9 @@
   "license": "MIT",
   "main": "index.js",
   "files": [
-    "index.js"
+    "index.js",
+    "rules/",
+    "lib/"
   ],
   "repository": {
     "type": "git",
@@ -31,17 +33,24 @@
     "url": "https://github.com/petbee/typescript/issues"
   },
   "dependencies": {
-    "@typescript-eslint/eslint-plugin": "6.10.0",
-    "@typescript-eslint/parser": "6.10.0",
-    "eslint-config-prettier": "9.0.0",
+    "@typescript-eslint/eslint-plugin": "^6.10.0",
+    "@typescript-eslint/parser": "^6.10.0",
+    "confusing-browser-globals": "^1.0.11",
+    "eslint-config-prettier": "^9.0.0",
+    "eslint-plugin-cypress": "^2.15.1",
+    "eslint-plugin-import": "^2.29.0",
+    "eslint-plugin-jest": "^27.6.0",
+    "eslint-plugin-node": "^11.1.0",
+    "eslint-plugin-prettier": "^5.0.1",
     "eslint-plugin-react": "7.33.2"
   },
   "peerDependencies": {
     "eslint": "^8.0.0",
+    "prettier": "^2",
     "typescript": "^4.0.0 || ^5.0.0"
   },
   "devDependencies": {
-    "@petbee/prettier-config": "2.0.2",
+    "@petbee/prettier-config": "^1.0.1",
     "@types/react": "18.2.37",
     "eslint": "8.53.0",
     "prettier": "3.0.3",
@@ -51,5 +60,5 @@
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "c88132ca3b4e5269d65060a0f49ae7f2cbff9173"
+  "gitHead": "3c90a0ee37ac4f15cafa2778c9e132bfbb4b6082"
 }

package/rules/best-practices.js

@@ -0,0 +1,303 @@
+module.exports = {
+  rules: {
+    // Enforces return statements in callbacks of array's methods
+    // https://eslint.org/docs/rules/array-callback-return
+    'array-callback-return': ['error', { allowImplicit: true }],
+
+    // Treat var statements as if they were block scoped
+    // https://eslint.org/docs/rules/block-scoped-var
+    'block-scoped-var': 'error',
+
+    // Require default case in switch statements
+    // https://eslint.org/docs/rules/default-case
+    'default-case': ['error', { commentPattern: '^no default$' }],
+
+    // Disallow case statement fallthrough
+    // https://eslint.org/docs/rules/no-fallthrough
+    'no-fallthrough': [
+      'error',
+      {
+        commentPattern: '(break[\\s\\w]*omitted|falls\\s?through)',
+      },
+    ],
+
+    // Enforce parameters with default values to be last
+    // https://eslint.org/docs/rules/default-param-last
+    'default-param-last': 'error',
+
+    // Encourages use of dot notation whenever possible
+    // https://eslint.org/docs/rules/dot-notation
+    'dot-notation': ['error', { allowKeywords: true }],
+
+    // Require the use of === and !==
+    // https://eslint.org/docs/rules/eqeqeq
+    eqeqeq: ['error', 'always', { null: 'ignore' }],
+
+    // Require grouped accessor pairs in object literals and classes
+    // https://eslint.org/docs/rules/grouped-accessor-pairs
+    'grouped-accessor-pairs': 'error',
+
+    // Enforce a maximum number of classes per file
+    // https://eslint.org/docs/rules/max-classes-per-file
+    // TODO, maybe turn on
+    'max-classes-per-file': ['off', 1],
+
+    // Disallow the use of alert, confirm, and prompt
+    // https://eslint.org/docs/rules/no-alert
+    'no-alert': 'warn',
+
+    // Disallow use of arguments.caller or arguments.callee
+    // https://eslint.org/docs/rules/no-caller
+    'no-caller': 'error',
+
+    // Disallow lexical declarations in case/default clauses
+    // https://eslint.org/docs/rules/no-case-declarations
+    'no-case-declarations': 'error',
+
+    // Disallow returning value in constructor
+    // https://eslint.org/docs/rules/no-constructor-return
+    'no-constructor-return': 'error',
+
+    // Disallow else after a return in an if
+    // https://eslint.org/docs/rules/no-else-return
+    'no-else-return': ['error', { allowElseIf: false }],
+
+    // Disallow empty functions, except for standalone funcs/arrows
+    // https://eslint.org/docs/rules/no-empty-function
+    'no-empty-function': [
+      'error',
+      {
+        allow: ['arrowFunctions', 'functions', 'methods'],
+      },
+    ],
+
+    // Disallow use of eval()
+    // https://eslint.org/docs/rules/no-eval
+    'no-eval': 'error',
+
+    // Disallow adding to native types
+    // https://eslint.org/docs/rules/no-extend-native
+    'no-extend-native': 'error',
+
+    // Disallow unnecessary function binding
+    // https://eslint.org/docs/rules/no-extra-bind
+    'no-extra-bind': 'error',
+
+    // Disallow Unnecessary Labels
+    // https://eslint.org/docs/rules/no-extra-label
+    'no-extra-label': 'error',
+
+    // Disallow the use of leading or trailing decimal points in numeric literals
+    // https://eslint.org/docs/rules/no-floating-decimal
+    // Disabled because prettier already handle this rule
+    'no-floating-decimal': 'off',
+
+    // Disallow reassignments of native objects or read-only globals
+    // https://eslint.org/docs/rules/no-global-assign
+    'no-global-assign': 'error',
+
+    // Disallow use of eval()-like methods
+    // https://eslint.org/docs/rules/no-implied-eval
+    'no-implied-eval': 'error',
+
+    // Disallow usage of __iterator__ property
+    // https://eslint.org/docs/rules/no-iterator
+    'no-iterator': 'error',
+
+    // Disallow use of labels for anything other then loops and switches
+    // https://eslint.org/docs/rules/no-labels
+    'no-labels': 'error',
+
+    // Disallow unnecessary nested blocks
+    // https://eslint.org/docs/rules/no-lone-blocks
+    'no-lone-blocks': 'error',
+
+    // Disallow creation of functions within loops
+    // https://eslint.org/docs/rules/no-loop-func
+    'no-loop-func': 'error',
+
+    // Disallow magic numbers
+    // https://eslint.org/docs/rules/no-magic-numbers
+    // TODO enable? maybe too much
+    'no-magic-numbers': [
+      'off',
+      {
+        ignore: [0, 1, 2, 3],
+        ignoreArrayIndexes: true,
+        enforceConst: true,
+        detectObjects: false,
+      },
+    ],
+
+    // Disallow use of multiline strings
+    // https://eslint.org/docs/rules/no-multi-str
+    'no-multi-str': 'error',
+
+    // Disallow use of new operator for Function object
+    // https://eslint.org/docs/rules/no-new-func
+    'no-new-func': 'error',
+
+    // Disallows creating new instances of String, Number, and Boolean
+    // https://eslint.org/docs/rules/no-new-wrappers
+    'no-new-wrappers': 'error',
+
+    // Disallow use of octal escape sequences in string literals, such as
+    // var foo = 'Copyright \251';
+    // https://eslint.org/docs/rules/no-octal-escape
+    'no-octal-escape': 'error',
+
+    // Disallow usage of __proto__ property
+    // https://eslint.org/docs/rules/no-proto
+    'no-proto': 'error',
+
+    // Disallow declaring the same variable more then once
+    // https://eslint.org/docs/rules/no-redeclare
+    'no-redeclare': 'error',
+
+    // Disallow use of assignment in return statement
+    // https://eslint.org/docs/rules/no-return-assign
+    'no-return-assign': ['error', 'except-parens'],
+
+    // Disallow redundant `return await`
+    // https://eslint.org/docs/rules/no-return-await
+    'no-return-await': 'error',
+
+    // Disallow use of `javascript:` urls.
+    // https://eslint.org/docs/rules/no-script-url
+    'no-script-url': 'error',
+
+    // Disallow comparisons where both sides are exactly the same
+    // https://eslint.org/docs/rules/no-self-compare
+    'no-self-compare': 'error',
+
+    // Disallow use of comma operator
+    // https://eslint.org/docs/rules/no-sequences
+    'no-sequences': 'error',
+
+    // Disallow unused labels
+    // https://eslint.org/docs/rules/no-unused-labels
+    'no-unused-labels': 'error',
+
+    // Disallow unnecessary catch clauses
+    // https://eslint.org/docs/rules/no-useless-catch
+    // TODO enable?
+    'no-useless-catch': 'off',
+
+    // Disallow unnecessary string escaping
+    // https://eslint.org/docs/rules/no-useless-escape
+    'no-useless-escape': 'error',
+
+    // Disallow redundant return; keywords
+    // https://eslint.org/docs/rules/no-useless-return
+    'no-useless-return': 'error',
+
+    // Disallow use of void operator
+    // https://eslint.org/docs/rules/no-void
+    'no-void': 'error',
+
+    // Prefer using regex literals instead of constructor
+    // https://eslint.org/docs/rules/prefer-regex-literals
+    'prefer-regex-literals': 'warn',
+
+    // Require use of the second argument for parseInt()
+    // https://eslint.org/docs/rules/radix
+    radix: 'error',
+
+    // Requires to declare all vars on top of their containing scope
+    // https://eslint.org/docs/rules/vars-on-top
+    'vars-on-top': 'error',
+    // https://eslint.org/docs/rules/constructor-super
+    'constructor-super': 'error',
+
+    // Disallow useless computed property keys
+    // https://eslint.org/docs/rules/no-useless-computed-key
+    'no-useless-computed-key': 'error',
+
+    // Disallow unnecessary constructor
+    // https://eslint.org/docs/rules/no-useless-constructor
+    'no-useless-constructor': 'error',
+
+    // Disallow renaming import, export, and destructured assignments to the same name
+    // https://eslint.org/docs/rules/no-useless-rename
+    'no-useless-rename': ['error'],
+
+    // Require let or const instead of var
+    // https://eslint.org/docs/rules/no-var
+    'no-var': 'error',
+
+    // Require method and property shorthand syntax for object literals
+    // https://eslint.org/docs/rules/object-shorthand
+    'object-shorthand': [
+      'error',
+      'always',
+      {
+        ignoreConstructors: false,
+        avoidQuotes: true,
+      },
+    ],
+
+    // Suggest using arrow functions as callbacks
+    // https://eslint.org/docs/rules/prefer-arrow-callback
+    // TODO discussion
+    'prefer-arrow-callback': [
+      'off',
+      {
+        allowNamedFunctions: false,
+        allowUnboundThis: true,
+      },
+    ],
+
+    // Suggest using of const declaration for variables that are never modified after declared
+    // https://eslint.org/docs/rules/prefer-const
+    'prefer-const': [
+      'error',
+      {
+        destructuring: 'all',
+        ignoreReadBeforeAssign: true,
+      },
+    ],
+
+    // Prefer destructuring from arrays and objects
+    // https://eslint.org/docs/rules/prefer-destructuring
+    'prefer-destructuring': [
+      'warn',
+      {
+        VariableDeclarator: {
+          array: true,
+          object: true,
+        },
+        AssignmentExpression: {
+          array: false,
+          object: false,
+        },
+      },
+      {
+        enforceForRenamedProperties: false,
+      },
+    ],
+
+    // Disallow parseInt() in favor of binary, octal, and hexadecimal literals
+    // https://eslint.org/docs/rules/prefer-numeric-literals
+    'prefer-numeric-literals': 'error',
+
+    // Use rest parameters instead of arguments
+    // https://eslint.org/docs/rules/prefer-rest-params
+    'prefer-rest-params': 'error',
+
+    // Suggest using the spread operator instead of .apply()
+    // https://eslint.org/docs/rules/prefer-spread
+    'prefer-spread': 'error',
+
+    // Suggest using template literals instead of string concatenation
+    // https://eslint.org/docs/rules/prefer-template
+    'prefer-template': 'warn',
+
+    // Disallow generator functions that do not have yield
+    // https://eslint.org/docs/rules/require-yield
+    'require-yield': 'error',
+
+    // Require a Symbol description
+    // https://eslint.org/docs/rules/symbol-description
+    'symbol-description': 'error',
+  },
+}

package/rules/errors.js

@@ -0,0 +1,41 @@
+module.exports = {
+  // only rules not included in 'eslint:recommended' or with different values
+  rules: {
+    // Enforces that a return statement is present in property getters
+    // https://eslint.org/docs/rules/getter-return
+    'getter-return': ['error', { allowImplicit: true }],
+
+    // Disallow await inside of loops
+    // https://eslint.org/docs/rules/no-await-in-loop
+    'no-await-in-loop': 'error',
+
+    // Disallow assignment in conditional expressions
+    // https://eslint.org/docs/rules/no-cond-assign
+    'no-cond-assign': ['error', 'except-parens'],
+
+    // Disallow use of console
+    // https://eslint.org/docs/rules/no-console
+    'no-console': ['error', { allow: ['warn', 'error', 'info'] }],
+
+    // Disallow template literal placeholder syntax in regular strings
+    // https://eslint.org/docs/rules/no-template-curly-in-string
+    'no-template-curly-in-string': 'error',
+
+    // Disallow assignments that can lead to race conditions due to usage of await or yield
+    // https://eslint.org/docs/rules/require-atomic-updates
+    'require-atomic-updates': 'warn',
+
+    //! Require eslint >= 6.7.0
+
+    // Disallow duplicate conditions in if-else-if chains
+    // https://eslint.org/docs/rules/no-dupe-else-if
+    'no-dupe-else-if': 'error',
+
+    // https://eslint.org/docs/rules/no-import-assign
+    'no-import-assign': 'error',
+
+    // Disallow returning values from setters
+    // https://eslint.org/docs/rules/no-setter-return
+    'no-setter-return': 'error',
+  },
+}

package/rules/imports.js

@@ -0,0 +1,54 @@
+// https://github.com/benmosher/eslint-plugin-import/blob/master/docs/rules
+module.exports = {
+  extends: ['plugin:import/typescript'],
+  plugins: ['import'],
+  rules: {
+    // Disallow non-import statements appearing before import statements
+    // https://github.com/benmosher/eslint-plugin-import/blob/master/docs/rules/first.md
+    'import/first': 'error',
+
+    // Disallow duplicate imports
+    // https://github.com/benmosher/eslint-plugin-import/blob/master/docs/rules/no-duplicates.md
+    'import/no-duplicates': 'error',
+
+    // Ensure native, external and internal imports are separated, above relative imports and that unassigned imports are ignored
+    // https://github.com/benmosher/eslint-plugin-import/blob/master/docs/rules/order.md
+    'import/order': [
+      'error',
+      {
+        'newlines-between': 'always',
+        groups: [
+          'builtin',
+          'external',
+          'internal',
+          ['parent', 'sibling', 'index'],
+          'type',
+        ],
+      },
+    ],
+
+    // Require a newline after the last import/require in a group
+    // https://github.com/benmosher/eslint-plugin-import/blob/master/docs/rules/newline-after-import.md
+    'import/newline-after-import': 'error',
+
+    // Forbid import of modules using absolute paths
+    // https://github.com/benmosher/eslint-plugin-import/blob/master/docs/rules/no-absolute-path.md
+    'import/no-absolute-path': 'error',
+
+    // Forbid mutable exports
+    // https://github.com/benmosher/eslint-plugin-import/blob/master/docs/rules/no-mutable-exports.md
+    'import/no-mutable-exports': 'error',
+
+    // Disallow invalid exports, e.g. multiple defaults
+    // https://github.com/benmosher/eslint-plugin-import/blob/master/docs/rules/export.md
+    'import/export': 'error',
+
+    // Ensures that there are no useless path segments
+    // https://github.com/benmosher/eslint-plugin-import/blob/master/docs/rules/no-useless-path-segments.md
+    'import/no-useless-path-segments': ['error', { commonjs: true }],
+
+    // Forbid a module from importing itself
+    // https://github.com/benmosher/eslint-plugin-import/blob/master/docs/rules/no-self-import.md
+    'import/no-self-import': 'error',
+  },
+}

package/rules/node.js

@@ -0,0 +1,42 @@
+module.exports = {
+  plugins: ['node'],
+  env: {
+    node: true,
+  },
+  rules: {
+    // Disallow use of process.env
+    // https://github.com/mysticatea/eslint-plugin-node/blob/master/docs/rules/no-process-env.md
+    'node/no-process-env': 'off',
+
+    // Enforce a callback to return
+    // https://github.com/mysticatea/eslint-plugin-node/blob/master/docs/rules/callback-return.md
+    //! too annoying
+    'node/callback-return': 'off',
+
+    // Require all requires be top-level
+    // https://github.com/mysticatea/eslint-plugin-node/blob/master/docs/rules/global-require.md
+    'node/global-require': 'error',
+
+    // Disallow use of new operator with the require function
+    // https://github.com/mysticatea/eslint-plugin-node/blob/master/docs/rules/no-new-require.md
+    'node/no-new-require': 'error',
+
+    // Disallow string concatenation with __dirname and __filename
+    // https://github.com/mysticatea/eslint-plugin-node/blob/master/docs/rules/no-path-concat.md
+    'node/no-path-concat': 'error',
+
+    // Make process.exit() expressions the same code path as throw
+    // https://github.com/mysticatea/eslint-plugin-node/blob/master/docs/rules/process-exit-as-throw.md
+    'node/process-exit-as-throw': 'error',
+
+    // Disallow deprecated APIs
+    // https://github.com/mysticatea/eslint-plugin-node/blob/master/docs/rules/no-deprecated-api.md
+    'node/no-deprecated-api': 'error',
+
+    // Encourages use of promise APIs instead o callback APIs
+    // https://github.com/mysticatea/eslint-plugin-node/blob/master/docs/rules/prefer-promises/fs.md
+    // https://github.com/mysticatea/eslint-plugin-node/blob/master/docs/rules/prefer-promises/dns.md
+    'node/prefer-promises/fs': 'warn',
+    'node/prefer-promises/dns': 'warn',
+  },
+}

package/rules/prettier.js

@@ -0,0 +1,8 @@
+// https://github.com/prettier/eslint-plugin-prettier
+module.exports = {
+  extends: ['plugin:prettier/recommended'],
+  plugins: ['prettier'],
+  rules: {
+    'prettier/prettier': 'error',
+  },
+}

package/rules/style.js

@@ -0,0 +1,205 @@
+module.exports = {
+  rules: {
+    // Allow brace-less single-line if, else if, else, for, while, or do, while still enforcing the use of curly braces for other instances.
+    // https://eslint.org/docs/rules/curly
+    // Disabled because conflicts with prettier
+    // https://github.com/prettier/eslint-config-prettier#curly
+    curly: 'off',
+
+    // Require camel case names
+    // https://eslint.org/docs/rules/camelcase
+    camelcase: [
+      'error',
+      {
+        properties: 'never',
+        ignoreDestructuring: false,
+      },
+    ],
+
+    // Require function expressions to have a name
+    // https://eslint.org/docs/rules/func-names
+    'func-names': 'warn',
+
+    // Enforce position of line comments
+    // https://eslint.org/docs/rules/line-comment-position
+    'line-comment-position': [
+      'off',
+      {
+        position: 'above',
+        applyDefaultPatterns: true,
+      },
+    ],
+
+    // Disallow comments inline after code
+    // https://eslint.org/docs/rules/no-inline-comments
+    'no-inline-comments': 'off',
+
+    // Require or disallow newlines around directives
+    // https://eslint.org/docs/rules/lines-around-directive
+    'lines-around-directive': [
+      'error',
+      {
+        before: 'always',
+        after: 'always',
+      },
+    ],
+
+    // Limit the number of parameters that can be used in the function declaration.
+    // https://eslint.org/docs/rules/max-params
+    'max-params': [
+      'warn',
+      {
+        max: 3,
+      },
+    ],
+
+    // Require a capital letter for constructors
+    // https://eslint.org/docs/rules/new-cap
+    'new-cap': [
+      'error',
+      {
+        newIsCap: true,
+        capIsNew: false,
+      },
+    ],
+
+    // Disallow use of the Array constructor
+    // https://eslint.org/docs/rules/no-array-constructor
+    'no-array-constructor': 'error',
+
+    // Disallow if as the only statement in an else block
+    // https://eslint.org/docs/rules/no-lonely-if
+    'no-lonely-if': 'error',
+
+    // Disallow use of chained assignment expressions
+    // https://eslint.org/docs/rules/no-multi-assign
+    'no-multi-assign': 'error',
+
+    // Disallow negated conditions
+    // https://eslint.org/docs/rules/no-negated-condition
+    'no-negated-condition': 'warn',
+
+    // Disallow use of the Object constructor
+    // https://eslint.org/docs/rules/no-new-object
+    'no-new-object': 'error',
+
+    // Disallow certain syntax forms
+    // https://eslint.org/docs/rules/no-restricted-syntax
+    'no-restricted-syntax': [
+      'error',
+      {
+        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.',
+      },
+      // ban all enums
+      {
+        selector: 'TSEnumDeclaration:not([const=true])',
+        message:
+          "Literal types and enums, in many cases, solve the same problem while enum has some trade-offs that usually literal types don't. Consider using a literal type instead.",
+      },
+    ],
+
+    // Disallow the use of Boolean literals in conditional expressions
+    // Also, prefer `a || b` over `a ? a : b`
+    // https://eslint.org/docs/rules/no-unneeded-ternary
+    'no-unneeded-ternary': ['error', { defaultAssignment: false }],
+
+    // Allow just one var statement per function
+    // https://eslint.org/docs/rules/one-var
+    'one-var': ['error', 'never'],
+
+    // Require assignment operator shorthand where possible or prohibit it entirely
+    // https://eslint.org/docs/rules/operator-assignment
+    'operator-assignment': ['error', 'always'],
+
+    // Prefer use of an object spread over Object.assign
+    // https://eslint.org/docs/rules/prefer-object-spread
+    'prefer-object-spread': 'error',
+
+    // Require or disallow a space immediately following the // or /* in a comment
+    // https://eslint.org/docs/rules/spaced-comment
+    'spaced-comment': [
+      'error',
+      'always',
+      {
+        line: {
+          exceptions: ['-', '+'],
+          markers: ['-', '+', '?', '!'],
+        },
+        block: {
+          exceptions: ['-', '+'],
+          markers: ['-', '+', '?', '!'],
+          balanced: true,
+        },
+      },
+    ],
+
+    // Require or disallow padding lines between statements
+    // https://eslint.org/docs/rules/padding-line-between-statements
+    'padding-line-between-statements': [
+      'warn',
+      // empty lines after declarations
+      {
+        blankLine: 'always',
+        prev: ['const', 'let', 'var'],
+        next: '*',
+      },
+      // allow to have none or one blank line between declarations
+      {
+        blankLine: 'any',
+        prev: ['const', 'let', 'var'],
+        next: ['const', 'let', 'var'],
+      },
+      // enforce blank lines after multiline declarations
+      {
+        blankLine: 'always',
+        prev: ['multiline-const', 'multiline-let', 'multiline-var'],
+        next: '*',
+      },
+      // empty lines before returns
+      {
+        blankLine: 'always',
+        prev: '*',
+        next: 'return',
+      },
+      // empty lines between switch cases and breaks
+      {
+        blankLine: 'always',
+        prev: ['case', 'break'],
+        next: ['case', 'break', 'default'],
+      },
+      // always require blankline after function, class declarations and multiline blocks (if, try-catch, etc)
+      {
+        blankLine: 'always',
+        prev: ['function', 'class', 'multiline-block-like'],
+        next: '*',
+      },
+      // import/order already handle padding lines between cjs-imports
+      {
+        blankLine: 'any',
+        prev: ['cjs-import'],
+        next: ['cjs-import'],
+      },
+    ],
+
+    // Require or disallow padding lines between class members
+    // https://eslint.org/docs/rules/lines-between-class-members
+    'lines-between-class-members': [
+      'error',
+      'always',
+      {
+        exceptAfterSingleLine: true,
+      },
+    ],
+
+    //! Require eslint >= 6.7.0
+
+    // Disallow the use of Math.pow in favor of the ** operator
+    // https://eslint.org/docs/rules/prefer-exponentiation-operator
+    'prefer-exponentiation-operator': 'error',
+  },
+}

package/rules/tests.js

@@ -0,0 +1,78 @@
+// Jest:
+// https://github.com/jest-community/eslint-plugin-jest/blob/master/docs/rules
+// Cypress: https://github.com/cypress-io/eslint-plugin-cypress/blob/master/docs/rules
+const { hasPackage } = require('../lib/utils')
+
+const hasJest = hasPackage('jest')
+
+module.exports = {
+  overrides: [
+    // ! CYPRESS
+    {
+      files: ['**/cypress/**/*.{ts,tsx,js,jsx}'],
+      extends: ['plugin:cypress/recommended'],
+      rules: {
+        // Enforce assertions before taking a screenshot
+        // https://github.com/cypress-io/eslint-plugin-cypress/blob/master/docs/rules/assertion-before-screenshot.md
+        'cypress/assertion-before-screenshot': 'warn',
+      },
+    },
+    // ! JEST
+    {
+      // Run through every test file found
+      files: ['*.{test,spec}.{ts,tsx,js,jsx}'],
+      // Unless it's inside a cypress directory
+      excludedFiles: ['**/cypress/**'],
+      extends: ['plugin:jest/recommended', 'plugin:jest/style'],
+      settings: {
+        // need to explicitly set this for the IO apps.
+        // we need to explicitly define jest version because IO apps
+        // have jest installed in a subdirectory.
+        jest: {
+          ...(hasJest === false && {
+            version: 26,
+          }),
+        },
+      },
+      rules: {
+        // Enforce consistent a test method name
+        // https://github.com/jest-community/eslint-plugin-jest/blob/master/docs/rules/consistent-test-it.md
+        'jest/consistent-test-it': [
+          'warn',
+          {
+            fn: 'test',
+            withinDescribe: 'it',
+          },
+        ],
+
+        // Disallow alias methods
+        // https://github.com/jest-community/eslint-plugin-jest/blob/master/docs/rules/no-alias-methods.md
+        'jest/no-alias-methods': 'error',
+
+        // Disallow duplicate setup/teardown hooks
+        // https://github.com/jest-community/eslint-plugin-jest/blob/master/docs/rules/no-duplicate-hooks.md
+        'jest/no-duplicate-hooks': 'error',
+
+        // Suggest to have all hooks at top-level before tests
+        // https://github.com/jest-community/eslint-plugin-jest/blob/master/docs/rules/prefer-hooks-on-top.md
+        'jest/prefer-hooks-on-top': 'error',
+
+        // Suggest jest.spyOn() instead of jest.fn()
+        // https://github.com/jest-community/eslint-plugin-jest/blob/master/docs/rules/prefer-spy-on.md
+        'jest/prefer-spy-on': 'warn',
+
+        // Suggest using test.todo()
+        // https://github.com/jest-community/eslint-plugin-jest/blob/master/docs/rules/prefer-todo.md
+        'jest/prefer-todo': 'warn',
+
+        // Disallow return statements from tests
+        // https://github.com/jest-community/eslint-plugin-jest/blob/master/docs/rules/no-test-return-statement.md
+        'jest/no-test-return-statement': 'warn',
+
+        // Disallow deprecated jest functions
+        // https://github.com/jest-community/eslint-plugin-jest/blob/master/docs/rules/no-deprecated-functions.md
+        'jest/no-deprecated-functions': 'error',
+      },
+    },
+  ],
+}

package/rules/typescript.js

@@ -0,0 +1,286 @@
+const { hasPackage } = require('../lib/utils')
+
+const hasTypescript = hasPackage('typescript')
+
+module.exports = !hasTypescript
+  ? {}
+  : {
+      overrides: [
+        {
+          files: ['*.ts', '*.tsx'],
+          extends: ['plugin:@typescript-eslint/eslint-recommended', 'plugin:@typescript-eslint/recommended'],
+          plugins: ['@typescript-eslint'],
+          parser: '@typescript-eslint/parser',
+          parserOptions: {
+            ecmaVersion: 2019,
+            sourceType: 'module',
+            project: [
+              // look in the root
+              'tsconfig{.eslint.json,.json}',
+              // look in dirs like node/react
+              '*/tsconfig{.eslint.json,.json}',
+              // look in dirs like packages/package/*
+              '*/*/tsconfig{.eslint.json,.json}',
+            ],
+            projectFolderIgnoreList: [/node_modules/i],
+            // We need this configuration to avoid performance issues in monorepos
+            // https://github.com/typescript-eslint/typescript-eslint/issues/1192#issuecomment-862414778
+            allowAutomaticSingleRunInference: true,
+          },
+          rules: {
+            //! extensions of native eslint rules
+            //! when modifying a rule here, make sure to modify the native one and vice-versa
+
+            // Don't require a weird naming convention for interfaces
+            '@typescript-eslint/interface-name-prefix': 'off',
+
+            // Disallow declaration of variables already declared in the outer scope
+            // https://eslint.org/docs/rules/no-shadow
+            'no-shadow': 'off',
+            '@typescript-eslint/no-shadow': [
+              'error',
+              {
+                allow: ['done', 'next', 'resolve', 'reject', 'cb'],
+              },
+            ],
+
+            // Prevent unused declared variables
+            // https://typescript-eslint.io/rules/no-unused-vars/
+            'no-unused-vars': 'off',
+            '@typescript-eslint/no-unused-vars': [
+              'warn',
+              {
+                ignoreRestSiblings: true,
+                argsIgnorePattern: '_+',
+              },
+            ],
+
+            // Disallows the use of eval()-like methods
+            // https://typescript-eslint.io/rules/no-magic-numbers/
+            'no-magic-numbers': 'off',
+            '@typescript-eslint/no-magic-numbers': [
+              'off',
+              {
+                ignore: [0, 1, 2, 3],
+                ignoreArrayIndexes: true,
+                enforceConst: true,
+                detectObjects: false,
+                ignoreNumericLiteralTypes: true,
+                ignoreEnums: true,
+              },
+            ],
+
+            // Enforce parameters with default values to be last
+            // https://typescript-eslint.io/rules/default-param-last/
+            'default-param-last': 'off',
+            '@typescript-eslint/default-param-last': 'error',
+
+            // Disallow useless constructors
+            // https://typescript-eslint.io/rules/no-useless-constructor/
+            'no-useless-constructor': 'off',
+            '@typescript-eslint/no-useless-constructor': 'error',
+
+            // Disallow empty functions, except for standalone funcs/arrows
+            // https://eslint.org/docs/rules/no-empty-function
+            'no-empty-function': 'off',
+            '@typescript-eslint/no-empty-function': [
+              'error',
+              {
+                allow: ['arrowFunctions', 'functions', 'methods'],
+              },
+            ],
+
+            // Require a consistent naming convention
+            // https://typescript-eslint.io/rules/naming-convention/
+            camelcase: 'off',
+            '@typescript-eslint/naming-convention': [
+              'error',
+              {
+                selector: 'default',
+                format: ['camelCase'],
+                leadingUnderscore: 'allow',
+                trailingUnderscore: 'allow',
+              },
+              {
+                selector: 'variable',
+                format: ['camelCase', 'UPPER_CASE', 'PascalCase'],
+                leadingUnderscore: 'allow',
+                trailingUnderscore: 'allow',
+              },
+              {
+                selector: 'function',
+                format: ['camelCase', 'PascalCase'],
+              },
+              {
+                selector: 'typeLike',
+                format: ['PascalCase'],
+              },
+              {
+                selector: 'memberLike',
+                format: null,
+              },
+              {
+                // have to leave this for now as this rule
+                // doesn't separate regular parameters from
+                // destructured parameters
+                selector: 'parameter',
+                format: null,
+              },
+            ],
+
+            // Disallow use of variables before they are defined
+            // https://typescript-eslint.io/rules/no-use-before-define/
+            'no-use-before-define': 'off',
+            '@typescript-eslint/no-use-before-define': [
+              'error',
+              {
+                functions: false,
+                classes: false,
+                variables: true,
+                enums: false,
+                typedefs: false,
+              },
+            ],
+            // ! ts only rules
+            // Enforce explicit accessibility modifiers on class properties and methods
+            // https://typescript-eslint.io/rules/explicit-member-accessibility/
+            '@typescript-eslint/explicit-member-accessibility': [
+              'error',
+              {
+                accessibility: 'explicit',
+                overrides: {
+                  accessors: 'explicit',
+                  constructors: 'no-public',
+                  methods: 'explicit',
+                  parameterProperties: 'explicit',
+                },
+              },
+            ],
+
+            // Don't allow "any" at all
+            // https://typescript-eslint.io/rules/no-explicit-any
+            '@typescript-eslint/no-explicit-any': 'error',
+
+            // Enforce explicit function return type
+            // https://typescript-eslint.io/rules/explicit-function-return-type/
+            '@typescript-eslint/explicit-function-return-type': 'off',
+
+            // Enforce a consistent way of typing arrays
+            // https://typescript-eslint.io/rules/array-type/v
+            '@typescript-eslint/array-type': [
+              'warn',
+              {
+                default: 'array-simple',
+                readonly: 'array-simple',
+              },
+            ],
+
+            // Enforce a consitent way to type objects
+            // https://typescript-eslint.io/rules/consistent-type-definitions/
+            '@typescript-eslint/consistent-type-definitions': 'off',
+
+            // Disallow non null assertions (!), comes from the recommended config
+            // https://typescript-eslint.io/rules/no-non-null-assertion/
+            '@typescript-eslint/no-non-null-assertion': 'warn',
+
+            // Enforce that when adding two variables, operands must both be of type number or of type string
+            // https://typescript-eslint.io/rules/restrict-plus-operands/
+            '@typescript-eslint/restrict-plus-operands': [
+              'error',
+              {
+                skipCompoundAssignments: true,
+              },
+            ],
+
+            // Enforce optional chaining over chaining AND (&&) operators
+            // https://typescript-eslint.io/rules/prefer-optional-chain/
+            '@typescript-eslint/prefer-optional-chain': 'warn',
+
+            // Enforce optional chaining over chaining AND (&&) operators
+            // https://typescript-eslint.io/rules/no-non-null-asserted-optional-chain/
+            '@typescript-eslint/no-non-null-asserted-optional-chain': 'error',
+
+            // Enforce nullish coalescing over short-circuiting
+            // https://typescript-eslint.io/rules/prefer-nullish-coalescing/
+            '@typescript-eslint/prefer-nullish-coalescing': [
+              'warn',
+              {
+                ignoreConditionalTests: true,
+                ignoreMixedLogicalExpressions: true,
+              },
+            ],
+
+            // Prefer usage of as const over literal type
+            // https://typescript-eslint.io/rules/prefer-as-const/
+            '@typescript-eslint/prefer-as-const': 'error',
+
+            // Prevent unnecessary type arguments
+            // https://typescript-eslint.io/rules/no-unnecessary-type-arguments/
+            '@typescript-eslint/no-unnecessary-type-arguments': 'warn',
+
+            // Warns when a namespace qualifier is unnecessary
+            // https://typescript-eslint.io/rules/no-unnecessary-qualifier/
+            '@typescript-eslint/no-unnecessary-qualifier': 'warn',
+
+            // Disallow throwing literals as exceptions
+            // https://typescript-eslint.io/rules/no-throw-literal/
+            '@typescript-eslint/no-throw-literal': 'warn',
+
+            // Disallows invocation of require() in favor of import statements
+            // https://typescript-eslint.io/rules/no-require-imports/
+            '@typescript-eslint/no-require-imports': 'warn',
+
+            // Disallows the use of eval()-like methods
+            // https://typescript-eslint.io/rules/no-implied-eval/
+            '@typescript-eslint/no-implied-eval': 'error',
+
+            // Requires Array#sort calls to always provide a compareFunction
+            // https://typescript-eslint.io/rules/require-array-sort-compare/
+            '@typescript-eslint/require-array-sort-compare': 'error',
+
+            // Enforce explicit enum item values
+            // https://typescript-eslint.io/rules/prefer-enum-initializers/
+            '@typescript-eslint/prefer-enum-initializers': 'warn',
+
+            // Explicitly defines what a module scoped method returns
+            // https://typescript-eslint.io/rules/explicit-module-boundary-types/
+            '@typescript-eslint/explicit-module-boundary-types': 'off',
+
+            // Disallow // @ts comments
+            // https://typescript-eslint.io/rules/ban-ts-comment/
+            '@typescript-eslint/ban-ts-comment': [
+              'error',
+              {
+                'ts-expect-error': 'allow-with-description',
+                'ts-ignore': true,
+                'ts-nocheck': true,
+                'ts-check': false,
+                minimumDescriptionLength: 3,
+              },
+            ],
+
+            // Disallows unnecessary constraints on generic types
+            // https://typescript-eslint.io/rules/no-unnecessary-type-constraint/
+            '@typescript-eslint/no-unnecessary-type-constraint': 'warn',
+
+            // Enforces consistent usage of type imports
+            // https://typescript-eslint.io/rules/consistent-type-imports/
+            '@typescript-eslint/consistent-type-imports': [
+              'warn',
+              {
+                prefer: 'type-imports',
+                disallowTypeAnnotations: false,
+              },
+            ],
+          },
+        },
+        {
+          files: ['*.d.ts'],
+          rules: {
+            'import/order': 'off',
+            'import/no-duplicates': 'off',
+            'import/export': 'off',
+          },
+        },
+      ],
+    }

package/rules/variables.js

@@ -0,0 +1,53 @@
+const confusingBrowserGlobals = require('confusing-browser-globals')
+
+module.exports = {
+  rules: {
+    // Disallow labels that share a name with a variable
+    // https://eslint.org/docs/rules/no-label-var
+    'no-label-var': 'error',
+
+    // Disallow specific globals
+    // https://eslint.org/docs/rules/no-restricted-globals
+    'no-restricted-globals': ['error', 'isFinite', 'isNaN'].concat(
+      confusingBrowserGlobals
+    ),
+
+    // Disallow declaration of variables already declared in the outer scope
+    // https://eslint.org/docs/rules/no-shadow
+    'no-shadow': [
+      'error',
+      {
+        allow: ['done', 'next', 'resolve', 'reject', 'cb'],
+      },
+    ],
+
+    // Disallow shadowing of names such as arguments
+    // https://eslint.org/docs/rules/no-shadow-restricted-names
+    'no-shadow-restricted-names': 'error',
+
+    // Disallow use of undefined when initializing variables
+    // https://eslint.org/docs/rules/no-undef-init
+    'no-undef-init': 'error',
+
+    // Disallow declaration of variables that are not used in the code
+    // https://eslint.org/docs/rules/no-unused-vars
+    'no-unused-vars': [
+      'error',
+      {
+        ignoreRestSiblings: true,
+        argsIgnorePattern: '_+',
+      },
+    ],
+
+    // Disallow use of variables before they are defined
+    // https://eslint.org/docs/rules/no-use-before-define
+    'no-use-before-define': [
+      'off',
+      {
+        functions: false,
+        classes: false,
+        variables: true,
+      },
+    ],
+  },
+}