@lumelabs/eslint-config 0.1.0

package/rules/style.js

@@ -0,0 +1,616 @@
+module.exports = {
+    rules: {
+        // enforce line breaks after opening and before closing array brackets
+        // https://eslint.org/docs/rules/array-bracket-newline
+        // TODO: enable? semver-major
+        "array-bracket-newline": ["off", "consistent"], // object option alternative: { multiline: true, minItems: 3 }
+
+        // enforce line breaks between array elements
+        // https://eslint.org/docs/rules/array-element-newline
+        // TODO: enable? semver-major
+        "array-element-newline": ["off", { multiline: true, minItems: 3 }],
+
+        // enforce spacing inside array brackets
+        "array-bracket-spacing": ["error", "never"],
+
+        // enforce spacing inside single-line blocks
+        // https://eslint.org/docs/rules/block-spacing
+        "block-spacing": ["error", "always"],
+
+        // enforce one true brace style
+        "brace-style": ["error", "1tbs", { allowSingleLine: true }],
+
+        // require camel case names
+        camelcase: ["error", { properties: "never", ignoreDestructuring: false }],
+
+        // enforce or disallow capitalization of the first letter of a comment
+        // https://eslint.org/docs/rules/capitalized-comments
+        "capitalized-comments": [
+            "off",
+            "never",
+            {
+                line: {
+                    ignorePattern: ".*",
+                    ignoreInlineComments: true,
+                    ignoreConsecutiveComments: true,
+                },
+                block: {
+                    ignorePattern: ".*",
+                    ignoreInlineComments: true,
+                    ignoreConsecutiveComments: true,
+                },
+            },
+        ],
+
+        // require trailing commas in multiline object literals
+        "comma-dangle": [
+            "error",
+            {
+                arrays: "always-multiline",
+                objects: "always-multiline",
+                imports: "always-multiline",
+                exports: "always-multiline",
+                functions: "always-multiline",
+            },
+        ],
+
+        // enforce spacing before and after comma
+        "comma-spacing": ["error", { before: false, after: true }],
+
+        // enforce one true comma style
+        "comma-style": [
+            "error",
+            "last",
+            {
+                exceptions: {
+                    ArrayExpression: false,
+                    ArrayPattern: false,
+                    ArrowFunctionExpression: false,
+                    CallExpression: false,
+                    FunctionDeclaration: false,
+                    FunctionExpression: false,
+                    ImportDeclaration: false,
+                    ObjectExpression: false,
+                    ObjectPattern: false,
+                    VariableDeclaration: false,
+                    NewExpression: false,
+                },
+            },
+        ],
+
+        // disallow padding inside computed properties
+        "computed-property-spacing": ["error", "never"],
+
+        // enforces consistent naming when capturing the current execution context
+        "consistent-this": "off",
+
+        // enforce newline at the end of file, with no multiple empty lines
+        "eol-last": ["error", "always"],
+
+        // https://eslint.org/docs/rules/function-call-argument-newline
+        "function-call-argument-newline": ["error", "consistent"],
+
+        // enforce spacing between functions and their invocations
+        // https://eslint.org/docs/rules/func-call-spacing
+        "func-call-spacing": ["error", "never"],
+
+        // requires function names to match the name of the variable or property to which they are
+        // assigned
+        // https://eslint.org/docs/rules/func-name-matching
+        "func-name-matching": [
+            "off",
+            "always",
+            {
+                includeCommonJSModuleExports: false,
+                considerPropertyDescriptor: true,
+            },
+        ],
+
+        // require function expressions to have a name
+        // https://eslint.org/docs/rules/func-names
+        "func-names": "warn",
+
+        // enforces use of function declarations or expressions
+        // https://eslint.org/docs/rules/func-style
+        // TODO: enable
+        "func-style": ["off", "expression"],
+
+        // require line breaks inside function parentheses if there are line breaks between parameters
+        // https://eslint.org/docs/rules/function-paren-newline
+        "function-paren-newline": ["error", "multiline-arguments"],
+
+        // disallow specified identifiers
+        // https://eslint.org/docs/rules/id-denylist
+        "id-denylist": "off",
+
+        // this option enforces minimum and maximum identifier lengths
+        // (variable names, property names etc.)
+        "id-length": "off",
+
+        // require identifiers to match the provided regular expression
+        "id-match": "off",
+
+        // Enforce the location of arrow function bodies with implicit returns
+        // https://eslint.org/docs/rules/implicit-arrow-linebreak
+        "implicit-arrow-linebreak": ["error", "beside"],
+
+        // this option sets a specific tab width for your code
+        // https://eslint.org/docs/rules/indent
+        indent: [
+            "error",
+            2,
+            {
+                SwitchCase: 1,
+                VariableDeclarator: 1,
+                outerIIFEBody: 1,
+                // MemberExpression: null,
+                FunctionDeclaration: {
+                    parameters: 1,
+                    body: 1,
+                },
+                FunctionExpression: {
+                    parameters: 1,
+                    body: 1,
+                },
+                CallExpression: {
+                    arguments: 1,
+                },
+                ArrayExpression: 1,
+                ObjectExpression: 1,
+                ImportDeclaration: 1,
+                flatTernaryExpressions: false,
+                // list derived from https://github.com/benjamn/ast-types/blob/HEAD/def/jsx.js
+                ignoredNodes: [
+                    "JSXElement",
+                    "JSXElement > *",
+                    "JSXAttribute",
+                    "JSXIdentifier",
+                    "JSXNamespacedName",
+                    "JSXMemberExpression",
+                    "JSXSpreadAttribute",
+                    "JSXExpressionContainer",
+                    "JSXOpeningElement",
+                    "JSXClosingElement",
+                    "JSXFragment",
+                    "JSXOpeningFragment",
+                    "JSXClosingFragment",
+                    "JSXText",
+                    "JSXEmptyExpression",
+                    "JSXSpreadChild",
+                ],
+                ignoreComments: false,
+            },
+        ],
+
+        // specify whether double or single quotes should be used in JSX attributes
+        // https://eslint.org/docs/rules/jsx-quotes
+        "jsx-quotes": ["off", "prefer-double"],
+
+        // enforces spacing between keys and values in object literal properties
+        "key-spacing": ["error", { beforeColon: false, afterColon: true }],
+
+        // require a space before & after certain keywords
+        "keyword-spacing": [
+            "error",
+            {
+                before: true,
+                after: true,
+                overrides: {
+                    return: { after: true },
+                    throw: { after: true },
+                    case: { after: true },
+                },
+            },
+        ],
+
+        // enforce position of line comments
+        // https://eslint.org/docs/rules/line-comment-position
+        // TODO: enable?
+        "line-comment-position": [
+            "off",
+            {
+                position: "above",
+                ignorePattern: "",
+                applyDefaultPatterns: true,
+            },
+        ],
+
+        // disallow mixed 'LF' and 'CRLF' as linebreaks
+        // https://eslint.org/docs/rules/linebreak-style
+        "linebreak-style": ["error", "unix"],
+
+        // require or disallow an empty line between class members
+        // https://eslint.org/docs/rules/lines-between-class-members
+        "lines-between-class-members": "off",
+
+        // enforces empty lines around comments
+        "lines-around-comment": "off",
+
+        // require or disallow newlines around directives
+        // https://eslint.org/docs/rules/lines-around-directive
+        "lines-around-directive": [
+            "error",
+            {
+                before: "always",
+                after: "always",
+            },
+        ],
+
+        // Require or disallow logical assignment logical operator shorthand
+        // https://eslint.org/docs/latest/rules/logical-assignment-operators
+        // TODO, semver-major: enable
+        "logical-assignment-operators": [
+            "off",
+            "always",
+            {
+                enforceForIfStatements: true,
+            },
+        ],
+
+        // specify the maximum depth that blocks can be nested
+        "max-depth": ["off", 4],
+
+        // specify the maximum length of a line in your program
+        // https://eslint.org/docs/rules/max-len
+        "max-len": [
+            "error",
+            100,
+            2,
+            {
+                ignoreUrls: true,
+                ignoreComments: false,
+                ignoreRegExpLiterals: true,
+                ignoreStrings: true,
+                ignoreTemplateLiterals: true,
+            },
+        ],
+
+        // specify the max number of lines in a file
+        // https://eslint.org/docs/rules/max-lines
+        "max-lines": [
+            "off",
+            {
+                max: 300,
+                skipBlankLines: true,
+                skipComments: true,
+            },
+        ],
+
+        // enforce a maximum function length
+        // https://eslint.org/docs/rules/max-lines-per-function
+        "max-lines-per-function": [
+            "off",
+            {
+                max: 50,
+                skipBlankLines: true,
+                skipComments: true,
+                IIFEs: true,
+            },
+        ],
+
+        // specify the maximum depth callbacks can be nested
+        "max-nested-callbacks": "off",
+
+        // limits the number of parameters that can be used in the function declaration.
+        "max-params": ["off", 3],
+
+        // specify the maximum number of statement allowed in a function
+        "max-statements": ["off", 10],
+
+        // restrict the number of statements per line
+        // https://eslint.org/docs/rules/max-statements-per-line
+        "max-statements-per-line": ["off", { max: 1 }],
+
+        // enforce a particular style for multiline comments
+        // https://eslint.org/docs/rules/multiline-comment-style
+        "multiline-comment-style": ["off", "starred-block"],
+
+        // require multiline ternary
+        // https://eslint.org/docs/rules/multiline-ternary
+        // TODO: enable?
+        "multiline-ternary": ["off", "never"],
+
+        // require a capital letter for constructors
+        "new-cap": [
+            "error",
+            {
+                newIsCap: true,
+                newIsCapExceptions: [],
+                capIsNew: false,
+                capIsNewExceptions: ["Immutable.Map", "Immutable.Set", "Immutable.List"],
+            },
+        ],
+
+        // disallow the omission of parentheses when invoking a constructor with no arguments
+        // https://eslint.org/docs/rules/new-parens
+        "new-parens": "error",
+
+        // allow/disallow an empty newline after var statement
+        "newline-after-var": "off",
+
+        // https://eslint.org/docs/rules/newline-before-return
+        "newline-before-return": "off",
+
+        // enforces new line after each method call in the chain to make it
+        // more readable and easy to maintain
+        // https://eslint.org/docs/rules/newline-per-chained-call
+        "newline-per-chained-call": ["error", { ignoreChainWithDepth: 4 }],
+
+        // disallow use of the Array constructor
+        "no-array-constructor": "error",
+
+        // disallow use of bitwise operators
+        // https://eslint.org/docs/rules/no-bitwise
+        "no-bitwise": "off",
+
+        // disallow use of the continue statement
+        // https://eslint.org/docs/rules/no-continue
+        "no-continue": "off",
+
+        // disallow comments inline after code
+        "no-inline-comments": "off",
+
+        // disallow if as the only statement in an else block
+        // https://eslint.org/docs/rules/no-lonely-if
+        "no-lonely-if": "off",
+
+        // disallow un-paren'd mixes of different operators
+        // https://eslint.org/docs/rules/no-mixed-operators
+        "no-mixed-operators": [
+            "error",
+            {
+                // the list of arithmetic groups disallows mixing `%` and `**`
+                // with other arithmetic operators.
+                groups: [
+                    ["%", "**"],
+                    ["%", "+"],
+                    ["%", "-"],
+                    ["%", "*"],
+                    ["%", "/"],
+                    ["/", "*"],
+                    ["&", "|", "<<", ">>", ">>>"],
+                    ["==", "!=", "===", "!=="],
+                    ["&&", "||"],
+                ],
+                allowSamePrecedence: false,
+            },
+        ],
+
+        // disallow mixed spaces and tabs for indentation
+        "no-mixed-spaces-and-tabs": "error",
+
+        // disallow use of chained assignment expressions
+        // https://eslint.org/docs/rules/no-multi-assign
+        "no-multi-assign": "off",
+
+        // disallow multiple empty lines, only one newline at the end, and no new lines at the beginning
+        // https://eslint.org/docs/rules/no-multiple-empty-lines
+        "no-multiple-empty-lines": ["error", { max: 1, maxBOF: 0, maxEOF: 0 }],
+
+        // disallow negated conditions
+        // https://eslint.org/docs/rules/no-negated-condition
+        "no-negated-condition": "off",
+
+        // disallow nested ternary expressions
+        "no-nested-ternary": "off",
+
+        // disallow use of the Object constructor
+        "no-new-object": "error",
+
+        // disallow use of unary operators, ++ and --
+        // https://eslint.org/docs/rules/no-plusplus
+        "no-plusplus": "off",
+
+        // disallow certain syntax forms
+        // https://eslint.org/docs/rules/no-restricted-syntax
+        "no-restricted-syntax": [
+            "error",
+            {
+                selector: "ForInStatement",
+                message:
+                    "for..in loops iterate over the entire prototype chain, which is virtually never what you want. Use Object.{keys,values,entries}, and iterate over the resulting array.",
+            },
+            {
+                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.",
+            },
+        ],
+
+        // disallow space between function identifier and application
+        // deprecated in favor of func-call-spacing
+        "no-spaced-func": "off",
+
+        // disallow tab characters entirely
+        "no-tabs": "error",
+
+        // disallow the use of ternary operators
+        "no-ternary": "off",
+
+        // disallow trailing whitespace at the end of lines
+        "no-trailing-spaces": [
+            "error",
+            {
+                skipBlankLines: false,
+                ignoreComments: false,
+            },
+        ],
+
+        // disallow dangling underscores in identifiers
+        // https://eslint.org/docs/rules/no-underscore-dangle
+        "no-underscore-dangle": "off",
+
+        // 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 }],
+
+        // disallow whitespace before properties
+        // https://eslint.org/docs/rules/no-whitespace-before-property
+        "no-whitespace-before-property": "error",
+
+        // enforce the location of single-line statements
+        // https://eslint.org/docs/rules/nonblock-statement-body-position
+        "nonblock-statement-body-position": ["error", "beside", { overrides: {} }],
+
+        // require padding inside curly braces
+        "object-curly-spacing": ["error", "always"],
+
+        // enforce line breaks between braces
+        // https://eslint.org/docs/rules/object-curly-newline
+        "object-curly-newline": [
+            "error",
+            {
+                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.
+        // https://eslint.org/docs/rules/object-property-newline
+        "object-property-newline": [
+            "error",
+            {
+                allowAllPropertiesOnSameLine: true,
+            },
+        ],
+
+        // allow just one var statement per function
+        "one-var": ["error", "never"],
+
+        // require a newline around variable declaration
+        // https://eslint.org/docs/rules/one-var-declaration-per-line
+        "one-var-declaration-per-line": ["error", "always"],
+
+        // require assignment operator shorthand where possible or prohibit it entirely
+        // https://eslint.org/docs/rules/operator-assignment
+        "operator-assignment": ["error", "always"],
+
+        // Requires operator at the beginning of the line in multiline statements
+        // https://eslint.org/docs/rules/operator-linebreak
+        "operator-linebreak": ["error", "before", { overrides: { "=": "none" } }],
+
+        // disallow padding within blocks
+        "padded-blocks": [
+            "error",
+            {
+                blocks: "never",
+                classes: "never",
+                switches: "never",
+            },
+            {
+                allowSingleLineBlocks: true,
+            },
+        ],
+
+        // Require or disallow padding lines between statements
+        // https://eslint.org/docs/rules/padding-line-between-statements
+        "padding-line-between-statements": "off",
+
+        // Disallow the use of Math.pow in favor of the ** operator
+        // https://eslint.org/docs/rules/prefer-exponentiation-operator
+        "prefer-exponentiation-operator": "error",
+
+        // Prefer use of an object spread over Object.assign
+        // https://eslint.org/docs/rules/prefer-object-spread
+        "prefer-object-spread": "error",
+
+        // require quotes around object literal property names
+        // https://eslint.org/docs/rules/quote-props.html
+        "quote-props": ["error", "as-needed", { keywords: false, unnecessary: true, numbers: false }],
+
+        // specify whether double or single quotes should be used
+        quotes: ["error", "single", { avoidEscape: true }],
+
+        // do not require jsdoc
+        // https://eslint.org/docs/rules/require-jsdoc
+        "require-jsdoc": "off",
+
+        // require or disallow use of semicolons instead of ASI
+        semi: ["error", "always"],
+
+        // enforce spacing before and after semicolons
+        "semi-spacing": ["error", { before: false, after: true }],
+
+        // Enforce location of semicolons
+        // https://eslint.org/docs/rules/semi-style
+        "semi-style": ["error", "last"],
+
+        // requires object keys to be sorted
+        "sort-keys": ["off", "asc", { caseSensitive: false, natural: true }],
+
+        // sort variables within the same declaration block
+        "sort-vars": "off",
+
+        // require or disallow space before blocks
+        "space-before-blocks": "error",
+
+        // require or disallow space before function opening parenthesis
+        // https://eslint.org/docs/rules/space-before-function-paren
+        "space-before-function-paren": [
+            "error",
+            {
+                anonymous: "always",
+                named: "never",
+                asyncArrow: "always",
+            },
+        ],
+
+        // require or disallow spaces inside parentheses
+        "space-in-parens": ["error", "never"],
+
+        // require spaces around operators
+        "space-infix-ops": "error",
+
+        // Require or disallow spaces before/after unary operators
+        // https://eslint.org/docs/rules/space-unary-ops
+        "space-unary-ops": [
+            "error",
+            {
+                words: true,
+                nonwords: false,
+                overrides: {},
+            },
+        ],
+
+        // 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: ["=", "!", "/"], // 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
+        // https://eslint.org/docs/rules/switch-colon-spacing
+        "switch-colon-spacing": ["error", { after: true, before: false }],
+
+        // Require or disallow spacing between template tags and their literals
+        // https://eslint.org/docs/rules/template-tag-spacing
+        "template-tag-spacing": ["error", "never"],
+
+        // require or disallow the Unicode Byte Order Mark
+        // https://eslint.org/docs/rules/unicode-bom
+        "unicode-bom": ["error", "never"],
+
+        // require regex literals to be wrapped in parentheses
+        "wrap-regex": "off",
+    },
+}

package/rules/typescript-eslint.js

@@ -0,0 +1,29 @@
+module.exports = {
+    plugins: ["@typescript-eslint"],
+
+    extends: ["plugin:@typescript-eslint/recommended"],
+
+    rules: {
+        // TypeScript
+        "@typescript-eslint/explicit-member-accessibility": "off",
+        "@typescript-eslint/explicit-function-return-type": "off",
+        "@typescript-eslint/no-var-requires": "off",
+        "@typescript-eslint/no-non-null-assertion": "off",
+        "@typescript-eslint/no-empty-interface": "off",
+        "@typescript-eslint/naming-convention": "off",
+        "@typescript-eslint/no-use-before-define": ["error", { functions: false }],
+        "@typescript-eslint/no-unused-vars": ["error", { argsIgnorePattern: "^_", varsIgnorePattern: "^_" }],
+        "@typescript-eslint/no-explicit-any": "warn",
+        "@typescript-eslint/no-shadow": ["warn"],
+        "@typescript-eslint/explicit-module-boundary-types": "off",
+        "@typescript-eslint/ban-ts-comment": "off",
+        "@typescript-eslint/no-unsafe-function-type": "off",
+        "@typescript-eslint/no-empty-object-type": "off",
+        "@typescript-eslint/no-wrapper-object-types": "warn",
+        // "@typescript-eslint/consistent-type-imports": [
+        //     "error",
+        //     { prefer: "type-imports", fixStyle: "inline-type-imports" },
+        // ],
+        // "@typescript-eslint/consistent-type-exports": ["error", { fixMixedExportsWithInlineTypeSpecifier: true }],
+    },
+}