eslint-plugin-power-esrules 0.1.1 → 0.1.3

package/index.js

@@ -7,6 +7,7 @@ module.exports = {
     "use-state-naming": require("./lib/rules/use-state-naming"),
     "class-to-functional": require("./lib/rules/class-to-functional"),
     "import-sorting": require("./lib/rules/import-sorting"),
+    "require-data-testid": require("./lib/rules/require-data-testid"),
   },
   configs: {
     recommended: {
@@ -19,6 +20,7 @@ module.exports = {
         "power-esrules/use-state-naming": "error",
         "power-esrules/class-to-functional": "error",
         "power-esrules/import-sorting": "error",
+        "power-esrules/require-data-testid": "error",
       },
     },
   },

package/lib/rules/class-to-functional.js

@@ -7,230 +7,238 @@
  * Условия для определения:
  * 1. Не содержит внутреннего стейта (this.state)
  * 2. Содержит от 1 до 4 методов класса (не считая методы жизненного цикла)
- * Рекомендация: Запустите npm run codemod:classToFC -- <file-path>
  */
 
-const path = require('path');
+const path = require("path");
 
 /**
  * Проверяет, является ли класс React компонентом
  */
 function isReactComponentClass(node) {
-    if (!node || (node.type !== 'ClassDeclaration' && node.type !== 'ClassExpression')) {
-        return false;
-    }
-    if (!node.superClass) {
-        return false;
-    }
-    const { superClass } = node;
-    if (superClass.type === 'Identifier') {
-        return superClass.name === 'Component' || superClass.name === 'PureComponent';
-    }
-    if (
-        superClass.type === 'MemberExpression' &&
-        superClass.object &&
-        superClass.object.type === 'Identifier' &&
-        superClass.object.name === 'React' &&
-        superClass.property &&
-        superClass.property.type === 'Identifier' &&
-        (superClass.property.name === 'Component' || superClass.property.name === 'PureComponent')
-    ) {
-        return true;
-    }
+  if (
+    !node ||
+    (node.type !== "ClassDeclaration" && node.type !== "ClassExpression")
+  ) {
+    return false;
+  }
+  if (!node.superClass) {
     return false;
+  }
+  const { superClass } = node;
+  if (superClass.type === "Identifier") {
+    return (
+      superClass.name === "Component" || superClass.name === "PureComponent"
+    );
+  }
+  if (
+    superClass.type === "MemberExpression" &&
+    superClass.object &&
+    superClass.object.type === "Identifier" &&
+    superClass.object.name === "React" &&
+    superClass.property &&
+    superClass.property.type === "Identifier" &&
+    (superClass.property.name === "Component" ||
+      superClass.property.name === "PureComponent")
+  ) {
+    return true;
+  }
+  return false;
 }
 
 /**
  * Проверяет, является ли метод методом жизненного цикла
  */
 function isLifecycleMethod(methodName) {
-    const lifecycleMethods = [
-        'componentDidMount',
-        'componentDidUpdate',
-        'componentWillUnmount',
-        'componentWillMount',
-        'componentWillReceiveProps',
-        'UNSAFE_componentWillMount',
-        'UNSAFE_componentWillReceiveProps',
-        'UNSAFE_componentWillUpdate',
-        'shouldComponentUpdate',
-        'componentWillUpdate',
-        'getSnapshotBeforeUpdate',
-        'componentDidCatch',
-        'getDerivedStateFromProps',
-    ];
-    return lifecycleMethods.includes(methodName) || methodName.startsWith('component');
+  const lifecycleMethods = [
+    "componentDidMount",
+    "componentDidUpdate",
+    "componentWillUnmount",
+    "componentWillMount",
+    "componentWillReceiveProps",
+    "UNSAFE_componentWillMount",
+    "UNSAFE_componentWillReceiveProps",
+    "UNSAFE_componentWillUpdate",
+    "shouldComponentUpdate",
+    "componentWillUpdate",
+    "getSnapshotBeforeUpdate",
+    "componentDidCatch",
+    "getDerivedStateFromProps",
+  ];
+  return (
+    lifecycleMethods.includes(methodName) || methodName.startsWith("component")
+  );
 }
 
 /**
  * Проверяет, содержит ли узел использование this.state или this.setState
  */
 function hasStateUsage(node) {
-    let hasState = false;
-    // Используем обход AST для поиска this.state и this.setState
-    function traverse(node) {
-        if (!node || hasState) {
-            return;
-        }
-        if (
-            node.type === 'MemberExpression' &&
-            node.object &&
-            node.object.type === 'ThisExpression' &&
-            node.property &&
-            node.property.type === 'Identifier' &&
-            node.property.name === 'state'
-        ) {
-            hasState = true;
-            return;
-        }
-        if (
-            node.type === 'CallExpression' &&
-            node.callee &&
-            node.callee.type === 'MemberExpression' &&
-            node.callee.object &&
-            node.callee.object.type === 'ThisExpression' &&
-            node.callee.property &&
-            node.callee.property.type === 'Identifier' &&
-            node.callee.property.name === 'setState'
-        ) {
-            hasState = true;
-            return;
-        }
-        // Рекурсивно обходим дочерние узлы
-        for (const key in node) {
-            if (key !== 'parent' && node[key] && typeof node[key] === 'object') {
-                if (Array.isArray(node[key])) {
-                    node[key].forEach((child) => traverse(child));
-                } else {
-                    traverse(node[key]);
-                }
-            }
+  let hasState = false;
+  // Используем обход AST для поиска this.state и this.setState
+  function traverse(node) {
+    if (!node || hasState) {
+      return;
+    }
+    if (
+      node.type === "MemberExpression" &&
+      node.object &&
+      node.object.type === "ThisExpression" &&
+      node.property &&
+      node.property.type === "Identifier" &&
+      node.property.name === "state"
+    ) {
+      hasState = true;
+      return;
+    }
+    if (
+      node.type === "CallExpression" &&
+      node.callee &&
+      node.callee.type === "MemberExpression" &&
+      node.callee.object &&
+      node.callee.object.type === "ThisExpression" &&
+      node.callee.property &&
+      node.callee.property.type === "Identifier" &&
+      node.callee.property.name === "setState"
+    ) {
+      hasState = true;
+      return;
+    }
+    // Рекурсивно обходим дочерние узлы
+    for (const key in node) {
+      if (key !== "parent" && node[key] && typeof node[key] === "object") {
+        if (Array.isArray(node[key])) {
+          node[key].forEach((child) => traverse(child));
+        } else {
+          traverse(node[key]);
         }
+      }
     }
-    traverse(node);
-    return hasState;
+  }
+  traverse(node);
+  return hasState;
 }
 
 /**
  * Подсчитывает методы класса, исключая lifecycle методы, render и constructor
  */
 function countNonLifecycleMethods(classBody) {
-    let count = 0;
-    if (!classBody || !classBody.body || !Array.isArray(classBody.body)) {
-        return 0;
-    }
-    classBody.body.forEach((member) => {
-        if (member.type === 'MethodDefinition') {
-            const methodName = member.key && member.key.name;
-            if (methodName === 'render' || methodName === 'constructor') {
-                return;
-            }
-            if (!isLifecycleMethod(methodName)) {
-                count++;
-            }
-        } else if (
-            member.type === 'Property' ||
-            member.type === 'ClassProperty' ||
-            member.type === 'PropertyDefinition'
+  let count = 0;
+  if (!classBody || !classBody.body || !Array.isArray(classBody.body)) {
+    return 0;
+  }
+  classBody.body.forEach((member) => {
+    if (member.type === "MethodDefinition") {
+      const methodName = member.key && member.key.name;
+      if (methodName === "render" || methodName === "constructor") {
+        return;
+      }
+      if (!isLifecycleMethod(methodName)) {
+        count++;
+      }
+    } else if (
+      member.type === "Property" ||
+      member.type === "ClassProperty" ||
+      member.type === "PropertyDefinition"
+    ) {
+      const methodName = member.key && member.key.name;
+      if (methodName === "render") {
+        return;
+      }
+      if (!isLifecycleMethod(methodName)) {
+        if (
+          member.value &&
+          (member.value.type === "ArrowFunctionExpression" ||
+            member.value.type === "FunctionExpression")
         ) {
-            const methodName = member.key && member.key.name;
-            if (methodName === 'render') {
-                return;
-            }
-            if (!isLifecycleMethod(methodName)) {
-                if (
-                    member.value &&
-                    (member.value.type === 'ArrowFunctionExpression' || member.value.type === 'FunctionExpression')
-                ) {
-                    count++;
-                }
-            }
+          count++;
         }
-    });
+      }
+    }
+  });
 
-    return count;
+  return count;
 }
 
 /**
  * Получает относительный путь к файлу от корня проекта
  */
 function getRelativeFilePath(context) {
-    const filename = context.getFilename();
-    const workspaceRoot = context.getCwd ? context.getCwd() : process.cwd();
-    return path.relative(workspaceRoot, filename);
+  const filename = context.getFilename();
+  const workspaceRoot = context.getCwd ? context.getCwd() : process.cwd();
+  return path.relative(workspaceRoot, filename);
 }
 
 module.exports = {
-    meta: {
-        type: 'suggestion',
-        docs: {
-            description:
-                'Определяет классовые компоненты для конвертации в функциональные и рекомендует запустить codemod',
-            category: 'Best Practices',
-            recommended: false,
-        },
-        fixable: null,
-        schema: [],
-        messages: {
-            shouldConvertToFunctional:
-                'Классовый компонент "{{componentName}}" подходит для конвертации в функциональный. ' +
-                'Запустите: npm run codemod:classToFC -- {{filePath}}',
-        },
+  meta: {
+    type: "suggestion",
+    docs: {
+      description:
+        "Определяет классовые компоненты для конвертации в функциональные и рекомендует запустить codemod",
+      category: "Best Practices",
+      recommended: false,
+    },
+    fixable: null,
+    schema: [],
+    messages: {
+      shouldConvertToFunctional:
+        'Классовый компонент "{{componentName}}" подходит для конвертации в функциональный. ' +
+        "Запустите:node node_modules/power-linter/scripts/classToFC/run-codemod.js {{filePath}}",
     },
+  },
 
-    create(context) {
-        return {
-            ClassDeclaration(node) {
-                if (!isReactComponentClass(node)) {
-                    return;
-                }
-                const componentName = node.id ? node.id.name : 'Unknown';
-                // Проверяем использование this.state
-                if (hasStateUsage(node)) {
-                    return;
-                }
-                const methodCount = countNonLifecycleMethods(node.body);
-                if (methodCount >= 1 && methodCount <= 4) {
-                    const filePath = getRelativeFilePath(context);
-                    context.report({
-                        node: node.id || node,
-                        messageId: 'shouldConvertToFunctional',
-                        data: {
-                            componentName,
-                            filePath,
-                        },
-                    });
-                }
+  create(context) {
+    return {
+      ClassDeclaration(node) {
+        if (!isReactComponentClass(node)) {
+          return;
+        }
+        const componentName = node.id ? node.id.name : "Unknown";
+        // Проверяем использование this.state
+        if (hasStateUsage(node)) {
+          return;
+        }
+        const methodCount = countNonLifecycleMethods(node.body);
+        if (methodCount >= 1 && methodCount <= 4) {
+          const filePath = getRelativeFilePath(context);
+          context.report({
+            node: node.id || node,
+            messageId: "shouldConvertToFunctional",
+            data: {
+              componentName,
+              filePath,
             },
+          });
+        }
+      },
 
-            ClassExpression(node) {
-                if (!isReactComponentClass(node)) {
-                    return;
-                }
-                let componentName = 'Unknown';
-                const { parent } = node;
-                if (parent && parent.type === 'VariableDeclarator' && parent.id) {
-                    componentName = parent.id.name;
-                } else if (parent && parent.type === 'ExportDefaultDeclaration') {
-                    componentName = 'DefaultExport';
-                }
-                // Проверяем использование this.state
-                if (hasStateUsage(node)) {
-                    return;
-                }
-                const methodCount = countNonLifecycleMethods(node.body);
-                if (methodCount >= 1 && methodCount <= 4) {
-                    const filePath = getRelativeFilePath(context);
-                    context.report({
-                        node: node.parent && node.parent.id ? node.parent.id : node,
-                        messageId: 'shouldConvertToFunctional',
-                        data: {
-                            componentName,
-                            filePath,
-                        },
-                    });
-                }
+      ClassExpression(node) {
+        if (!isReactComponentClass(node)) {
+          return;
+        }
+        let componentName = "Unknown";
+        const { parent } = node;
+        if (parent && parent.type === "VariableDeclarator" && parent.id) {
+          componentName = parent.id.name;
+        } else if (parent && parent.type === "ExportDefaultDeclaration") {
+          componentName = "DefaultExport";
+        }
+        // Проверяем использование this.state
+        if (hasStateUsage(node)) {
+          return;
+        }
+        const methodCount = countNonLifecycleMethods(node.body);
+        if (methodCount >= 1 && methodCount <= 4) {
+          const filePath = getRelativeFilePath(context);
+          context.report({
+            node: node.parent && node.parent.id ? node.parent.id : node,
+            messageId: "shouldConvertToFunctional",
+            data: {
+              componentName,
+              filePath,
             },
-        };
-    },
+          });
+        }
+      },
+    };
+  },
 };

package/lib/rules/import-sorting.js

@@ -16,236 +16,247 @@
  * @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 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 internalPathPatterns = [
+    /^components\//,
+    /^utils\//,
+    /^modules\//,
+    /^pages\//,
+    /^services\//,
+    /^store\//,
+    /^types\//,
+    /^constants\//,
+    /^hooks\//,
+    /^helpers\//,
+    /^selectors\//,
+    /^base\//,
+  ];
+  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() // Не константа
+      (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';
+    if (isDefaultImport || hasComponentName) {
+      return "component";
     }
-    return 'internal';
+  }
+  // Проверяем, является ли именованный импорт компонентом (начинается с большой буквы, но не константа)
+  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;
+  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);
+  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;
+  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: 'Требуется пустая строка между группами импортов',
-        },
+  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; // Исправляем только первую найденную ошибку за раз
-                    }
-                }
+  create(context) {
+    const sourceCode = context.getSourceCode();
+    return {
+      Program(node) {
+        const imports = node.body.filter(
+          (stmt) => stmt.type === "ImportDeclaration"
+        );
 
-                // Проверяем пустые строки между группами
-                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');
-                                },
-                            });
-                        }
+        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 {
-                        // Проверяем, что нет лишних пустых строк внутри группы
-                        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
-                                    );
-                                },
-                            });
-                        }
+                      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/require-data-testid.js

