@croct/eslint-plugin 0.8.2 → 0.9.0

package/configs/react.js

@@ -1,355 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createReactConfig = createReactConfig;
-const eslint_plugin_react_1 = __importDefault(require("eslint-plugin-react"));
-const eslint_plugin_react_hooks_1 = __importDefault(require("eslint-plugin-react-hooks"));
-const eslint_plugin_testing_library_1 = __importDefault(require("eslint-plugin-testing-library"));
-const eslint_plugin_jest_dom_1 = __importDefault(require("eslint-plugin-jest-dom"));
-// @ts-expect-error - no types available
-const eslint_plugin_jsx_a11y_1 = __importDefault(require("eslint-plugin-jsx-a11y"));
-// @ts-expect-error - no types available
-const eslint_plugin_1 = __importDefault(require("@stylistic/eslint-plugin"));
-const baseRules = {
-    // Custom rule
-    '@croct/jsx-attribute-spacing': 'error',
-    // React rules (from airbnb, with customizations)
-    'react/display-name': 'off',
-    'react/forbid-prop-types': ['error', {
-            forbid: ['any', 'array', 'object'],
-            checkContextTypes: true,
-            checkChildContextTypes: true,
-        }],
-    'react/forbid-dom-props': ['off', { forbid: [] }],
-    'react/jsx-boolean-value': ['error', 'never', { always: [] }],
-    'react/jsx-closing-bracket-location': ['error', 'line-aligned'],
-    'react/jsx-closing-tag-location': 'error',
-    'react/jsx-curly-spacing': ['error', 'never', { allowMultiline: true }],
-    'react/jsx-handler-names': ['off', {
-            eventHandlerPrefix: 'handle',
-            eventHandlerPropPrefix: 'on',
-        }],
-    'react/jsx-indent-props': 'off',
-    'react/jsx-key': 'off',
-    'react/jsx-max-props-per-line': ['error', { maximum: 1, when: 'multiline' }],
-    'react/jsx-no-bind': [
-        'error',
-        {
-            allowArrowFunctions: true,
-            allowBind: false,
-            allowFunctions: true,
-        },
-    ],
-    'react/jsx-no-duplicate-props': ['error', { ignoreCase: true }],
-    'react/jsx-no-literals': ['off', { noStrings: true }],
-    'react/jsx-no-undef': 'error',
-    'react/jsx-pascal-case': ['error', {
-            allowAllCaps: true,
-            ignore: [],
-        }],
-    'react/sort-prop-types': ['off', {
-            ignoreCase: true,
-            callbacksLast: false,
-            requiredFirst: false,
-            sortShapeProp: true,
-        }],
-    'react/jsx-sort-prop-types': 'off',
-    'react/jsx-sort-props': [
-        'error',
-        {
-            noSortAlphabetically: true,
-            multiline: 'last',
-        },
-    ],
-    'react/jsx-sort-default-props': ['off', {
-            ignoreCase: true,
-        }],
-    'react/jsx-uses-react': 'off',
-    'react/jsx-uses-vars': 'error',
-    'react/no-danger': 'warn',
-    'react/no-deprecated': ['error'],
-    'react/no-did-mount-set-state': 'off',
-    'react/no-did-update-set-state': 'error',
-    'react/no-will-update-set-state': 'error',
-    'react/no-direct-mutation-state': 'off',
-    'react/no-is-mounted': 'error',
-    'react/no-multi-comp': 'off',
-    'react/no-set-state': 'off',
-    'react/no-string-refs': 'error',
-    'react/no-unknown-property': 'error',
-    'react/prefer-es6-class': ['error', 'always'],
-    'react/prefer-stateless-function': ['error', { ignorePureComponents: true }],
-    'react/prop-types': 'off',
-    'react/react-in-jsx-scope': 'off',
-    'react/require-render-return': 'error',
-    'react/self-closing-comp': 'error',
-    'react/sort-comp': ['error', {
-            order: [
-                'static-variables',
-                'static-methods',
-                'instance-variables',
-                'lifecycle',
-                '/^handle.+$/',
-                '/^on.+$/',
-                'getters',
-                'setters',
-                '/^(get|set)(?!(InitialState$|DefaultProps$|ChildContext$)).+$/',
-                'instance-methods',
-                'everything-else',
-                'rendering',
-            ],
-            groups: {
-                lifecycle: [
-                    'displayName',
-                    'propTypes',
-                    'contextTypes',
-                    'childContextTypes',
-                    'mixins',
-                    'statics',
-                    'defaultProps',
-                    'constructor',
-                    'getDefaultProps',
-                    'getInitialState',
-                    'state',
-                    'getChildContext',
-                    'getDerivedStateFromProps',
-                    'componentWillMount',
-                    'UNSAFE_componentWillMount',
-                    'componentDidMount',
-                    'componentWillReceiveProps',
-                    'UNSAFE_componentWillReceiveProps',
-                    'shouldComponentUpdate',
-                    'componentWillUpdate',
-                    'UNSAFE_componentWillUpdate',
-                    'getSnapshotBeforeUpdate',
-                    'componentDidUpdate',
-                    'componentDidCatch',
-                    'componentWillUnmount',
-                ],
-                rendering: [
-                    '/^render.+$/',
-                    'render',
-                ],
-            },
-        }],
-    'react/jsx-wrap-multilines': 'error',
-    'react/jsx-first-prop-new-line': ['error', 'multiline-multiprop'],
-    'react/jsx-equals-spacing': ['error', 'never'],
-    'react/jsx-indent': ['error', 4],
-    'react/jsx-no-target-blank': ['error', { enforceDynamicLinks: 'always' }],
-    'react/jsx-filename-extension': [
-        1,
-        {
-            extensions: ['.tsx'],
-        },
-    ],
-    'react/jsx-no-comment-textnodes': 'error',
-    'react/no-render-return-value': 'error',
-    'react/require-optimization': ['off', { allowDecorators: [] }],
-    'react/no-find-dom-node': 'error',
-    'react/forbid-component-props': ['off', { forbid: [] }],
-    'react/forbid-elements': ['off', { forbid: [] }],
-    'react/no-danger-with-children': 'error',
-    'react/no-unused-prop-types': ['error', {
-            customValidators: [],
-            skipShapeProps: true,
-        }],
-    'react/style-prop-object': 'error',
-    'react/no-unescaped-entities': 'error',
-    'react/no-children-prop': 'error',
-    'react/jsx-tag-spacing': ['error', {
-            closingSlash: 'never',
-            beforeSelfClosing: 'always',
-            afterOpening: 'never',
-            beforeClosing: 'never',
-        }],
-    'react/jsx-space-before-closing': ['off', 'always'],
-    'react/no-array-index-key': 'error',
-    'react/require-default-props': 'off',
-    'react/forbid-foreign-prop-types': ['warn', { allowInPropTypes: true }],
-    'react/void-dom-elements-no-children': 'error',
-    'react/default-props-match-prop-types': ['error', { allowRequiredDefaults: false }],
-    'react/no-redundant-should-component-update': 'error',
-    'react/no-unused-state': 'error',
-    'react/boolean-prop-naming': ['off', {
-            propTypeNames: ['bool', 'mutuallyExclusiveTrueProps'],
-            rule: '^(is|has)[A-Z]([A-Za-z0-9]?)+',
-            message: '',
-        }],
-    'react/no-typos': 'error',
-    'react/jsx-curly-brace-presence': ['error', { props: 'never', children: 'never' }],
-    'react/jsx-one-expression-per-line': 'off',
-    'react/destructuring-assignment': 'off',
-    'react/no-access-state-in-setstate': 'error',
-    'react/button-has-type': ['error', {
-            button: true,
-            submit: true,
-            reset: false,
-        }],
-    'react/jsx-child-element-spacing': 'off',
-    'react/no-this-in-sfc': 'error',
-    'react/jsx-max-depth': 'off',
-    'react/jsx-props-no-multi-spaces': 'error',
-    'react/no-unsafe': 'off',
-    'react/jsx-fragments': ['error', 'element'],
-    'react/jsx-curly-newline': ['error', {
-            multiline: 'consistent',
-            singleline: 'consistent',
-        }],
-    'react/state-in-constructor': ['error', 'always'],
-    'react/static-property-placement': ['error', 'property assignment'],
-    'react/jsx-props-no-spreading': 'off',
-    'react/prefer-read-only-props': 'off',
-    'react/jsx-no-script-url': ['error', [
-            {
-                name: 'Link',
-                props: ['to'],
-            },
-        ]],
-    'react/jsx-no-useless-fragment': [
-        'error',
-        {
-            allowExpressions: true,
-        },
-    ],
-    'react/no-adjacent-inline-elements': 'off',
-    'react/function-component-definition': 'off',
-    'react/jsx-newline': [
-        'error',
-        {
-            prevent: true,
-        },
-    ],
-    'react/jsx-no-constructed-context-values': 'error',
-    'react/no-unstable-nested-components': [
-        'error',
-        {
-            allowAsProps: true,
-        },
-    ],
-    'react/no-namespace': 'error',
-    'react/prefer-exact-props': 'error',
-    'react/no-arrow-function-lifecycle': 'error',
-    'react/no-invalid-html-attribute': 'error',
-    'react/no-unused-class-component-methods': 'error',
-    // React Hooks rules
-    'react-hooks/rules-of-hooks': 'error',
-    'react-hooks/exhaustive-deps': 'warn',
-    // Testing Library rules (overrides)
-    'testing-library/no-container': 'off',
-    'testing-library/no-node-access': 'off',
-    'testing-library/await-async-utils': 'off',
-    // JSX A11y rules (overrides)
-    'jsx-a11y/aria-role': [
-        'error',
-        {
-            ignoreNonDOM: true,
-        },
-    ],
-    // Underscore dangle override for Redux DevTools
-    'no-underscore-dangle': ['error', {
-            allow: ['__REDUX_DEVTOOLS_EXTENSION_COMPOSE__'],
-            allowAfterThis: false,
-            allowAfterSuper: false,
-            enforceInMethodNames: true,
-        }],
-    // Class methods use this override for React lifecycle methods
-    'class-methods-use-this': ['error', {
-            exceptMethods: [
-                'render',
-                'getInitialState',
-                'getDefaultProps',
-                'getChildContext',
-                'componentWillMount',
-                'UNSAFE_componentWillMount',
-                'componentDidMount',
-                'componentWillReceiveProps',
-                'UNSAFE_componentWillReceiveProps',
-                'shouldComponentUpdate',
-                'componentWillUpdate',
-                'UNSAFE_componentWillUpdate',
-                'componentDidUpdate',
-                'componentWillUnmount',
-                'componentDidCatch',
-                'getSnapshotBeforeUpdate',
-            ],
-        }],
-    // Import restrictions
-    'no-restricted-imports': [
-        'error',
-        {
-            name: 'react',
-            importNames: ['default'],
-            message: 'The React runtime is automatically imported, '
-                + 'you can simply omit the import declaration in this case.',
-        },
-    ],
-    // Import order for React (using import-x)
-    'import-x/order': [
-        'error',
-        {
-            groups: [
-                'builtin',
-                'external',
-                'internal',
-            ],
-            pathGroups: [
-                {
-                    pattern: 'react',
-                    group: 'external',
-                    position: 'before',
-                },
-            ],
-            pathGroupsExcludedImportTypes: ['react'],
-            'newlines-between': 'never',
-            alphabetize: {
-                order: 'asc',
-                caseInsensitive: true,
-            },
-        },
-    ],
-};
-// Factory function to create React config with the plugin reference
-function createReactConfig(plugin, javascriptConfig) {
-    return [
-        ...javascriptConfig,
-        eslint_plugin_react_1.default.configs.flat.recommended,
-        eslint_plugin_testing_library_1.default.configs['flat/react'],
-        eslint_plugin_jest_dom_1.default.configs['flat/recommended'],
-        eslint_plugin_jsx_a11y_1.default.flatConfigs.recommended,
-        {
-            name: '@croct/react',
-            plugins: {
-                'react-hooks': eslint_plugin_react_hooks_1.default,
-                '@stylistic': eslint_plugin_1.default,
-                '@croct': plugin,
-            },
-            languageOptions: {
-                parserOptions: {
-                    ecmaFeatures: {
-                        jsx: true,
-                    },
-                },
-            },
-            settings: {
-                'import-x/resolver': {
-                    node: {
-                        extensions: ['.js', '.jsx', '.json'],
-                    },
-                },
-                react: {
-                    pragma: 'React',
-                    version: 'detect',
-                },
-                propWrapperFunctions: [
-                    'forbidExtraProps',
-                    'exact',
-                    'Object.freeze',
-                ],
-            },
-            rules: baseRules,
-        },
-    ];
-}

