@croct/eslint-plugin 0.1.0

package/index.d.ts

@@ -0,0 +1,266 @@
+declare const configuration: {
+    rules: {
+        'argument-spacing': import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleModule<"missing", never[], {
+            CallExpression: (node: import("@typescript-eslint/types/dist/ast-spec").CallExpression | import("@typescript-eslint/types/dist/ast-spec").NewExpression) => void;
+            NewExpression: (node: import("@typescript-eslint/types/dist/ast-spec").CallExpression | import("@typescript-eslint/types/dist/ast-spec").NewExpression) => void;
+        }>;
+        'jsx-attribute-spacing': import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleModule<"missing", never[], {
+            JSXAttribute: (node: import("@typescript-eslint/types/dist/ast-spec").JSXAttribute) => void;
+        }>;
+        'complex-expression-spacing': import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleModule<"missing", never[], {
+            ArrowFunctionExpression: (node: import("@typescript-eslint/types/dist/ast-spec").ArrowFunctionExpression) => void;
+            IfStatement: (node: import("@typescript-eslint/types/dist/ast-spec").IfStatement) => void;
+        }>;
+    };
+    configs: {
+        cypress: {
+            extends: string[];
+            plugins: string[];
+            rules: {
+                'no-loop-func': number;
+                'cypress/no-assigning-return-values': string;
+                'cypress/no-unnecessary-waiting': string;
+                'cypress/assertion-before-screenshot': string;
+                'cypress/no-async-tests': string;
+                'cypress/no-pause': string;
+                '@typescript-eslint/no-namespace': string;
+            };
+        };
+        react: {
+            extends: string[];
+            plugins: string[];
+            rules: {
+                '@croct/jsx-attribute-spacing': string;
+                'react/jsx-wrap-multilines': string;
+                'react/display-name': string;
+                'react/jsx-newline': (string | {
+                    prevent: boolean;
+                })[];
+                'react/jsx-no-bind': (string | {
+                    allowArrowFunctions: boolean;
+                    allowBind: boolean;
+                    allowFunctions: boolean;
+                })[];
+                'react/no-unstable-nested-components': (string | {
+                    allowAsProps: boolean;
+                })[];
+                'react/jsx-no-useless-fragment': (string | {
+                    allowExpressions: boolean;
+                })[];
+                'react/function-component-definition': string;
+                'testing-library/no-container': string;
+                'testing-library/no-node-access': string;
+                'testing-library/await-async-utils': string;
+                'jsx-a11y/aria-role': (string | {
+                    ignoreNonDOM: boolean;
+                })[];
+                'react/jsx-uses-react': string;
+                'react/react-in-jsx-scope': string;
+                'react/jsx-one-expression-per-line': string;
+                'react/prop-types': string;
+                'react/require-default-props': string;
+                'react/jsx-fragments': string[];
+                'react-hooks/rules-of-hooks': string;
+                'react-hooks/exhaustive-deps': string;
+                'react/jsx-filename-extension': (number | {
+                    extensions: string[];
+                })[];
+                'react/jsx-indent': (string | number)[];
+                'react/jsx-indent-props': string;
+                'react/jsx-props-no-spreading': string;
+                'no-restricted-imports': (string | {
+                    name: string;
+                    importNames: string[];
+                    message: string;
+                })[];
+                'import/order': (string | {
+                    groups: string[];
+                    pathGroups: {
+                        pattern: string;
+                        group: string;
+                        position: string;
+                    }[];
+                    pathGroupsExcludedImportTypes: string[];
+                    'newlines-between': string;
+                    alphabetize: {
+                        order: string;
+                        caseInsensitive: boolean;
+                    };
+                })[];
+            };
+        };
+        typescript: {
+            extends: string[];
+            plugins: string[];
+            rules: {
+                '@typescript-eslint/array-type': (string | {
+                    default: string;
+                })[];
+                '@typescript-eslint/prefer-as-const': string;
+                '@typescript-eslint/adjacent-overload-signatures': string;
+                '@typescript-eslint/type-annotation-spacing': string;
+                '@typescript-eslint/semi': string[];
+                '@typescript-eslint/strict-boolean-expressions': (string | {
+                    allowString: boolean;
+                    allowNumber: boolean;
+                    allowNullableObject: boolean;
+                })[];
+                '@typescript-eslint/prefer-regexp-exec': string;
+                '@typescript-eslint/prefer-optional-chain': string;
+                'no-shadow': string;
+                '@typescript-eslint/no-shadow': (string | {
+                    ignoreTypeValueShadow: boolean;
+                    ignoreFunctionTypeParameterNameValueShadow: boolean;
+                })[];
+                '@typescript-eslint/no-empty-interface': string;
+                '@typescript-eslint/explicit-member-accessibility': string[];
+                '@typescript-eslint/explicit-module-boundary-types': string;
+                '@typescript-eslint/explicit-function-return-type': string[];
+                '@typescript-eslint/no-explicit-any': string;
+                'no-use-before-define': string;
+                '@typescript-eslint/no-use-before-define': string;
+                'no-unused-expressions': string;
+                '@typescript-eslint/no-unused-expressions': string;
+                indent: (string | number | {
+                    SwitchCase: number;
+                })[];
+                '@typescript-eslint/no-unused-vars': string;
+                'no-unused-vars': string;
+                '@typescript-eslint/no-non-null-assertion': string;
+                'object-curly-spacing': string;
+                '@typescript-eslint/object-curly-spacing': string;
+                '@typescript-eslint/member-delimiter-style': (string | {
+                    multiline: {
+                        delimiter: string;
+                        requireLast: boolean;
+                    };
+                    singleline: {
+                        delimiter: string;
+                        requireLast: boolean;
+                    };
+                    overrides: {
+                        interface: {
+                            singleline: {
+                                delimiter: string;
+                            };
+                            multiline: {
+                                delimiter: string;
+                            };
+                        };
+                    };
+                })[];
+                'no-undef': string;
+            };
+            overrides: {
+                files: string[];
+                extends: string[];
+                plugins: string[];
+                rules: {
+                    'no-new-object': string;
+                };
+                env: {
+                    jest: boolean;
+                };
+            }[];
+        };
+        javascript: {
+            extends: string[];
+            plugins: string[];
+            rules: {
+                '@croct/argument-spacing': string;
+                '@croct/complex-expression-spacing': string;
+                'array-bracket-newline': string[];
+                'multiline-ternary': string[];
+                'no-undef-init': string;
+                'jest/consistent-test-it': (string | {
+                    fn: string;
+                })[];
+                'jest/no-large-snapshots': string;
+                'jest/prefer-expect-resolves': string;
+                'jest/prefer-lowercase-title': (string | {
+                    ignore: string[];
+                })[];
+                'jest/prefer-spy-on': string;
+                'jest/require-top-level-describe': string;
+                'jest/prefer-to-contain': string;
+                'jest/prefer-hooks-on-top': string;
+                'jest/prefer-equality-matcher': string;
+                'jest/no-test-return-statement': string;
+                'function-call-argument-newline': string[];
+                'no-underscore-dangle': string;
+                'import/no-default-export': string;
+                'array-element-newline': string[];
+                'import-newlines/enforce': (string | {
+                    items: number;
+                    'max-len': number;
+                })[];
+                'no-smart-quotes/no-smart-quotes': string;
+                'no-shadow': string;
+                'import/prefer-default-export': string;
+                'import/no-extraneous-dependencies': string;
+                'no-use-before-define': string;
+                'arrow-parens': string[];
+                'class-methods-use-this': string;
+                'consistent-return': string;
+                'default-case': string;
+                'import/extensions': string[];
+                'import/no-unresolved': string;
+                indent: (string | number | {
+                    SwitchCase: number;
+                })[];
+                'linebreak-style': string[];
+                'max-classes-per-file': string;
+                'max-len': (string | {
+                    code: number;
+                    ignoreStrings: boolean;
+                })[];
+                'no-await-in-loop': string;
+                'no-bitwise': string;
+                'no-continue': string;
+                'no-multiple-empty-lines': (string | {
+                    max: number;
+                    maxEOF: number;
+                    maxBOF: number;
+                })[];
+                'no-plusplus': (string | {
+                    allowForLoopAfterthoughts: boolean;
+                })[];
+                'no-unused-expressions': string;
+                'no-unused-vars': string;
+                'no-restricted-syntax': string[];
+                'object-curly-newline': (string | {
+                    multiline: boolean;
+                    consistent: boolean;
+                })[];
+                'object-curly-spacing': string[];
+                'require-await': string;
+                'object-shorthand': string[];
+                'padding-line-between-statements': (string | {
+                    blankLine: string;
+                    prev: string;
+                    next: string[];
+                } | {
+                    blankLine: string;
+                    prev: string[];
+                    next: string;
+                } | {
+                    blankLine: string;
+                    prev: string[];
+                    next: string[];
+                })[];
+            };
+            overrides: {
+                files: string[];
+                extends: string[];
+                plugins: string[];
+                rules: {
+                    'no-new-object': string;
+                };
+                env: {
+                    jest: boolean;
+                };
+            }[];
+        };
+    };
+};
+export = configuration;

