eslint-plugin-power-esrules 0.1.1

package/lib/rules/import-sorting.js

@@ -0,0 +1,251 @@
+/**
+ * Rule: import-sorting
+ *
+ * Проверяет сортировку импортов согласно соглашению:
+ *
+ * 1. Самыми первыми идут импорты из сторонних библиотек
+ * 2. За ними следует импорты наших функций, классов, утилит
+ * 3. Последними следуют компоненты (это не означает, что все что лежит в папке components, а именно компоненты)
+ *
+ * Между группами импортов должны быть пустые строки.
+ */
+
+/**
+ * Определяет тип импорта
+ * @param {Object} node - AST узел ImportDeclaration
+ * @returns {string} - 'external', 'internal', или 'component'
+ */
+function getImportType(node) {
+    const source = node.source.value;
+    // Относительные импорты (./ или ../) всегда внутренние
+    if (source.startsWith('./') || source.startsWith('../')) {
+        // Проверяем, является ли это компонентом
+        // Компоненты обычно импортируются как default или с большой буквы
+        const isDefaultImport = node.specifiers.some(
+            (spec) => spec.type === 'ImportDefaultSpecifier'
+        );
+        const hasComponentName = node.specifiers.some(
+            (spec) =>
+                spec.type === 'ImportSpecifier' &&
+                spec.imported &&
+                /^[A-Z]/.test(spec.imported.name)
+        );
+        if (isDefaultImport || hasComponentName) {
+            return 'component';
+        }
+        return 'internal';
+    }
+
+    // Сторонние библиотеки (не относительные и не начинаются с внутренних путей)
+    const internalPathPatterns = [
+        /^components\//,
+        /^utils\//,
+        /^modules\//,
+        /^pages\//,
+        /^services\//,
+        /^store\//,
+        /^types\//,
+        /^constants\//,
+        /^hooks\//,
+        /^helpers\//,
+    ];
+    const isInternalPath = internalPathPatterns.some((pattern) => pattern.test(source));
+    if (!isInternalPath) {
+        return 'external';
+    }
+    // Внутренние пути
+    // Компоненты обычно из папки components/ или имеют имена с большой буквы
+    if (source.startsWith('components/')) {
+        // Исключения: theme, constants, utils, helpers - это утилиты, не компоненты
+        const isUtility = /components\/(theme|constants|utils|helpers|auxiliary)/.test(source);
+        if (isUtility) {
+            return 'internal';
+        }
+        // Проверяем, является ли это компонентом
+        const isDefaultImport = node.specifiers.some(
+            (spec) => spec.type === 'ImportDefaultSpecifier'
+        );
+        const hasComponentName = node.specifiers.some(
+            (spec) =>
+                spec.type === 'ImportSpecifier' &&
+                spec.imported &&
+                /^[A-Z][a-zA-Z]*$/.test(spec.imported.name) && // Имя начинается с большой буквы и не все заглавные
+                spec.imported.name !== spec.imported.name.toUpperCase() // Не константа (не все заглавные)
+        );
+        if (isDefaultImport || hasComponentName) {
+            return 'component';
+        }
+    }
+    // Проверяем, является ли именованный импорт компонентом (начинается с большой буквы, но не константа)
+    const hasComponentName = node.specifiers.some(
+        (spec) =>
+            spec.type === 'ImportSpecifier' &&
+            spec.imported &&
+            /^[A-Z][a-zA-Z]*$/.test(spec.imported.name) &&
+            spec.imported.name !== spec.imported.name.toUpperCase() // Не константа
+    );
+    if (hasComponentName) {
+        return 'component';
+    }
+    return 'internal';
+}
+
+/**
+ * Получает приоритет для сортировки
+ */
+function getImportPriority(type) {
+    const priorities = {
+        external: 1,
+        internal: 2,
+        component: 3,
+    };
+    return priorities[type] || 999;
+}
+
+/**
+ * Сравнивает два импорта для сортировки
+ */
+function compareImports(a, b) {
+    const typeA = getImportType(a);
+    const typeB = getImportType(b);
+    const priorityA = getImportPriority(typeA);
+    const priorityB = getImportPriority(typeB);
+    // Сначала по типу
+    if (priorityA !== priorityB) {
+        return priorityA - priorityB;
+    }
+    // Затем по имени источника (алфавитно)
+    const sourceA = a.source.value;
+    const sourceB = b.source.value;
+    return sourceA.localeCompare(sourceB);
+}
+
+/**
+ * Проверяет, нужна ли пустая строка между двумя импортами
+ */
+function needsBlankLineBetween(importA, importB) {
+    const typeA = getImportType(importA);
+    const typeB = getImportType(importB);
+    return typeA !== typeB;
+}
+
+module.exports = {
+    meta: {
+        type: 'layout',
+        docs: {
+            description: 'Проверяет сортировку импортов согласно соглашению',
+            category: 'Stylistic Issues',
+            recommended: false,
+        },
+        fixable: 'code',
+        schema: [],
+        messages: {
+            // eslint-disable-next-line max-len
+            incorrectOrder: 'Импорты должны быть отсортированы: сначала сторонние библиотеки, затем внутренние утилиты, затем компоненты',
+            missingBlankLine: 'Требуется пустая строка между группами импортов',
+        },
+    },
+
+    create(context) {
+        const sourceCode = context.getSourceCode();
+        return {
+            Program(node) {
+                const imports = node.body.filter((stmt) => stmt.type === 'ImportDeclaration');
+
+                if (imports.length === 0) {
+                    return;
+                }
+                // Проверяем порядок импортов
+                for (let i = 1; i < imports.length; i++) {
+                    const prev = imports[i - 1];
+                    const current = imports[i];
+                    const comparison = compareImports(prev, current);
+                    if (comparison > 0) {
+                        context.report({
+                            node: current,
+                            messageId: 'incorrectOrder',
+                            fix(fixer) {
+                                // Находим все импорты и сортируем их
+                                const sortedImports = [...imports].sort(compareImports);
+                                const firstImport = imports[0];
+                                const lastImport = imports[imports.length - 1];
+                                const firstToken = sourceCode.getFirstToken(firstImport);
+                                const lastToken = sourceCode.getLastToken(lastImport);
+                                // Собираем текст для всех отсортированных импортов
+                                let sortedText = '';
+                                for (let j = 0; j < sortedImports.length; j++) {
+                                    const importNode = sortedImports[j];
+                                    // Получаем текст импорта и убираем завершающие переводы строк
+                                    let importText = sourceCode.getText(importNode);
+                                    // Убираем все завершающие переводы строк и пробелы
+                                    importText = importText.replace(/[\r\n\s]+$/, '');
+                                    sortedText += importText;
+                                    // Добавляем перевод строки между импортами
+                                    if (j < sortedImports.length - 1) {
+                                        const nextImport = sortedImports[j + 1];
+                                        if (needsBlankLineBetween(importNode, nextImport)) {
+                                            sortedText += '\n\n';
+                                        } else {
+                                            sortedText += '\n';
+                                        }
+                                    }
+                                }
+                                return fixer.replaceTextRange([firstToken.range[0], lastToken.range[1]], sortedText);
+                            },
+                        });
+                        return; // Исправляем только первую найденную ошибку за раз
+                    }
+                }
+
+                // Проверяем пустые строки между группами
+                for (let i = 1; i < imports.length; i++) {
+                    const prev = imports[i - 1];
+                    const current = imports[i];
+                    if (needsBlankLineBetween(prev, current)) {
+                        const firstTokenCurrent = sourceCode.getFirstToken(current);
+                        const lastTokenPrev = sourceCode.getLastToken(prev);
+                        const lineDiff = firstTokenCurrent.loc.start.line - lastTokenPrev.loc.end.line;
+                        const hasBlankLine = lineDiff > 1;
+                        if (!hasBlankLine) {
+                            context.report({
+                                node: current,
+                                messageId: 'missingBlankLine',
+                                fix(fixer) {
+                                    const firstToken = sourceCode.getFirstToken(current);
+                                    return fixer.insertTextBefore(firstToken, '\n');
+                                },
+                            });
+                        }
+                    } else {
+                        // Проверяем, что нет лишних пустых строк внутри группы
+                        const firstTokenCurrent = sourceCode.getFirstToken(current);
+                        const lastTokenPrev = sourceCode.getLastToken(prev);
+                        const lineDiff = firstTokenCurrent.loc.start.line - lastTokenPrev.loc.end.line;
+                        const hasBlankLine = lineDiff > 1;
+                        if (hasBlankLine) {
+                            context.report({
+                                node: current,
+                                messageId: 'missingBlankLine',
+                                fix(fixer) {
+                                    // Удаляем лишние пустые строки
+                                    const firstToken = sourceCode.getFirstToken(current);
+                                    const lastTokenOfPrev = sourceCode.getLastToken(prev);
+                                    const textBetween = sourceCode.getText().slice(
+                                        lastTokenOfPrev.range[1],
+                                        firstToken.range[0]
+                                    );
+                                    const fixedText = textBetween.replace(/\n\s*\n+/g, '\n');
+                                    return fixer.replaceTextRange(
+                                        [lastTokenOfPrev.range[1], firstToken.range[0]],
+                                        fixedText
+                                    );
+                                },
+                            });
+                        }
+                    }
+                }
+            },
+        };
+    },
+};
+