package/configs/typescript.js

@@ -1,117 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createTypescriptConfig = createTypescriptConfig;
-const typescript_eslint_1 = __importDefault(require("typescript-eslint"));
-const parser_1 = __importDefault(require("@typescript-eslint/parser"));
-const eslint_plugin_jest_1 = __importDefault(require("eslint-plugin-jest"));
-// @ts-expect-error - no types available
-const eslint_plugin_1 = __importDefault(require("@stylistic/eslint-plugin"));
-const baseRules = {
-    'import-x/export': 'off',
-    '@typescript-eslint/array-type': ['error', {
-            default: 'array-simple',
-        }],
-    '@typescript-eslint/prefer-as-const': 'error',
-    '@typescript-eslint/adjacent-overload-signatures': 'error',
-    '@stylistic/type-annotation-spacing': 'error',
-    '@stylistic/semi': ['error', 'always'],
-    '@typescript-eslint/strict-boolean-expressions': ['error', {
-            allowString: false,
-            allowNumber: false,
-            allowNullableObject: false,
-        }],
-    '@typescript-eslint/prefer-optional-chain': 'error',
-    'no-shadow': 'off',
-    '@typescript-eslint/no-shadow': ['error', {
-            ignoreTypeValueShadow: true,
-            ignoreFunctionTypeParameterNameValueShadow: true,
-        }],
-    '@typescript-eslint/explicit-member-accessibility': [
-        'error',
-    ],
-    '@typescript-eslint/explicit-module-boundary-types': 'off',
-    '@typescript-eslint/explicit-function-return-type': ['error', { allowExpressions: true }],
-    '@typescript-eslint/no-explicit-any': 'off',
-    'no-use-before-define': 'off',
-    '@typescript-eslint/no-use-before-define': 'off',
-    'no-unused-expressions': 'off',
-    '@typescript-eslint/no-unused-expressions': 'error',
-    '@stylistic/indent': ['error', 4, {
-            SwitchCase: 1,
-        }],
-    '@typescript-eslint/no-unused-vars': [
-        'error',
-        {
-            args: 'after-used',
-            ignoreRestSiblings: true,
-        },
-    ],
-    'no-unused-vars': 'off',
-    '@typescript-eslint/no-non-null-assertion': 'off',
-    '@stylistic/object-curly-spacing': 'error',
-    '@stylistic/member-delimiter-style': ['error', {
-            multiline: {
-                delimiter: 'comma',
-                requireLast: true,
-            },
-            singleline: {
-                delimiter: 'comma',
-                requireLast: false,
-            },
-            overrides: {
-                interface: {
-                    singleline: {
-                        delimiter: 'semi',
-                    },
-                    multiline: {
-                        delimiter: 'semi',
-                    },
-                },
-            },
-        }],
-    'no-undef': 'off',
-    '@typescript-eslint/no-namespace': 'off',
-    '@typescript-eslint/restrict-template-expressions': 'off',
-    // Disable rules that turn `any` into `unknown`, places where `unknown` is the preferred type
-    // have that type already.
-    '@typescript-eslint/no-unsafe-argument': 'off',
-    '@typescript-eslint/no-unsafe-assignment': 'off',
-    '@typescript-eslint/no-unsafe-call': 'off',
-    '@typescript-eslint/no-unsafe-enum-comparison': 'off',
-    '@typescript-eslint/no-unsafe-member-access': 'off',
-    '@typescript-eslint/no-unsafe-return': 'off',
-    '@typescript-eslint/no-unsafe-unary-minus': 'off',
-    // Breaks with overloaded functions that implement both callback and Promise signatures
-    '@typescript-eslint/no-misused-promises': 'off',
-    // Doesn't detect classes that implement `toString` method
-    '@typescript-eslint/no-base-to-string': 'off',
-    // Conflict with TS promise ignore explicitly (void Promise)
-    'no-void': 'off',
-};
-// Factory function to create TypeScript config with the plugin reference
-function createTypescriptConfig(plugin, javascriptConfig) {
-    return [
-        ...javascriptConfig,
-        ...typescript_eslint_1.default.configs.recommendedTypeChecked,
-        eslint_plugin_jest_1.default.configs['flat/recommended'],
-        {
-            name: '@croct/typescript',
-            files: ['**/*.ts', '**/*.tsx'],
-            plugins: {
-                '@stylistic': eslint_plugin_1.default,
-                '@croct': plugin,
-            },
-            languageOptions: {
-                parser: parser_1.default,
-                parserOptions: {
-                    // Enable type-aware linting
-                    projectService: true,
-                },
-            },
-            rules: baseRules,
-        },
-    ];
-}