package/index.js

@@ -0,0 +1,8 @@
+"use strict";
+const rules_1 = require("./rules");
+const configs_1 = require("./configs");
+const configuration = {
+    rules: rules_1.rules,
+    configs: configs_1.configs,
+};
+module.exports = configuration;

package/package.json

@@ -0,0 +1,68 @@
+{
+  "name": "@croct/eslint-plugin",
+  "version": "0.1.0",
+  "description": "ESLint rules and presets applied to all Croct JavaScript projects.",
+  "author": "",
+  "license": "UNLICENSED",
+  "main": "index.js",
+  "types": "index.d.ts",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/croct-tech/coding-standard-js.git"
+  },
+  "bugs": {
+    "url": "https://github.com/croct-tech/coding-standard-js/issues"
+  },
+  "homepage": "https://github.com/croct-tech/coding-standard-js",
+  "scripts": {
+    "lint": "eslint 'src/**/*.{ts,tsx}'",
+    "test": "jest -c jest.config.js --coverage",
+    "validate": "tsc --noEmit",
+    "build": "tsc -p tsconfig.build.json"
+  },
+  "keywords": [
+    "eslint",
+    "eslint-plugin",
+    "config",
+    "croct",
+    "javascript",
+    "styleguide",
+    "typescript",
+    "react",
+    "cypress"
+  ],
+  "dependencies": {
+    "@rushstack/eslint-patch": "^1.1",
+    "@typescript-eslint/eslint-plugin": "^5.10",
+    "@typescript-eslint/experimental-utils": "^5.10",
+    "eslint-config-airbnb": "^19.0",
+    "eslint-config-airbnb-base": "^15.0",
+    "eslint-plugin-cypress": "^2.12",
+    "eslint-plugin-import": "^2.25",
+    "eslint-plugin-import-newlines": "^1.1",
+    "eslint-plugin-jest": "^26.1",
+    "eslint-plugin-jest-dom": "^4.0",
+    "eslint-plugin-jsx-a11y": "^6.5",
+    "eslint-plugin-no-smart-quotes": "^1.3",
+    "eslint-plugin-react": "^7.28",
+    "eslint-plugin-react-hooks": "^4.3",
+    "eslint-plugin-testing-library": "^5.0"
+  },
+  "devDependencies": {
+    "@types/eslint": "^8.4",
+    "@types/jest": "^27.4",
+    "@typescript-eslint/parser": "^5.10",
+    "@typescript-eslint/types": "^5.10",
+    "@typescript-eslint/utils": "^5.10",
+    "eslint": "^8.8",
+    "eslint-plugin-eslint-plugin": "^4.1.0",
+    "eslint-plugin-self": "^1.2.1",
+    "jest": "^27.5",
+    "ts-jest": "^27.1",
+    "typescript": "^4.5"
+  },
+  "peerDependencies": {
+    "@typescript-eslint/parser": ">= 5",
+    "eslint": ">= 8"
+  }
+}

