@croct/eslint-plugin 0.8.2 → 0.9.0

package/rules/jsx-attribute-spacing/index.js

@@ -1,60 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.jsxAttributeSpacing = void 0;
-const utils_1 = require("@typescript-eslint/utils");
-const createRule_1 = require("../createRule");
-exports.jsxAttributeSpacing = (0, createRule_1.createRule)({
-    name: 'jsx-attribute-spacing',
-    meta: {
-        type: 'suggestion',
-        docs: {
-            description: 'Enforces a surrounding line break in multiline JSX attributes.',
-        },
-        fixable: 'whitespace',
-        schema: [],
-        messages: {
-            missing: 'Missing new line.',
-        },
-    },
-    defaultOptions: [],
-    create: context => {
-        const sourceCode = context.getSourceCode();
-        function check(node) {
-            const { value } = node;
-            if (value?.type !== utils_1.TSESTree.AST_NODE_TYPES.JSXExpressionContainer) {
-                return;
-            }
-            const firstToken = sourceCode.getFirstToken(value.expression);
-            const lastToken = sourceCode.getLastToken(value.expression);
-            if ((firstToken.type === utils_1.TSESTree.AST_TOKEN_TYPES.Punctuator
-                && lastToken.type === utils_1.TSESTree.AST_TOKEN_TYPES.Punctuator)
-                || (firstToken.loc.start.line === lastToken.loc.end.line)) {
-                return;
-            }
-            const leftBrace = sourceCode.getFirstToken(value);
-            const rightBrace = sourceCode.getLastToken(value);
-            const tokens = [
-                [leftBrace, firstToken],
-                [lastToken, rightBrace],
-            ];
-            for (const [previousToken, currentToken] of tokens) {
-                if (previousToken.loc.end.line !== currentToken.loc.start.line) {
-                    continue;
-                }
-                const tokenBefore = sourceCode.getTokenBefore(currentToken, { includeComments: true });
-                context.report({
-                    node: node,
-                    loc: {
-                        start: tokenBefore.loc.end,
-                        end: currentToken.loc.start,
-                    },
-                    messageId: 'missing',
-                    fix: fixer => fixer.replaceTextRange([tokenBefore.range[1], currentToken.range[0]], '\n'),
-                });
-            }
-        }
-        return {
-            JSXAttribute: check,
-        };
-    },
-});

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