package/lib/rules/no-default-props.js

@@ -0,0 +1,68 @@
+/**
+ * Rule: no-default-props
+ *
+ * Запрещает использование defaultProps согласно соглашению:
+ *
+ * При задании значений по умолчанию не пользуемся defaultProps.
+ */
+
+/**
+ * Проверяет, является ли идентификатор React-компонентом
+ */
+function isReactComponentName(name) {
+    if (!name || typeof name !== 'string') {
+        return false;
+    }
+    return /^[A-Z]/.test(name);
+}
+
+/**
+ * Получает имя компонента из узла присваивания
+ */
+function getComponentNameFromAssignment(node) {
+    if (!node || node.type !== 'AssignmentExpression') {
+        return null;
+    }
+    const { left } = node;
+    if (!left || left.type !== 'MemberExpression') {
+        return null;
+    }
+    if (left.property && left.property.type === 'Identifier' && left.property.name === 'defaultProps') {
+        if (left.object && left.object.type === 'Identifier') {
+            return left.object.name;
+        }
+    }
+    return null;
+}
+
+module.exports = {
+    meta: {
+        type: 'problem',
+        docs: {
+            description: 'Запрещает использование defaultProps',
+            category: 'Stylistic Issues',
+            recommended: false,
+        },
+        fixable: null,
+        schema: [],
+        messages: {
+            noDefaultProps:
+                // eslint-disable-next-line max-len
+                'Использование defaultProps запрещено. Используйте деструктуризацию с значениями по умолчанию в параметрах функции.',
+        },
+    },
+
+    create(context) {
+        return {
+            AssignmentExpression(node) {
+                const componentName = getComponentNameFromAssignment(node);
+                if (componentName && isReactComponentName(componentName)) {
+                    context.report({
+                        node: node.left.property,
+                        messageId: 'noDefaultProps',
+                    });
+                }
+            },
+        };
+    },
+};