package/rules/argument-spacing/index.d.ts

@@ -0,0 +1,5 @@
+import { TSESTree } from '@typescript-eslint/experimental-utils';
+export declare const argumentSpacing: import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleModule<"missing", never[], {
+    CallExpression: (node: TSESTree.NewExpression | TSESTree.CallExpression) => void;
+    NewExpression: (node: TSESTree.NewExpression | TSESTree.CallExpression) => void;
+}>;

package/rules/argument-spacing/index.js

@@ -0,0 +1,68 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.argumentSpacing = void 0;
+const createRule_1 = require("../createRule");
+exports.argumentSpacing = (0, createRule_1.createRule)({
+    name: 'argument-spacing',
+    meta: {
+        type: 'suggestion',
+        docs: {
+            description: 'Enforces a surrounding line break before and after the argument list in multiline functional calls.',
+            recommended: 'error',
+        },
+        fixable: 'whitespace',
+        schema: [],
+        messages: {
+            missing: 'Missing new line.',
+        },
+    },
+    defaultOptions: [],
+    create: context => {
+        function check(node) {
+            const sourceCode = context.getSourceCode();
+            if (node.arguments.length === 0) {
+                return;
+            }
+            const lastArgument = node.arguments[node.arguments.length - 1];
+            const firstToken = sourceCode.getTokenBefore(node.arguments[0], {
+                filter: token => token.value === '(',
+            });
+            const lastToken = sourceCode.getTokenAfter(lastArgument, {
+                filter: token => token.value === ')',
+            });
+            if (firstToken.loc.start.line === lastToken.loc.end.line) {
+                return;
+            }
+            const lastArgumentFirstToken = sourceCode.getFirstToken(lastArgument);
+            if ((lastArgument.type !== 'ArrowFunctionExpression' || lastArgument.body.type === 'BlockStatement')
+                && firstToken.loc.start.line === lastArgumentFirstToken.loc.start.line) {
+                return;
+            }
+            const tokens = [
+                firstToken,
+                ...node.arguments,
+                lastToken,
+            ];
+            for (let i = 1; i < tokens.length; i++) {
+                const previousToken = tokens[i - 1];
+                const currentToken = tokens[i];
+                if (previousToken.loc.end.line === currentToken.loc.start.line) {
+                    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 {
+            CallExpression: check,
+            NewExpression: check,
+        };
+    },
+});

package/rules/complex-expression-spacing/index.d.ts

@@ -0,0 +1,5 @@
+import { TSESTree } from '@typescript-eslint/experimental-utils';
+export declare const complexExpressionSpacing: import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleModule<"missing", never[], {
+    ArrowFunctionExpression: (node: TSESTree.ArrowFunctionExpression) => void;
+    IfStatement: (node: TSESTree.IfStatement) => void;
+}>;

package/rules/complex-expression-spacing/index.js

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.complexExpressionSpacing = void 0;
+const createRule_1 = require("../createRule");
+exports.complexExpressionSpacing = (0, createRule_1.createRule)({
+    name: 'complex-expression-spacing',
+    meta: {
+        type: 'suggestion',
+        docs: {
+            description: 'Enforces a surrounding line break in complex expression.',
+            recommended: 'error',
+        },
+        fixable: 'whitespace',
+        schema: [],
+        messages: {
+            missing: 'Missing new line.',
+        },
+    },
+    defaultOptions: [],
+    create: context => {
+        const sourceCode = context.getSourceCode();
+        function check(node) {
+            const parentPreviousToken = sourceCode.getTokenBefore(node, {
+                filter: token => token.type === 'Punctuator',
+            });
+            const parentNextToken = sourceCode.getTokenAfter(node, {
+                filter: token => token.type === 'Punctuator',
+            });
+            if (parentPreviousToken.loc.end.line === parentNextToken.loc.start.line) {
+                return;
+            }
+            const firstToken = sourceCode.getFirstToken(node);
+            const lastToken = sourceCode.getLastToken(node);
+            const tokens = [
+                [parentPreviousToken, firstToken],
+                [lastToken, parentNextToken],
+            ];
+            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 {
+            ArrowFunctionExpression: (node) => {
+                const { body } = node;
+                if (body.type === 'ConditionalExpression') {
+                    check(body);
+                }
+            },
+            IfStatement: (node) => {
+                check(node.test);
+            },
+        };
+    },
+});

package/rules/createRule.d.ts

@@ -0,0 +1,2 @@
+import { ESLintUtils } from '@typescript-eslint/experimental-utils';
+export declare const createRule: <TOptions extends readonly unknown[], TMessageIds extends string, TRuleListener extends import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleListener = import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleListener>({ name, meta, ...rule }: Readonly<ESLintUtils.RuleWithMetaAndName<TOptions, TMessageIds, TRuleListener>>) => import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleModule<TMessageIds, TOptions, TRuleListener>;

package/rules/createRule.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createRule = void 0;
+const experimental_utils_1 = require("@typescript-eslint/experimental-utils");
+exports.createRule = experimental_utils_1.ESLintUtils.RuleCreator(name => `https://github.com/croct-tech/coding-standard-js/tree/master/docs/${name}.md`);

package/rules/index.d.ts

@@ -0,0 +1,13 @@
+export declare const rules: {
+    'argument-spacing': import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleModule<"missing", never[], {
+        CallExpression: (node: import("@typescript-eslint/types/dist/ast-spec").CallExpression | import("@typescript-eslint/types/dist/ast-spec").NewExpression) => void;
+        NewExpression: (node: import("@typescript-eslint/types/dist/ast-spec").CallExpression | import("@typescript-eslint/types/dist/ast-spec").NewExpression) => void;
+    }>;
+    'jsx-attribute-spacing': import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleModule<"missing", never[], {
+        JSXAttribute: (node: import("@typescript-eslint/types/dist/ast-spec").JSXAttribute) => void;
+    }>;
+    'complex-expression-spacing': import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleModule<"missing", never[], {
+        ArrowFunctionExpression: (node: import("@typescript-eslint/types/dist/ast-spec").ArrowFunctionExpression) => void;
+        IfStatement: (node: import("@typescript-eslint/types/dist/ast-spec").IfStatement) => void;
+    }>;
+};

package/rules/index.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+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");
+exports.rules = {
+    'argument-spacing': argument_spacing_1.argumentSpacing,
+    'jsx-attribute-spacing': jsx_attribute_spacing_1.jsxAttributeSpacing,
+    'complex-expression-spacing': complex_expression_spacing_1.complexExpressionSpacing,
+};

package/rules/jsx-attribute-spacing/index.d.ts

@@ -0,0 +1,4 @@
+import { TSESTree } from '@typescript-eslint/experimental-utils';
+export declare const jsxAttributeSpacing: import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleModule<"missing", never[], {
+    JSXAttribute: (node: TSESTree.JSXAttribute) => void;
+}>;

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

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.jsxAttributeSpacing = void 0;
+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.',
+            recommended: 'error',
+        },
+        fixable: 'whitespace',
+        schema: [],
+        messages: {
+            missing: 'Missing new line.',
+        },
+    },
+    defaultOptions: [],
+    create: context => {
+        const sourceCode = context.getSourceCode();
+        function check(node) {
+            const { value } = node;
+            if (value === null || value.type !== 'JSXExpressionContainer') {
+                return;
+            }
+            const firstToken = sourceCode.getFirstToken(value.expression);
+            const lastToken = sourceCode.getLastToken(value.expression);
+            if ((firstToken.type === 'Punctuator' && lastToken.type === '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,
+        };
+    },
+});