@@ -0,0 +1,221 @@
+/**
+ * Rule: require-data-testid
+ *
+ * Проверяет наличие data-testid атрибута у корневого контейнера JSX файла
+ * и рекомендует запустить codemod скрипт для его добавления, если атрибут отсутствует.
+ */
+
+const path = require("path");
+
+/**
+ * Получает имя JSX элемента
+ */
+function getJSXName(jsxName) {
+  if (!jsxName) return null;
+  switch (jsxName.type) {
+    case "JSXIdentifier":
+      return jsxName.name || null;
+    case "JSXMemberExpression":
+      // Берем правую часть: UI.Button -> Button
+      return getJSXName(jsxName.property);
+    case "JSXNamespacedName":
+      return `${jsxName.namespace?.name || "ns"}:${
+        jsxName.name?.name || "Name"
+      }`;
+    default:
+      return null;
+  }
+}
+
+/**
+ * Проверяет, является ли узел верхнеуровневым JSX элементом
+ * (не вложенным в другой JSX элемент или Fragment)
+ */
+function isTopLevelJSX(node) {
+  let current = node.parent;
+  while (current) {
+    const parentType = current.type;
+    // Если родитель - JSX элемент или Fragment, значит это не верхнеуровневый элемент
+    if (parentType === "JSXElement" || parentType === "JSXFragment") {
+      return false;
+    }
+    // Если родитель - ReturnStatement, это возвращаемое значение компонента (верхнеуровневый)
+    if (parentType === "ReturnStatement") {
+      return true;
+    }
+    // Если родитель - ExportDefaultDeclaration или ExportNamedDeclaration,
+    // это может быть верхнеуровневый JSX
+    if (
+      parentType === "ExportDefaultDeclaration" ||
+      parentType === "ExportNamedDeclaration"
+    ) {
+      return true;
+    }
+    current = current.parent;
+  }
+  return false;
+}
+
+/**
+ * Спускается от Fragment к первому рендеримому JSXElement
+ */
+function descendToFirstRenderable(node) {
+  if (!node) return null;
+
+  // 1) Если это JSXFragment — обходим детей
+  if (node.type === "JSXFragment") {
+    for (const child of node.children || []) {
+      if (child.type === "JSXElement") {
+        const resolved = descendToFirstRenderable(child);
+        if (resolved) return resolved;
+      }
+    }
+    return null;
+  }
+
+  // 2) Если это JSXElement с именем Fragment
+  if (node.type === "JSXElement") {
+    const name = getJSXName(node.openingElement?.name);
+    if (name === "Fragment") {
+      for (const child of node.children || []) {
+        if (child.type === "JSXElement") {
+          const resolved = descendToFirstRenderable(child);
+          if (resolved) return resolved;
+        }
+      }
+      return null;
+    }
+    // Иначе это реальный рендеримый элемент
+    return node;
+  }
+
+  return null;
+}
+
+/**
+ * Проверяет наличие data-testid или dataTestID атрибута
+ */
+function hasDataTestId(openingElement) {
+  if (!openingElement || !openingElement.attributes) {
+    return false;
+  }
+  return openingElement.attributes.some((attr) => {
+    if (!attr || attr.type !== "JSXAttribute" || !attr.name) {
+      return false;
+    }
+    const attrName = attr.name.name;
+    return attrName === "data-testid" || attrName === "dataTestID";
+  });
+}
+
+/**
+ * Получает относительный путь к файлу от корня проекта
+ */
+function getRelativeFilePath(context) {
+  const filename = context.getFilename();
+  const workspaceRoot = context.getCwd ? context.getCwd() : process.cwd();
+  return path.relative(workspaceRoot, filename);
+}
+
+module.exports = {
+  meta: {
+    type: "suggestion",
+    docs: {
+      description:
+        "Проверяет наличие data-testid атрибута у корневого контейнера JSX файла и рекомендует запустить codemod",
+      category: "Best Practices",
+      recommended: false,
+    },
+    fixable: null,
+    schema: [],
+    messages: {
+      missingDataTestId:
+        "Корневой контейнер JSX не содержит атрибут data-testid. " +
+        "Запустите: node node_modules/power-linter/scripts/addDataTestId/run-codemod.js {{filePath}}" +
+        "или node node_modules/power-linter/scripts/addDataTestId/run-codemod.js src для всего проекта",
+    },
+  },
+
+  create(context) {
+    let hasReported = false;
+    let rootJSXNode = null;
+
+    return {
+      ReturnStatement(node) {
+        // Проверяем только один раз на файл
+        if (hasReported || rootJSXNode) {
+          return;
+        }
+
+        const returnArgument = node.argument;
+        if (!returnArgument) {
+          return;
+        }
+
+        // Если возвращается JSX элемент или Fragment
+        if (
+          returnArgument.type === "JSXElement" ||
+          returnArgument.type === "JSXFragment"
+        ) {
+          // Проверяем, что это не вложенный JSX (не имеет JSX родителя)
+          if (isTopLevelJSX(returnArgument)) {
+            rootJSXNode = returnArgument;
+          }
+        }
+      },
+
+      JSXElement(node) {
+        // Проверяем только один раз на файл
+        if (hasReported || rootJSXNode) {
+          return;
+        }
+
+        // Проверяем верхнеуровневые JSX элементы вне ReturnStatement
+        // (например, экспортируемые напрямую)
+        if (isTopLevelJSX(node)) {
+          rootJSXNode = node;
+        }
+      },
+
+      JSXFragment(node) {
+        // Проверяем только один раз на файл
+        if (hasReported || rootJSXNode) {
+          return;
+        }
+
+        // Проверяем верхнеуровневые Fragment вне ReturnStatement
+        if (isTopLevelJSX(node)) {
+          rootJSXNode = node;
+        }
+      },
+
+      "Program:exit"() {
+        // После обхода всего файла проверяем корневой JSX элемент
+        if (hasReported || !rootJSXNode) {
+          return;
+        }
+
+        // Если это Fragment, спускаемся к первому рендеримому элементу
+        const rootElement = descendToFirstRenderable(rootJSXNode);
+        const elementToCheck = rootElement || rootJSXNode;
+
+        if (!elementToCheck.openingElement) {
+          return;
+        }
+
+        // Проверяем наличие data-testid
+        if (!hasDataTestId(elementToCheck.openingElement)) {
+          hasReported = true;
+          const filePath = getRelativeFilePath(context);
+          context.report({
+            node: elementToCheck.openingElement,
+            messageId: "missingDataTestId",
+            data: {
+              filePath,
+            },
+          });
+        }
+      },
+    };
+  },
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eslint-plugin-power-esrules",
-  "version": "0.1.1",
+  "version": "0.1.3",
   "description": "custom ESLint rules",
   "main": "index.js",
   "peerDependencies": {