@croct/eslint-plugin 0.1.3 → 0.2.2

package/README.md

@@ -25,7 +25,7 @@
 
 ## Installation
 
-The recommended way to install the SDK is via [NPM](https://npmjs.com). It pairs nicely with module bundlers such as
+The recommended way to install the package is via [NPM](https://npmjs.com). It pairs nicely with module bundlers such as
 Webpack or Browserify:
 
 ```sh

package/configs/index.d.ts

@@ -95,7 +95,6 @@ export declare const configs: {
                     allowNumber: boolean;
                     allowNullableObject: boolean;
                 })[];
-                '@typescript-eslint/prefer-regexp-exec': string;
                 '@typescript-eslint/prefer-optional-chain': string;
                 'no-shadow': string;
                 '@typescript-eslint/no-shadow': (string | {
@@ -114,7 +113,10 @@ export declare const configs: {
                 indent: (string | number | {
                     SwitchCase: number;
                 })[];
-                '@typescript-eslint/no-unused-vars': string;
+                '@typescript-eslint/no-unused-vars': (string | {
+                    args: string;
+                    ignoreRestSiblings: boolean;
+                })[];
                 'no-unused-vars': string;
                 '@typescript-eslint/no-non-null-assertion': string;
                 'object-curly-spacing': string;
@@ -156,7 +158,6 @@ export declare const configs: {
                 '@typescript-eslint/type-annotation-spacing'?: undefined;
                 '@typescript-eslint/semi'?: undefined;
                 '@typescript-eslint/strict-boolean-expressions'?: undefined;
-                '@typescript-eslint/prefer-regexp-exec'?: undefined;
                 '@typescript-eslint/prefer-optional-chain'?: undefined;
                 'no-shadow'?: undefined;
                 '@typescript-eslint/no-shadow'?: undefined;
@@ -190,6 +191,10 @@ export declare const configs: {
         rules: {
             '@croct/argument-spacing': string;
             '@croct/complex-expression-spacing': string;
+            '@croct/newline-per-chained-call': string;
+            '@croct/min-chained-call-depth': string;
+            'newline-per-chained-call': string;
+            'no-plusplus': string;
             'array-bracket-newline': string[];
             'multiline-ternary': string[];
             'no-undef-init': string;
@@ -237,6 +242,10 @@ export declare const configs: {
             'max-len': (string | {
                 code: number;
                 ignoreStrings: boolean;
+                ignoreComments: boolean;
+                ignoreTemplateLiterals: boolean;
+                ignoreTrailingComments: boolean;
+                ignoreUrls: boolean;
             })[];
             'no-await-in-loop': string;
             'no-bitwise': string;
@@ -246,11 +255,11 @@ export declare const configs: {
                 maxEOF: number;
                 maxBOF: number;
             })[];
-            'no-plusplus': (string | {
-                allowForLoopAfterthoughts: boolean;
-            })[];
             'no-unused-expressions': string;
-            'no-unused-vars': string;
+            'no-unused-vars': (string | {
+                args: string;
+                ignoreRestSiblings: boolean;
+            })[];
             'no-restricted-syntax': string[];
             'object-curly-newline': (string | {
                 multiline: boolean;

package/configs/javascript.d.ts

@@ -4,6 +4,10 @@ export declare const javascript: {
     rules: {
         '@croct/argument-spacing': string;
         '@croct/complex-expression-spacing': string;
+        '@croct/newline-per-chained-call': string;
+        '@croct/min-chained-call-depth': string;
+        'newline-per-chained-call': string;
+        'no-plusplus': string;
         'array-bracket-newline': string[];
         'multiline-ternary': string[];
         'no-undef-init': string;
@@ -51,6 +55,10 @@ export declare const javascript: {
         'max-len': (string | {
             code: number;
             ignoreStrings: boolean;
+            ignoreComments: boolean;
+            ignoreTemplateLiterals: boolean;
+            ignoreTrailingComments: boolean;
+            ignoreUrls: boolean;
         })[];
         'no-await-in-loop': string;
         'no-bitwise': string;
@@ -60,11 +68,11 @@ export declare const javascript: {
             maxEOF: number;
             maxBOF: number;
         })[];
-        'no-plusplus': (string | {
-            allowForLoopAfterthoughts: boolean;
-        })[];
         'no-unused-expressions': string;
-        'no-unused-vars': string;
+        'no-unused-vars': (string | {
+            args: string;
+            ignoreRestSiblings: boolean;
+        })[];
         'no-restricted-syntax': string[];
         'object-curly-newline': (string | {
             multiline: boolean;

package/configs/javascript.js

@@ -16,6 +16,10 @@ exports.javascript = {
     rules: {
         '@croct/argument-spacing': 'error',
         '@croct/complex-expression-spacing': 'error',
+        '@croct/newline-per-chained-call': 'error',
+        '@croct/min-chained-call-depth': 'error',
+        'newline-per-chained-call': 'off',
+        'no-plusplus': 'off',
         'array-bracket-newline': [
             'error',
             'consistent',
@@ -99,7 +103,11 @@ exports.javascript = {
             'error',
             {
                 code: 100,
-                ignoreStrings: true,
+                ignoreStrings: false,
+                ignoreComments: false,
+                ignoreTemplateLiterals: false,
+                ignoreTrailingComments: false,
+                ignoreUrls: false,
             },
         ],
         'no-await-in-loop': 'off',
@@ -113,14 +121,14 @@ exports.javascript = {
                 maxBOF: 0,
             },
         ],
-        'no-plusplus': [
+        'no-unused-expressions': 'error',
+        'no-unused-vars': [
             'error',
             {
-                allowForLoopAfterthoughts: true,
+                args: 'after-used',
+                ignoreRestSiblings: true,
             },
         ],
-        'no-unused-expressions': 'error',
-        'no-unused-vars': 'error',
         'no-restricted-syntax': [
             'error',
             'ForInStatement',

package/configs/typescript.d.ts

@@ -18,7 +18,6 @@ export declare const typescript: {
                 allowNumber: boolean;
                 allowNullableObject: boolean;
             })[];
-            '@typescript-eslint/prefer-regexp-exec': string;
             '@typescript-eslint/prefer-optional-chain': string;
             'no-shadow': string;
             '@typescript-eslint/no-shadow': (string | {
@@ -37,7 +36,10 @@ export declare const typescript: {
             indent: (string | number | {
                 SwitchCase: number;
             })[];
-            '@typescript-eslint/no-unused-vars': string;
+            '@typescript-eslint/no-unused-vars': (string | {
+                args: string;
+                ignoreRestSiblings: boolean;
+            })[];
             'no-unused-vars': string;
             '@typescript-eslint/no-non-null-assertion': string;
             'object-curly-spacing': string;
@@ -79,7 +81,6 @@ export declare const typescript: {
             '@typescript-eslint/type-annotation-spacing'?: undefined;
             '@typescript-eslint/semi'?: undefined;
             '@typescript-eslint/strict-boolean-expressions'?: undefined;
-            '@typescript-eslint/prefer-regexp-exec'?: undefined;
             '@typescript-eslint/prefer-optional-chain'?: undefined;
             'no-shadow'?: undefined;
             '@typescript-eslint/no-shadow'?: undefined;

package/configs/typescript.js

@@ -25,7 +25,6 @@ exports.typescript = {
                         allowNumber: false,
                         allowNullableObject: false,
                     }],
-                '@typescript-eslint/prefer-regexp-exec': 'error',
                 '@typescript-eslint/prefer-optional-chain': 'error',
                 'no-shadow': 'off',
                 '@typescript-eslint/no-shadow': ['error', {
@@ -46,7 +45,13 @@ exports.typescript = {
                 indent: ['error', 4, {
                         SwitchCase: 1,
                     }],
-                '@typescript-eslint/no-unused-vars': 'error',
+                '@typescript-eslint/no-unused-vars': [
+                    'error',
+                    {
+                        args: 'after-used',
+                        ignoreRestSiblings: true,
+                    },
+                ],
                 'no-unused-vars': 'off',
                 '@typescript-eslint/no-non-null-assertion': 'off',
                 'object-curly-spacing': 'off',

package/index.d.ts

@@ -11,6 +11,17 @@ declare const configuration: {
             ArrowFunctionExpression: (node: import("@typescript-eslint/types/dist/ast-spec").ArrowFunctionExpression) => void;
             IfStatement: (node: import("@typescript-eslint/types/dist/ast-spec").IfStatement) => void;
         }>;
+        'newline-per-chained-call': import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleModule<"expectedLineBreak", {
+            ignoreChainWithDepth: number;
+        }[], {
+            CallExpression: (node: import("@typescript-eslint/types/dist/ast-spec").CallExpression) => void;
+            MemberExpression: (node: import("@typescript-eslint/types/dist/ast-spec").MemberExpression) => void;
+        }>;
+        'min-chained-call-depth': import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleModule<"unexpectedLineBreak", {
+            maxLineLength: number;
+        }[], {
+            CallExpression: (node: import("@typescript-eslint/types/dist/ast-spec").CallExpression) => void;
+        }>;
     };
     configs: {
         cypress: {
@@ -109,7 +120,6 @@ declare const configuration: {
                         allowNumber: boolean;
                         allowNullableObject: boolean;
                     })[];
-                    '@typescript-eslint/prefer-regexp-exec': string;
                     '@typescript-eslint/prefer-optional-chain': string;
                     'no-shadow': string;
                     '@typescript-eslint/no-shadow': (string | {
@@ -128,7 +138,10 @@ declare const configuration: {
                     indent: (string | number | {
                         SwitchCase: number;
                     })[];
-                    '@typescript-eslint/no-unused-vars': string;
+                    '@typescript-eslint/no-unused-vars': (string | {
+                        args: string;
+                        ignoreRestSiblings: boolean;
+                    })[];
                     'no-unused-vars': string;
                     '@typescript-eslint/no-non-null-assertion': string;
                     'object-curly-spacing': string;
@@ -170,7 +183,6 @@ declare const configuration: {
                     '@typescript-eslint/type-annotation-spacing'?: undefined;
                     '@typescript-eslint/semi'?: undefined;
                     '@typescript-eslint/strict-boolean-expressions'?: undefined;
-                    '@typescript-eslint/prefer-regexp-exec'?: undefined;
                     '@typescript-eslint/prefer-optional-chain'?: undefined;
                     'no-shadow'?: undefined;
                     '@typescript-eslint/no-shadow'?: undefined;
@@ -204,6 +216,10 @@ declare const configuration: {
             rules: {
                 '@croct/argument-spacing': string;
                 '@croct/complex-expression-spacing': string;
+                '@croct/newline-per-chained-call': string;
+                '@croct/min-chained-call-depth': string;
+                'newline-per-chained-call': string;
+                'no-plusplus': string;
                 'array-bracket-newline': string[];
                 'multiline-ternary': string[];
                 'no-undef-init': string;
@@ -251,6 +267,10 @@ declare const configuration: {
                 'max-len': (string | {
                     code: number;
                     ignoreStrings: boolean;
+                    ignoreComments: boolean;
+                    ignoreTemplateLiterals: boolean;
+                    ignoreTrailingComments: boolean;
+                    ignoreUrls: boolean;
                 })[];
                 'no-await-in-loop': string;
                 'no-bitwise': string;
@@ -260,11 +280,11 @@ declare const configuration: {
                     maxEOF: number;
                     maxBOF: number;
                 })[];
-                'no-plusplus': (string | {
-                    allowForLoopAfterthoughts: boolean;
-                })[];
                 'no-unused-expressions': string;
-                'no-unused-vars': string;
+                'no-unused-vars': (string | {
+                    args: string;
+                    ignoreRestSiblings: boolean;
+                })[];
                 'no-restricted-syntax': string[];
                 'object-curly-newline': (string | {
                     multiline: boolean;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@croct/eslint-plugin",
-  "version": "0.1.3",
+  "version": "0.2.2",
   "description": "ESLint rules and presets applied to all Croct JavaScript projects.",
   "license": "MIT",
   "author": {

package/rules/argument-spacing/index.js

@@ -7,7 +7,8 @@ exports.argumentSpacing = (0, createRule_1.createRule)({
     meta: {
         type: 'suggestion',
         docs: {
-            description: 'Enforces a surrounding line break before and after the argument list in multiline functional calls.',
+            description: 'Enforces a surrounding line break before and after '
+                + 'the argument list in multiline functional calls.',
             recommended: 'error',
         },
         fixable: 'whitespace',
@@ -34,7 +35,8 @@ exports.argumentSpacing = (0, createRule_1.createRule)({
                 return;
             }
             const lastArgumentFirstToken = sourceCode.getFirstToken(lastArgument);
-            if ((lastArgument.type !== 'ArrowFunctionExpression' || lastArgument.body.type === 'BlockStatement')
+            if ((lastArgument.type !== 'ArrowFunctionExpression'
+                || lastArgument.body.type === 'BlockStatement')
                 && firstToken.loc.start.line === lastArgumentFirstToken.loc.start.line) {
                 return;
             }

package/rules/index.d.ts

@@ -10,4 +10,15 @@ export declare const rules: {
         ArrowFunctionExpression: (node: import("@typescript-eslint/types/dist/ast-spec").ArrowFunctionExpression) => void;
         IfStatement: (node: import("@typescript-eslint/types/dist/ast-spec").IfStatement) => void;
     }>;
+    'newline-per-chained-call': import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleModule<"expectedLineBreak", {
+        ignoreChainWithDepth: number;
+    }[], {
+        CallExpression: (node: import("@typescript-eslint/types/dist/ast-spec").CallExpression) => void;
+        MemberExpression: (node: import("@typescript-eslint/types/dist/ast-spec").MemberExpression) => void;
+    }>;
+    'min-chained-call-depth': import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleModule<"unexpectedLineBreak", {
+        maxLineLength: number;
+    }[], {
+        CallExpression: (node: import("@typescript-eslint/types/dist/ast-spec").CallExpression) => void;
+    }>;
 };

package/rules/index.js

@@ -4,8 +4,12 @@ exports.rules = void 0;
 const argument_spacing_1 = require("./argument-spacing");
 const jsx_attribute_spacing_1 = require("./jsx-attribute-spacing");
 const complex_expression_spacing_1 = require("./complex-expression-spacing");
+const newline_per_chained_call_1 = require("./newline-per-chained-call");
+const min_chained_call_depth_1 = require("./min-chained-call-depth");
 exports.rules = {
     'argument-spacing': argument_spacing_1.argumentSpacing,
     'jsx-attribute-spacing': jsx_attribute_spacing_1.jsxAttributeSpacing,
     'complex-expression-spacing': complex_expression_spacing_1.complexExpressionSpacing,
+    'newline-per-chained-call': newline_per_chained_call_1.newlinePerChainedCall,
+    'min-chained-call-depth': min_chained_call_depth_1.minChainedCallDepth,
 };

package/rules/min-chained-call-depth/index.d.ts

@@ -0,0 +1,6 @@
+import { TSESTree } from '@typescript-eslint/experimental-utils';
+export declare const minChainedCallDepth: import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleModule<"unexpectedLineBreak", {
+    maxLineLength: number;
+}[], {
+    CallExpression: (node: TSESTree.CallExpression) => void;
+}>;

package/rules/min-chained-call-depth/index.js

@@ -0,0 +1,105 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.minChainedCallDepth = void 0;
+const ast_utils_1 = require("@typescript-eslint/utils/dist/ast-utils");
+const createRule_1 = require("../createRule");
+exports.minChainedCallDepth = (0, createRule_1.createRule)({
+    name: 'min-chained-call-depth',
+    meta: {
+        type: 'layout',
+        docs: {
+            description: 'Enforces a minimum depth for multiline chained calls.',
+            recommended: 'error',
+        },
+        fixable: 'whitespace',
+        schema: [
+            {
+                type: 'object',
+                properties: {
+                    maxLineLength: {
+                        type: 'integer',
+                        minimum: 1,
+                        default: 100,
+                    },
+                },
+                additionalProperties: false,
+            },
+        ],
+        messages: {
+            unexpectedLineBreak: 'Unexpected line break.',
+        },
+    },
+    defaultOptions: [
+        {
+            maxLineLength: 100,
+        },
+    ],
+    create: context => {
+        const sourceCode = context.getSourceCode();
+        function getDepth(node) {
+            let depth = 0;
+            let currentNode = node;
+            while (currentNode.type === 'CallExpression'
+                || currentNode.type === 'MemberExpression') {
+                if (currentNode.type === 'MemberExpression') {
+                    currentNode = currentNode.object;
+                }
+                else if (currentNode.type === 'CallExpression') {
+                    currentNode = currentNode.callee;
+                }
+                depth += 1;
+            }
+            return depth;
+        }
+        function check(node) {
+            var _a, _b, _c;
+            if (((_a = node.parent) === null || _a === void 0 ? void 0 : _a.type) === 'MemberExpression'
+                || ((_b = node.parent) === null || _b === void 0 ? void 0 : _b.type) === 'CallExpression'
+                || node.callee.type !== 'MemberExpression'
+                || node.callee.computed
+                || node.callee.object.loc.end.line === node.callee.property.loc.start.line) {
+                return;
+            }
+            if (getDepth(node) > 3) {
+                return;
+            }
+            const { maxLineLength = 100 } = (_c = context.options[0]) !== null && _c !== void 0 ? _c : {};
+            const { property } = node.callee;
+            const lastToken = sourceCode.getLastToken(node, {
+                filter: token => token.loc.end.line === property.loc.start.line,
+            });
+            const semicolon = sourceCode.getLastToken(node.parent, {
+                filter: token => (token.loc.start.line === property.loc.start.line
+                    && token.type === 'Punctuator'
+                    && token.value === ';'),
+            });
+            const lineLength = node.callee.object.loc.end.column
+                + lastToken.loc.end.column - property.loc.start.column
+                + 1
+                + (semicolon !== null ? 1 : 0);
+            if (maxLineLength !== null && lineLength > maxLineLength) {
+                return;
+            }
+            const punctuator = sourceCode.getTokenBefore(node.callee.property);
+            const previousToken = sourceCode.getTokenBefore(punctuator, { includeComments: true });
+            const nextToken = sourceCode.getTokenAfter(punctuator, { includeComments: true });
+            if ((0, ast_utils_1.isCommentToken)(previousToken) || (0, ast_utils_1.isCommentToken)(nextToken)) {
+                return;
+            }
+            context.report({
+                node: node,
+                loc: {
+                    start: node.callee.object.loc.end,
+                    end: node.callee.property.loc.start,
+                },
+                messageId: 'unexpectedLineBreak',
+                fix: fixer => fixer.replaceTextRange([previousToken.range[1], nextToken.range[0]], punctuator.value),
+            });
+        }
+        return {
+            CallExpression: (node) => {
+                check(node);
+            },
+        };
+    },
+});

package/rules/newline-per-chained-call/index.d.ts

@@ -0,0 +1,7 @@
+import { TSESTree } from '@typescript-eslint/experimental-utils';
+export declare const newlinePerChainedCall: import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleModule<"expectedLineBreak", {
+    ignoreChainWithDepth: number;
+}[], {
+    CallExpression: (node: TSESTree.CallExpression) => void;
+    MemberExpression: (node: TSESTree.MemberExpression) => void;
+}>;

package/rules/newline-per-chained-call/index.js

@@ -0,0 +1,122 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.newlinePerChainedCall = void 0;
+const createRule_1 = require("../createRule");
+const LINEBREAK_MATCHER = /\r\n|[\r\n\u2028\u2029]/u;
+exports.newlinePerChainedCall = (0, createRule_1.createRule)({
+    name: 'newline-per-chained-call',
+    meta: {
+        type: 'layout',
+        docs: {
+            description: 'Require a newline after each call in a method chain',
+            recommended: 'error',
+        },
+        fixable: 'whitespace',
+        schema: [
+            {
+                type: 'object',
+                properties: {
+                    ignoreChainWithDepth: {
+                        type: 'integer',
+                        minimum: 1,
+                        maximum: 10,
+                        default: 2,
+                    },
+                },
+                additionalProperties: false,
+            },
+        ],
+        messages: {
+            expectedLineBreak: 'Expected line break before `{{propertyName}}`.',
+        },
+    },
+    defaultOptions: [
+        {
+            ignoreChainWithDepth: 2,
+        },
+    ],
+    create: context => {
+        var _a, _b;
+        const options = (_a = context.options[0]) !== null && _a !== void 0 ? _a : {};
+        const ignoreChainWithDepth = (_b = options.ignoreChainWithDepth) !== null && _b !== void 0 ? _b : 2;
+        const sourceCode = context.getSourceCode();
+        function getPropertyText(node) {
+            const prefix = '.';
+            const lines = sourceCode.getText(node.property)
+                .split(LINEBREAK_MATCHER);
+            return prefix + lines[0];
+        }
+        function hasObjectAndPropertyOnSameLine(node) {
+            return node.object.loc.end.line === node.property.loc.start.line;
+        }
+        function isNotClosingParenToken(token) {
+            return token.value !== ')' || token.type !== 'Punctuator';
+        }
+        function validateCallExpressionIgnoreDepth(node) {
+            var _a;
+            let hasCallExpression = false;
+            if (node.type === 'CallExpression') {
+                hasCallExpression = true;
+            }
+            if ((node.parent !== undefined)
+                && node.parent.type !== 'CallExpression'
+                && node.parent.type !== 'MemberExpression') {
+                const memberExpressions = [];
+                let currentNode = (node.type === 'CallExpression'
+                    ? node.callee
+                    : node);
+                while (currentNode.type === 'CallExpression'
+                    || currentNode.type === 'MemberExpression') {
+                    if (currentNode.type === 'MemberExpression') {
+                        if (currentNode.property.type === 'Identifier'
+                            && !currentNode.computed) {
+                            memberExpressions.push(currentNode);
+                        }
+                        currentNode = currentNode.object;
+                    }
+                    else if (currentNode.type === 'CallExpression') {
+                        currentNode = currentNode.callee;
+                    }
+                }
+                if (memberExpressions.length > ignoreChainWithDepth
+                    && hasCallExpression
+                    && memberExpressions.some(hasObjectAndPropertyOnSameLine)) {
+                    const expressionsOnSameLine = memberExpressions
+                        .filter(hasObjectAndPropertyOnSameLine);
+                    const rootNode = expressionsOnSameLine[expressionsOnSameLine.length - 1];
+                    if (rootNode.type === 'MemberExpression'
+                        && ((_a = rootNode.parent) === null || _a === void 0 ? void 0 : _a.type) === 'CallExpression'
+                        && (rootNode.object.type === 'ThisExpression'
+                            || rootNode.object.type === 'Identifier')) {
+                        expressionsOnSameLine.pop();
+                    }
+                    expressionsOnSameLine.forEach(memberExpression => {
+                        context.report({
+                            node: memberExpression.property,
+                            loc: memberExpression.property.loc.start,
+                            messageId: 'expectedLineBreak',
+                            data: {
+                                propertyName: getPropertyText(memberExpression),
+                            },
+                            fix: fixer => {
+                                const firstTokenAfterObject = sourceCode.getTokenAfter(memberExpression.object, isNotClosingParenToken);
+                                return fixer.insertTextBefore(firstTokenAfterObject, '\n');
+                            },
+                        });
+                    });
+                }
+            }
+        }
+        return {
+            CallExpression: (node) => {
+                var _a;
+                if (((_a = node.callee) === null || _a === void 0 ? void 0 : _a.type) === 'MemberExpression') {
+                    validateCallExpressionIgnoreDepth(node);
+                }
+            },
+            MemberExpression: (node) => {
+                validateCallExpressionIgnoreDepth(node);
+            },
+        };
+    },
+});