@@ -1,158 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.minChainedCallDepth = void 0;
-const utils_1 = require("@typescript-eslint/utils");
-const ast_utils_1 = require("@typescript-eslint/utils/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.',
-        },
-        fixable: 'whitespace',
-        schema: [
-            {
-                type: 'object',
-                properties: {
-                    maxLineLength: {
-                        type: 'integer',
-                        minimum: 1,
-                        default: 100,
-                    },
-                    ignoreChainDeeperThan: {
-                        type: 'integer',
-                        minimum: 1,
-                        maximum: 10,
-                        default: 2,
-                    },
-                },
-                additionalProperties: false,
-            },
-        ],
-        messages: {
-            unexpectedLineBreak: 'Unexpected line break.',
-        },
-    },
-    defaultOptions: [
-        {
-            maxLineLength: 100,
-            ignoreChainDeeperThan: 2,
-        },
-    ],
-    create: context => {
-        const sourceCode = context.getSourceCode();
-        let maxDepth = 0;
-        function getDepth(node) {
-            let depth = 0;
-            let currentNode = node;
-            while (currentNode.type === utils_1.AST_NODE_TYPES.CallExpression
-                || currentNode.type === utils_1.AST_NODE_TYPES.MemberExpression) {
-                if (currentNode.type === utils_1.AST_NODE_TYPES.MemberExpression) {
-                    currentNode = currentNode.object;
-                    depth += 1;
-                }
-                else if (currentNode.type === utils_1.AST_NODE_TYPES.CallExpression) {
-                    currentNode = currentNode.callee;
-                }
-            }
-            return depth;
-        }
-        function check(node) {
-            // If the node is a member expression inside a call/new expression skip,
-            // this is to ensure that we consider the correct line length of the result.
-            //
-            // Example:
-            //     ```ts
-            //     foo
-            //        .bar();
-            //     ```
-            //     The replacement of this input should be `foo.bar();`, which has 10 character.
-            //     Without this check it would consider the length up to `r`, which is 7.
-            if (node.type === utils_1.AST_NODE_TYPES.MemberExpression
-                && node.parent?.type === utils_1.AST_NODE_TYPES.CallExpression) {
-                return;
-            }
-            // If the node is a call/new expression we need to validate it's callee as a member
-            // expression.
-            // If the node itself is already a member expression, like the
-            // `property` in `this.property.function()`, we validate the node directly.
-            const callee = node.type === utils_1.AST_NODE_TYPES.CallExpression
-                ? node.callee
-                : node;
-            if (
-            // If the callee is not a member expression, skip.
-            // For example, root level calls like `foo();`.
-            callee.type !== utils_1.AST_NODE_TYPES.MemberExpression
-                // If the callee is a computed member expression, like `foo[bar]()`, skip.
-                || callee.computed
-                || callee.object.type === utils_1.AST_NODE_TYPES.NewExpression
-                // If the callee is already in the same line as it's object, skip.
-                || callee.object.loc.end.line === callee.property.loc.start.line) {
-                return;
-            }
-            const currentDepth = getDepth(callee);
-            maxDepth = Math.max(maxDepth, currentDepth);
-            // Only affect the root level as the total depth is must be known.
-            // If the current call is nested inside another call, skip.
-            if (currentDepth > 1) {
-                return;
-            }
-            const { maxLineLength = 100, ignoreChainDeeperThan = 2 } = context.options[0] ?? {};
-            // If the max depth is greater than ignore threshold, skip
-            //
-            // Example:
-            //     ```ts
-            //     Array(10)
-            //         .fill(0)
-            //         .map(x => x + 1)
-            //         .slice(0, 5);
-            //     ```
-            //     In this case the depth is 3, and the default value of ignoreChainDeeperThan is 2.
-            //     So the check can be skipped.
-            if (maxDepth > ignoreChainDeeperThan) {
-                return;
-            }
-            const { property } = 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 === utils_1.AST_TOKEN_TYPES.Punctuator
-                    && token.value === ';'),
-            });
-            const lineLength = 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(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: callee.object.loc.end,
-                    end: callee.property.loc.start,
-                },
-                messageId: 'unexpectedLineBreak',
-                fix: fixer => fixer.replaceTextRange([previousToken.range[1], nextToken.range[0]], punctuator.value),
-            });
-        }
-        return {
-            CallExpression: (node) => {
-                check(node);
-            },
-            MemberExpression: (node) => {
-                check(node);
-            },
-        };
-    },
-});

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

