@croct/eslint-plugin 0.2.1 → 0.2.2

package/configs/index.d.ts

@@ -192,6 +192,7 @@ export declare const configs: {
             '@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[];

package/configs/javascript.d.ts

@@ -5,6 +5,7 @@ export declare const javascript: {
         '@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[];

package/configs/javascript.js

@@ -17,6 +17,7 @@ exports.javascript = {
         '@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': [

package/index.d.ts

@@ -17,6 +17,11 @@ declare const configuration: {
             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: {
@@ -212,6 +217,7 @@ declare const configuration: {
                 '@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[];

package/package.json

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

package/rules/index.d.ts

@@ -16,4 +16,9 @@ export declare const rules: {
         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

@@ -5,9 +5,11 @@ 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.js

@@ -53,6 +53,7 @@ exports.newlinePerChainedCall = (0, createRule_1.createRule)({
             return token.value !== ')' || token.type !== 'Punctuator';
         }
         function validateCallExpressionIgnoreDepth(node) {
+            var _a;
             let hasCallExpression = false;
             if (node.type === 'CallExpression') {
                 hasCallExpression = true;
@@ -84,11 +85,12 @@ exports.newlinePerChainedCall = (0, createRule_1.createRule)({
                         .filter(hasObjectAndPropertyOnSameLine);
                     const rootNode = expressionsOnSameLine[expressionsOnSameLine.length - 1];
                     if (rootNode.type === 'MemberExpression'
-                        && rootNode.object.type === 'ThisExpression') {
+                        && ((_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 => {
+                    expressionsOnSameLine.forEach(memberExpression => {
                         context.report({
                             node: memberExpression.property,
                             loc: memberExpression.property.loc.start,