package/lib/rules/no-inline-callbacks-in-jsx.js

@@ -0,0 +1,87 @@
+/**
+ * Rule: no-inline-callbacks-in-jsx
+ *
+ * Запрещает использование inline-коллбеков в JSX согласно соглашению:
+ *
+ * В JSX-рендере не используем inline-коллбеки: используем заранее объявленные функции/хендлеры
+ * вместо анонимных функций в JSX.
+ */
+
+/**
+ * Проверяет, является ли выражение inline-коллбеком
+ */
+function isInlineCallback(node) {
+    if (!node) {
+        return false;
+    }
+    if (node.type === 'ArrowFunctionExpression') {
+        return true;
+    }
+    if (node.type === 'FunctionExpression') {
+        return true;
+    }
+    if (node.type === 'CallExpression') {
+        const { callee } = node;
+        if (
+            callee.type === 'MemberExpression' &&
+            callee.property &&
+            callee.property.type === 'Identifier' &&
+            callee.property.name === 'bind'
+        ) {
+            return true;
+        }
+    }
+    return false;
+}
+
+/**
+ * Получает имя атрибута JSX
+ */
+function getJSXAttributeName(node) {
+    if (!node || !node.name) {
+        return null;
+    }
+    if (node.name.type === 'JSXIdentifier') {
+        return node.name.name;
+    }
+    if (node.name.type === 'JSXNamespacedName') {
+        return `${node.name.namespace.name}:${node.name.name.name}`;
+    }
+    return null;
+}
+
+module.exports = {
+    meta: {
+        type: 'suggestion',
+        docs: {
+            description: 'Запрещает использование inline-коллбеков в JSX',
+            category: 'Stylistic Issues',
+            recommended: false,
+        },
+        fixable: null,
+        schema: [],
+        messages: {
+            noInlineCallbacks: 'Не используйте inline-коллбеки в JSX. Объявите функцию отдельно и используйте её имя.',
+        },
+    },
+
+    create(context) {
+        return {
+            JSXExpressionContainer(node) {
+                const { expression } = node;
+                if (isInlineCallback(expression)) {
+                    const { parent } = node;
+                    if (parent && parent.type === 'JSXAttribute') {
+                        const attributeName = getJSXAttributeName(parent);
+                        if (attributeName && /^on[A-Z]/.test(attributeName)) {
+                            context.report({
+                                node: expression,
+                                messageId: 'noInlineCallbacks',
+                            });
+                        }
+                    }
+                }
+            },
+        };
+    },
+};