@@ -1,119 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.newlinePerChainedCall = void 0;
-const utils_1 = require("@typescript-eslint/utils");
-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',
-        },
-        fixable: 'whitespace',
-        schema: [
-            {
-                type: 'object',
-                properties: {
-                    ignoreChainDeeperThan: {
-                        type: 'integer',
-                        minimum: 1,
-                        maximum: 10,
-                        default: 2,
-                    },
-                },
-                additionalProperties: false,
-            },
-        ],
-        messages: {
-            expectedLineBreak: 'Expected line break before `{{propertyName}}`.',
-        },
-    },
-    defaultOptions: [
-        {
-            ignoreChainDeeperThan: 2,
-        },
-    ],
-    create: context => {
-        const options = context.options[0] ?? {};
-        const ignoreChainWithDepth = options.ignoreChainDeeperThan ?? 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 !== utils_1.TSESTree.AST_TOKEN_TYPES.Punctuator;
-        }
-        function validateCallExpressionIgnoreDepth(node) {
-            let hasCallExpression = false;
-            if (node.type === utils_1.TSESTree.AST_NODE_TYPES.CallExpression) {
-                hasCallExpression = true;
-            }
-            if (node.parent != null
-                && node.parent.type !== utils_1.TSESTree.AST_NODE_TYPES.CallExpression
-                && node.parent.type !== utils_1.TSESTree.AST_NODE_TYPES.MemberExpression) {
-                const memberExpressions = [];
-                let currentNode = ('callee' in node
-                    ? node.callee
-                    : node);
-                while (currentNode.type === utils_1.TSESTree.AST_NODE_TYPES.CallExpression
-                    || currentNode.type === utils_1.TSESTree.AST_NODE_TYPES.MemberExpression) {
-                    if (currentNode.type === utils_1.TSESTree.AST_NODE_TYPES.MemberExpression) {
-                        if (currentNode.property.type === utils_1.TSESTree.AST_NODE_TYPES.Identifier
-                            && !currentNode.computed) {
-                            memberExpressions.push(currentNode);
-                        }
-                        currentNode = currentNode.object;
-                    }
-                    else if (currentNode.type === utils_1.TSESTree.AST_NODE_TYPES.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 === utils_1.TSESTree.AST_NODE_TYPES.MemberExpression
-                        && (rootNode.parent != null && (rootNode.parent.type === utils_1.TSESTree.AST_NODE_TYPES.CallExpression
-                            || rootNode.parent.type === utils_1.TSESTree.AST_NODE_TYPES.MemberExpression))
-                        && (rootNode.object.type === utils_1.TSESTree.AST_NODE_TYPES.ThisExpression
-                            || rootNode.object.type === utils_1.TSESTree.AST_NODE_TYPES.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) => {
-                if (node.callee?.type === utils_1.TSESTree.AST_NODE_TYPES.MemberExpression) {
-                    validateCallExpressionIgnoreDepth(node);
-                }
-            },
-            MemberExpression: (node) => {
-                validateCallExpressionIgnoreDepth(node);
-            },
-        };
-    },
-});

package/rules/parameter-destructuring/index.js

@@ -1,60 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.parameterDestructuring = void 0;
-const utils_1 = require("@typescript-eslint/utils");
-const createRule_1 = require("../createRule");
-exports.parameterDestructuring = (0, createRule_1.createRule)({
-    name: 'parameter-destructuring',
-    meta: {
-        type: 'layout',
-        docs: {
-            description: 'Prevent noisy destructuring on parameters',
-        },
-        hasSuggestions: true,
-        schema: [],
-        messages: {
-            unexpectedDestructuring: ('Destructuring should not be done in the parameters. '
-                + 'Bind to a variable and destructure inside the function.'),
-        },
-    },
-    defaultOptions: [],
-    create: context => {
-        const sourceCode = context.getSourceCode();
-        return {
-            ObjectPattern: function checkObjectPattern(node) {
-                const { parent } = node;
-                // Skip for destructuring in contexts unrelated to function parameters
-                if (parent?.type !== utils_1.AST_NODE_TYPES.FunctionExpression
-                    && parent?.type !== utils_1.AST_NODE_TYPES.FunctionDeclaration
-                    && parent?.type !== utils_1.AST_NODE_TYPES.ArrowFunctionExpression) {
-                    return;
-                }
-                // Allow one-line destructuring
-                if (node.loc.start.line === node.loc.end.line) {
-                    return;
-                }
-                const { body } = parent;
-                context.report({
-                    node: node,
-                    messageId: 'unexpectedDestructuring',
-                    suggest: body.type === utils_1.AST_NODE_TYPES.BlockStatement
-                        ? [
-                            {
-                                messageId: 'unexpectedDestructuring',
-                                fix: (fixer) => [
-                                    // Replace the destructuring with a variable declaration
-                                    fixer.replaceText(node, 'value'),
-                                    // Add the destructuring inside the body
-                                    fixer.insertTextAfter(
-                                    // Null safety: a block expression always have the `{` token
-                                    // opening the body of the function.
-                                    sourceCode.getFirstToken(body), `\nconst ${sourceCode.getText(node)} = value;\n`),
-                                ],
-                            },
-                        ]
-                        : null,
-                });
-            },
-        };
-    },
-});