package/index.js

@@ -1,30 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.rules = exports.configs = void 0;
-const rules_1 = require("./rules");
-Object.defineProperty(exports, "rules", { enumerable: true, get: function () { return rules_1.rules; } });
-const javascript_1 = require("./configs/javascript");
-const typescript_1 = require("./configs/typescript");
-const react_1 = require("./configs/react");
-const cypress_1 = require("./configs/cypress");
-// Create the plugin with just the rules first
-const plugin = {
-    // Cast from TypeScript Rule Module to ESLint RuleDefinition.
-    // Due to variance, TS can't verify the type directly.
-    rules: rules_1.rules,
-    configs: {},
-};
-// Create configs with the plugin reference
-const javascriptConfig = (0, javascript_1.createJavaScriptConfig)(plugin);
-const typescriptConfig = (0, typescript_1.createTypescriptConfig)(plugin, javascriptConfig);
-const reactConfig = (0, react_1.createReactConfig)(plugin, javascriptConfig);
-const cypressConfig = (0, cypress_1.createCypressConfig)(plugin, javascriptConfig);
-exports.configs = {
-    javascript: javascriptConfig,
-    typescript: typescriptConfig,
-    react: reactConfig,
-    cypress: cypressConfig,
-};
-Object.assign(plugin.configs, exports.configs);
-// Export the plugin as default
-exports.default = plugin;