package/lib/rules/use-state-naming.js

@@ -0,0 +1,128 @@
+/**
+ * Rule: use-state-naming
+ *
+ * Проверяет именование переменных useState согласно соглашению:
+ *
+ * Названия переменных созданных через useState по возможности должны иметь окончание State
+ * (например innerModalState, setInnerModalState).
+ */
+
+/**
+ * Проверяет, является ли узел вызовом useState
+ */
+function isUseStateCall(node) {
+    if (!node || node.type !== 'CallExpression') {
+        return false;
+    }
+    const { callee } = node;
+    if (callee.type === 'Identifier' && callee.name === 'useState') {
+        return true;
+    }
+    if (
+        callee.type === 'MemberExpression' &&
+        callee.property &&
+        callee.property.type === 'Identifier' &&
+        callee.property.name === 'useState'
+    ) {
+        return true;
+    }
+    return false;
+}
+
+/**
+ * Проверяет, заканчивается ли имя на "State"
+ */
+function endsWithState(name) {
+    if (!name || typeof name !== 'string') {
+        return false;
+    }
+    return name.endsWith('State');
+}
+
+/**
+ * Генерирует правильное имя с окончанием State
+ */
+function fixStateName(name) {
+    if (!name || typeof name !== 'string') {
+        return name;
+    }
+    if (endsWithState(name)) {
+        return name;
+    }
+    return `${name}State`;
+}
+
+module.exports = {
+    meta: {
+        type: 'suggestion',
+        docs: {
+            description: 'Проверяет, что переменные useState имеют окончание State',
+            category: 'Stylistic Issues',
+            recommended: false,
+        },
+        fixable: 'code',
+        schema: [],
+        messages: {
+            useStateShouldEndWithState:
+                'Переменные useState должны иметь окончание "State". ' +
+                'Вместо "{{variableName}}" используйте "{{suggestedName}}"',
+        },
+    },
+
+    create(context) {
+        return {
+            VariableDeclarator(node) {
+                if (!node.id || node.id.type !== 'ArrayPattern') {
+                    return;
+                }
+                const { init } = node;
+                if (!init || !isUseStateCall(init)) {
+                    return;
+                }
+                const { elements } = node.id;
+                if (!elements || elements.length < 1) {
+                    return;
+                }
+                const stateElement = elements[0];
+                let stateName = null;
+                if (stateElement && stateElement.type === 'Identifier') {
+                    stateName = stateElement.name;
+                    if (!endsWithState(stateName)) {
+                        const suggestedName = fixStateName(stateName);
+                        context.report({
+                            node: stateElement,
+                            messageId: 'useStateShouldEndWithState',
+                            data: {
+                                variableName: stateName,
+                                suggestedName,
+                            },
+                            fix(fixer) {
+                                return fixer.replaceText(stateElement, suggestedName);
+                            },
+                        });
+                    }
+                }
+                const setterElement = elements[1];
+                if (setterElement && setterElement.type === 'Identifier' && stateName) {
+                    const setterName = setterElement.name;
+                    const correctedStateName = endsWithState(stateName) ? stateName : fixStateName(stateName);
+                    const stateNameWithoutState = correctedStateName.replace(/State$/, '');
+                    const expectedSetterName = `set${stateNameWithoutState}State`;
+                    if (setterName !== expectedSetterName) {
+                        context.report({
+                            node: setterElement,
+                            messageId: 'useStateShouldEndWithState',
+                            data: {
+                                variableName: setterName,
+                                suggestedName: expectedSetterName,
+                            },
+                            fix(fixer) {
+                                return fixer.replaceText(setterElement, expectedSetterName);
+                            },
+                        });
+                    }
+                }
+            },
+        };
+    },
+};

package/package.json

@@ -0,0 +1,31 @@
+{
+  "name": "eslint-plugin-power-esrules",
+  "version": "0.1.1",
+  "description": "custom ESLint rules",
+  "main": "index.js",
+  "peerDependencies": {
+    "eslint": "^8.0.0"
+  },
+  "keywords": [
+    "eslint",
+    "eslintplugin",
+    "lint",
+    "rules"
+  ],
+  "license": "MIT",
+  "directories": {
+    "lib": "lib"
+  },
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Vollmond148259/eslint-plugin-power-esrules.git"
+  },
+  "author": "vollmond148",
+  "bugs": {
+    "url": "https://github.com/Vollmond148259/eslint-plugin-power-esrules/issues"
+  },
+  "homepage": "https://github.com/Vollmond148259/eslint-plugin-power-esrules#readme"
+}