package/rules/argument-spacing/index.js

@@ -1,70 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.argumentSpacing = void 0;
-const utils_1 = require("@typescript-eslint/utils");
-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.',
-        },
-        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 !== utils_1.TSESTree.AST_NODE_TYPES.ArrowFunctionExpression
-                || lastArgument.body.type === utils_1.TSESTree.AST_NODE_TYPES.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.js

@@ -1,66 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.complexExpressionSpacing = void 0;
-const utils_1 = require("@typescript-eslint/utils");
-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.',
-        },
-        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 === utils_1.TSESTree.AST_TOKEN_TYPES.Punctuator,
-            });
-            const parentNextToken = sourceCode.getTokenAfter(node, {
-                filter: token => token.type === utils_1.TSESTree.AST_TOKEN_TYPES.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 === utils_1.TSESTree.AST_NODE_TYPES.ConditionalExpression) {
-                    check(body);
-                }
-            },
-            IfStatement: (node) => {
-                check(node.test);
-            },
-        };
-    },
-});

package/rules/createRule.js

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

package/rules/index.js

@@ -1,17 +0,0 @@
-"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");
-const newline_per_chained_call_1 = require("./newline-per-chained-call");
-const min_chained_call_depth_1 = require("./min-chained-call-depth");
-const parameter_destructuring_1 = require("./parameter-destructuring");
-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,
-    'parameter-destructuring': parameter_destructuring_1.parameterDestructuring,
-};