power-linter 0.1.0

package/README.md

@@ -0,0 +1,71 @@
+# power-linter
+
+power-linter — линтер (ESLint) и форматтер (Prettier) с расширяемой архитектурой для произвольных правил и скриптов.
+
+- конфиги eslint и prettier из коробки
+- кастомные правила-линтера (see `eslint-plugin-power-esrules`)
+
+## Использование
+
+1. Установка:
+
+```bash
+npm install power-linter --save-dev
+```
+
+2. Добавьте экспорт конфигурации eslint
+
+```js
+// .eslintrc.js
+module.exports = require('power-linter/src/eslint/config');
+```
+
+3. Добавьте экспорт конфигурации Prettier
+
+```js
+// .prettierrc.js
+module.exports = require('power-linter/src/prettier/config');
+```
+
+4. Для кастомных правил добавляйте файлы в `eslint-plugin-power-esrules`
+
+5. Добавьте в корневой каталог проекта настройки vscode в каталоге .vscode создайте файл settings.json и добавьте в него 
+
+`{
+"eslint.enable": true,
+"eslint.validate": [
+"javascript",
+"javascriptreact",
+"typescript",
+"typescriptreact"
+],
+"eslint.run": "onType",
+"editor.codeActionsOnSave": {
+"source.fixAll.eslint": "explicit"
+},
+"editor.formatOnSave": true,
+"[javascript]": {
+"editor.defaultFormatter": "dbaeumer.vscode-eslint",
+"editor.formatOnSave": true
+},
+"[javascriptreact]": {
+"editor.defaultFormatter": "dbaeumer.vscode-eslint",
+"editor.formatOnSave": true
+},
+"[typescript]": {
+"editor.defaultFormatter": "dbaeumer.vscode-eslint",
+"editor.formatOnSave": true
+},
+"[typescriptreact]": {
+"editor.defaultFormatter": "dbaeumer.vscode-eslint",
+"editor.formatOnSave": true
+},
+"eslint.lintTask.enable": true,
+"eslint.workingDirectories": [
+{
+"mode": "auto"
+}
+]
+}`
+
+---

package/package.json

@@ -0,0 +1,38 @@
+{
+    "name": "power-linter",
+    "version": "0.1.0",
+    "description": "power-linter — линтер (ESLint) и форматтер (Prettier) с расширяемой архитектурой для произвольных правил и скриптов.",
+    "main": "src/index.js",
+    "author": "vollmond148",
+    "license": "MIT",
+    "keywords": [
+        "eslint",
+        "prettier",
+        "linter",
+        "config",
+        "eslint-plugin",
+        "eslint-config",
+        "eslint-rules",
+        "custom-rules",
+        "code-style"
+    ],
+    "dependencies": {
+        "@babel/eslint-parser": "^7.19.1",
+        "eslint": "^8.56.0",
+        "eslint-config-airbnb": "^19.0.4",
+        "eslint-config-prettier": "^8.5.0",
+        "eslint-plugin-import": "^2.26.0",
+        "eslint-plugin-jsx-a11y": "^6.6.0",
+        "eslint-plugin-power-esrules": "^0.1.4",
+        "eslint-plugin-react": "^7.30.1",
+        "eslint-plugin-react-hooks": "^4.6.0",
+        "prettier": "^3.2.5"
+    },
+    "peerDependencies": {
+        "eslint": "^8.0.0"
+    },
+    "files": [
+        "src/",
+        "scripts/"
+    ]
+}

package/scripts/addDataTestId/add-data-testid.js

@@ -0,0 +1,186 @@
+/* eslint-disable max-len */
+/**
+ * Codemod: Добавляет уникальный data-testid только к внешнему визуальному JSX элементу.
+ * Если верхний узел — Fragment, спускается к первому реальному JSXElement.
+ *
+ * Использование через power-linter:
+ *   node node_modules/power-linter/scripts/addDataTestId/run-codemod.js <path>
+ */
+
+// const fs = require('fs');
+const path = require("path");
+const crypto = require("crypto");
+
+module.exports.parser = "tsx";
+
+// const DATA_FILE_PATH = path.resolve('./scripts/addDataId/data-testids.json');
+const IGNORED_IMPORTED_COMPONENTS = [
+  "div",
+  "span",
+  "SvgRoot",
+  "TooltipContentRoot",
+  "Svg",
+  "Field",
+];
+const COMPONENTS_FOR_TEST_ID_PROP = ["Field"];
+
+function md5short(value) {
+  return crypto.createHash("md5").update(value).digest("hex").slice(0, 6);
+}
+
+// Имя JSX: Identifier / MemberExpression / NamespacedName
+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 узла (Element или Fragment)
+function hasJSXAncestor(pathNode) {
+  let p = pathNode.parentPath;
+  while (p) {
+    const t = p.node && p.node.type;
+    if (t === "JSXElement" || t === "JSXFragment") return true;
+    p = p.parentPath;
+  }
+  return false;
+}
+
+// Спуститься от Fragment к первому рендеримому JSXElement
+function descendToFirstRenderable(j, node, root) {
+  // node: JSXElement (в т.ч. React.Fragment) или JSXFragment
+  if (!node) return null;
+
+  // 1) Если это JSXFragment — обходим детей
+  if (node.type === "JSXFragment") {
+    for (const ch of node.children || []) {
+      if (ch.type === "JSXElement") {
+        const resolved = descendToFirstRenderable(j, ch, root);
+        if (resolved) return resolved;
+      }
+      // Пропускаем JSXText/JSXExpressionContainer и т.п.
+    }
+    return null; // нет рендеримого элемента
+  }
+
+  // 2) Если это JSXElement с именем Fragment (включая React.Fragment)
+  if (node.type === "JSXElement") {
+    const nm = getJSXName(node.openingElement?.name);
+    if (nm === "Fragment" || checkIsImported(root, j, nm)) {
+      // Это <Fragment>...</Fragment>
+      for (const ch of node.children || []) {
+        if (ch.type === "JSXElement") {
+          const resolved = descendToFirstRenderable(j, ch, root);
+          if (resolved) return resolved;
+        }
+      }
+      return null;
+    }
+    // Иначе это реальный рендеримый элемент
+    return node;
+  }
+
+  return null;
+}
+
+function hasLocatorAttr(openingEl) {
+  return (openingEl.attributes || []).some((attr) => {
+    if (!attr || attr.type !== "JSXAttribute" || !attr.name) return false;
+    const n = attr.name.name;
+    return n === "data-testid" || n === "dataTestID";
+  });
+}
+
+function checkIsImported(root, j, name) {
+  // Для обычных html-тегов или 'Root' — не проверяем импорт (считаем всегда "true")
+  if (!name || IGNORED_IMPORTED_COMPONENTS.includes(name)) {
+    return false;
+  }
+
+  // Найдём все import и require декларации
+  const imports = root.find(j.ImportDeclaration);
+  // Проверим, импортируется ли нужное имя (или как дефолт, или как имя)
+  const isImported = imports.some((path) =>
+    path.node.specifiers.some(
+      (spec) =>
+        (spec.type === "ImportDefaultSpecifier" ||
+          spec.type === "ImportSpecifier") &&
+        spec.local &&
+        spec.local.name === name
+    )
+  );
+
+  return isImported;
+}
+
+module.exports = function transformer(fileInfo, api) {
+  const j = api.jscodeshift;
+  const root = j(fileInfo.source);
+
+  const absPath = fileInfo.path;
+  const relPath = path.relative(process.cwd(), absPath);
+  const fileBaseName = path.basename(relPath, path.extname(relPath));
+
+  // const registry = {};
+  // if (fs.existsSync(DATA_FILE_PATH)) {
+  //     try {
+  //         registry = JSON.parse(fs.readFileSync(DATA_FILE_PATH, 'utf8'));
+  //     } catch {
+  //         registry = {};
+  //     }
+  // }
+  // Ищем «верхние» JSX узлы (тут можно не искать верхние узлы тогда будет сильно больше элементов)
+  const topLevelJSX = root
+    .find(j.JSXElement)
+    .filter((p) => !hasJSXAncestor(p))
+    .nodes();
+
+  // Переберм массив элементов
+  topLevelJSX.forEach((candidate) => {
+    // Если фрагмент или Fragment — спустимся до первого реального элемента
+    const realRoot = descendToFirstRenderable(j, candidate, root);
+    if (!realRoot || !realRoot.openingElement) {
+      // Нечего помечать
+      return;
+    }
+
+    const opening = realRoot.openingElement;
+    // Имя компонента/тега (div / Button / UI.Button -> Button)
+    const name = getJSXName(opening.name);
+    // Проверяем, импортируется ли этот компонент в файле
+    const isImported = checkIsImported(root, j, name);
+    const isInsertProp = COMPONENTS_FOR_TEST_ID_PROP.includes(name);
+
+    if (!isImported && !hasLocatorAttr(opening)) {
+      // Собираем детерминированный короткий хеш: путь + имя
+      const uniqueId = `${fileBaseName}_${name}_${md5short(`${relPath}::${name}`)}`;
+
+      // Вешаем data-testid
+      opening.attributes = opening.attributes || [];
+      const testIDName = isInsertProp ? "dataTestID" : "data-testid";
+      opening.attributes.push(
+        j.jsxAttribute(j.jsxIdentifier(testIDName), j.literal(uniqueId))
+      );
+
+      // Обновляем реестр: храним уникальный список ID на файл
+      // const prev = Array.isArray(registry[relPath]) ? registry[relPath] : [];
+      // const nextSet = new Set(prev);
+      // nextSet.add(uniqueId);
+      // registry[relPath] = Array.from(nextSet);
+    }
+  });
+  // Пишем реестр один раз на файл
+  // для записи в json нужно раскоментировать fs , DATA_FILE_PATH, логику заполенения и обновления registry
+  // fs.writeFileSync(DATA_FILE_PATH, JSON.stringify(registry, null, 2), 'utf8');
+
+  return root.toSource({ quote: "single" });
+};

package/scripts/addDataTestId/run-codemod.js

@@ -0,0 +1,78 @@
+#!/usr/bin/env node
+
+/**
+ * Обертка для запуска codemod скрипта add-Data-testid.js
+ *
+ * Использование:
+ * node node_modules/power-linter/scripts/addDataTestId/run-codemod.js <path-or-directory>
+ *
+ */
+
+const { execSync } = require("child_process");
+const path = require("path");
+const fs = require("fs");
+
+const targetPath = process.argv[2];
+if (!targetPath) {
+  console.error(
+    "Ошибка: Укажите путь к файлу или директории для преобразования"
+  );
+  console.error(
+    "Использование: node node_modules/power-linter/scripts/addDataTestId/run-codemod.js <path-or-directory>"
+  );
+  process.exit(1);
+}
+
+// Определяем корень проекта
+const currentDir = process.cwd();
+const isPowerLinterDir =
+  currentDir.endsWith("power-linter") ||
+  path.basename(currentDir) === "power-linter";
+const projectRoot = isPowerLinterDir ? path.join(currentDir, "..") : currentDir;
+const absolutePath = path.isAbsolute(targetPath)
+  ? targetPath
+  : path.join(projectRoot, targetPath);
+
+if (!fs.existsSync(absolutePath)) {
+  console.error(`Ошибка: Путь не найден: ${absolutePath}`);
+  process.exit(1);
+}
+
+const codemodPath = path.join(__dirname, "add-data-testid.js");
+const stats = fs.statSync(absolutePath);
+const isDirectory = stats.isDirectory();
+
+// eslint-disable-next-line no-console
+console.log(`Преобразование: ${targetPath}`);
+// eslint-disable-next-line no-console
+console.log(`Использование codemod: ${codemodPath}`);
+
+try {
+  let command;
+  if (isDirectory) {
+    // Для директории используем те же параметры, что и в оригинальном скрипте
+    command = `npx jscodeshift -t "${codemodPath}" "${absolutePath}" --extensions=js,jsx,ts,tsx --parser=tsx`;
+  } else {
+    // Для одного файла
+    const ext = path.extname(absolutePath);
+    if (![".js", ".jsx", ".ts", ".tsx"].includes(ext)) {
+      console.error(
+        `Ошибка: Файл должен иметь расширение .js, .jsx, .ts или .tsx`
+      );
+      process.exit(1);
+    }
+    command = `npx jscodeshift -t "${codemodPath}" "${absolutePath}" --parser=tsx`;
+  }
+
+  // eslint-disable-next-line no-console
+  console.log(`Выполнение: ${command}`);
+  execSync(command, {
+    stdio: "inherit",
+    cwd: projectRoot,
+  });
+  // eslint-disable-next-line no-console
+  console.log("\n✓ Преобразование завершено успешно!");
+} catch (error) {
+  console.error("\n✗ Ошибка при выполнении преобразования:", error.message);
+  process.exit(1);
+}

package/scripts/classToFC/class-to-functional.js

@@ -0,0 +1,519 @@
+/**
+ * Codemod для преобразования классовых React компонентов в функциональные
+ *
+ * Условия применения:
+ * - Компонент не использует this.state
+ * - Компонент имеет от 1 до 4 методов класса
+ * - Компонент не имеет сложных lifecycle методов
+ *
+ * Использование:
+ * node node_modules/power-linter/scripts/classToFC/run-codemod.js <file-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;
+  }
+  return false;
+}
+
+/**
+ * Проверяет, содержит ли узел использование this.state или this.setState
+ */
+function hasStateUsage(node, j) {
+  let hasState = false;
+  j(node)
+    .find(j.MemberExpression, {
+      object: { type: "ThisExpression" },
+      property: { name: "state" },
+    })
+    .forEach(() => {
+      hasState = true;
+    });
+  j(node)
+    .find(j.CallExpression, {
+      callee: {
+        type: "MemberExpression",
+        object: { type: "ThisExpression" },
+        property: { name: "setState" },
+      },
+    })
+    .forEach(() => {
+      hasState = true;
+    });
+  return hasState;
+}
+
+/**
+ * Получает имя компонента
+ */
+function getComponentName(node, j, path) {
+  if (node.type === "ClassDeclaration" && node.id) {
+    return node.id.name;
+  }
+  if (node.type === "ClassExpression") {
+    let currentPath = path;
+    while (currentPath) {
+      const { parent } = currentPath;
+      if (parent && parent.value) {
+        if (parent.value.type === "VariableDeclarator" && parent.value.id) {
+          return parent.value.id.name;
+        }
+        if (parent.value.type === "ExportDefaultDeclaration") {
+          return null;
+        }
+      }
+      currentPath = parent;
+    }
+  }
+  return null;
+}
+
+/**
+ * Проверяет, является ли метод методом жизненного цикла
+ */
+function isLifecycleMethod(methodName) {
+  const lifecycleMethods = [
+    "componentDidMount",
+    "componentDidUpdate",
+    "componentWillUnmount",
+    "componentWillMount",
+    "componentWillReceiveProps",
+    "UNSAFE_componentWillMount",
+    "UNSAFE_componentWillReceiveProps",
+    "UNSAFE_componentWillUpdate",
+    "shouldComponentUpdate",
+    "getSnapshotBeforeUpdate",
+  ];
+  return (
+    lifecycleMethods.includes(methodName) || methodName.startsWith("component")
+  );
+}
+
+/**
+ * Преобразует методы класса в функции внутри компонента
+ */
+function convertMethodsToFunctions(classBody) {
+  const methods = [];
+  const lifecycleMethods = [];
+  const staticProperties = [];
+  classBody.body.forEach((member) => {
+    if (member.type === "MethodDefinition") {
+      const methodName = member.key.name;
+      if (methodName === "render" || methodName === "constructor") {
+        return;
+      }
+      if (isLifecycleMethod(methodName)) {
+        lifecycleMethods.push(member);
+      } else {
+        methods.push(member);
+      }
+    } else if (member.type === "Property" || member.type === "ClassProperty") {
+      if (member.static) {
+        staticProperties.push(member);
+      } else if (member.key && member.key.name !== "render") {
+        const methodName = member.key.name;
+        if (isLifecycleMethod(methodName)) {
+          lifecycleMethods.push(member);
+        } else {
+          methods.push(member);
+        }
+      }
+    }
+  });
+  return { methods, lifecycleMethods, staticProperties };
+}
+
+/**
+ * Заменяет this.props на props в узле
+ */
+function replaceThisProps(node, j) {
+  j(node)
+    .find(j.MemberExpression, {
+      object: { type: "ThisExpression" },
+      property: { name: "props" },
+    })
+    .replaceWith(() => j.identifier("props"));
+}
+
+/**
+ * Заменяет this.methodName на methodName
+ */
+function replaceThisMethods(node, methodNames, j) {
+  methodNames.forEach((methodName) => {
+    j(node)
+      .find(j.MemberExpression, {
+        object: { type: "ThisExpression" },
+        property: { name: methodName },
+      })
+      .replaceWith(() => j.identifier(methodName));
+  });
+}
+
+/**
+ * Преобразует методы жизненного цикла в хуки React
+ */
+function convertLifecycleMethodsToHooks(lifecycleMethods, j) {
+  const hooks = [];
+  let needsUseEffect = false;
+  lifecycleMethods.forEach((method) => {
+    const methodName = method.key.name;
+    let methodBody;
+    if (method.type === "MethodDefinition") {
+      methodBody = method.value.body;
+    } else if (method.type === "Property" || method.type === "ClassProperty") {
+      methodBody = method.value.body;
+    }
+    if (!methodBody) {
+      return;
+    }
+    replaceThisProps(methodBody, j);
+    if (methodName === "componentDidMount") {
+      needsUseEffect = true;
+      hooks.push(
+        j.expressionStatement(
+          j.callExpression(j.identifier("useEffect"), [
+            j.arrowFunctionExpression([], methodBody),
+            j.arrayExpression([]),
+          ])
+        )
+      );
+    } else if (methodName === "componentWillUnmount") {
+      needsUseEffect = true;
+      let cleanupFunction;
+      if (methodBody.type === "BlockStatement") {
+        cleanupFunction = j.arrowFunctionExpression([], methodBody);
+      } else {
+        cleanupFunction = j.arrowFunctionExpression(
+          [],
+          j.blockStatement([j.returnStatement(methodBody)])
+        );
+      }
+      const effectBody = j.blockStatement([j.returnStatement(cleanupFunction)]);
+      hooks.push(
+        j.expressionStatement(
+          j.callExpression(j.identifier("useEffect"), [
+            j.arrowFunctionExpression([], effectBody),
+            j.arrayExpression([]),
+          ])
+        )
+      );
+    } else if (methodName === "componentDidUpdate") {
+      needsUseEffect = true;
+      const params =
+        method.type === "MethodDefinition"
+          ? method.value.params
+          : method.value.params || [];
+      if (params.length > 0) {
+        hooks.push(
+          j.expressionStatement(
+            j.callExpression(j.identifier("useEffect"), [
+              j.arrowFunctionExpression([], methodBody),
+              j.arrayExpression([j.identifier("props")]),
+            ])
+          )
+        );
+      } else {
+        hooks.push(
+          j.expressionStatement(
+            j.callExpression(j.identifier("useEffect"), [
+              j.arrowFunctionExpression([], methodBody),
+            ])
+          )
+        );
+      }
+    } else if (
+      methodName === "UNSAFE_componentWillReceiveProps" ||
+      methodName === "componentWillReceiveProps"
+    ) {
+      needsUseEffect = true;
+      const params =
+        method.type === "MethodDefinition"
+          ? method.value.params
+          : method.value.params || [];
+      if (params.length > 0 && params[0].name) {
+        j(methodBody)
+          .find(j.Identifier, { name: params[0].name })
+          .replaceWith(() => j.identifier("props"));
+      }
+      hooks.push(
+        j.expressionStatement(
+          j.callExpression(j.identifier("useEffect"), [
+            j.arrowFunctionExpression([], methodBody),
+            j.arrayExpression([j.identifier("props")]),
+          ])
+        )
+      );
+    }
+  });
+
+  return { hooks, needsUseEffect };
+}
+
+/**
+ * Создает функциональный компонент из классового
+ */
+function createFunctionalComponent(classNode, j, path) {
+  const className = getComponentName(classNode, j, path);
+  const classBody = classNode.body;
+  if (hasStateUsage(classNode, j)) {
+    return null;
+  }
+  const { methods, lifecycleMethods, staticProperties } =
+    convertMethodsToFunctions(classBody);
+  const renderMethod = classBody.body.find((member) => {
+    if (member.type === "MethodDefinition" && member.key.name === "render") {
+      return true;
+    }
+    return (
+      (member.type === "Property" || member.type === "ClassProperty") &&
+      member.key &&
+      member.key.name === "render"
+    );
+  });
+  if (!renderMethod) {
+    return null;
+  }
+  let renderBody;
+  if (renderMethod.type === "MethodDefinition") {
+    renderBody = renderMethod.value.body;
+  } else {
+    renderBody = renderMethod.value.body;
+  }
+  if (!renderBody) {
+    return null;
+  }
+  const { hooks, needsUseEffect } = convertLifecycleMethodsToHooks(
+    lifecycleMethods,
+    j
+  );
+  const componentStatements = [];
+  const methodNames = [];
+  componentStatements.push(...hooks);
+  methods.forEach((method) => {
+    const methodName = method.key.name;
+    methodNames.push(methodName);
+    let methodBody;
+    let isArrow = false;
+    let params = [];
+    if (method.type === "MethodDefinition") {
+      methodBody = method.value.body;
+      params = method.value.params || [];
+    } else if (method.type === "Property" || method.type === "ClassProperty") {
+      if (method.value.type === "ArrowFunctionExpression") {
+        methodBody = method.value.body;
+        params = method.value.params || [];
+        isArrow = true;
+      } else {
+        methodBody = method.value.body;
+        params = method.value.params || [];
+      }
+    }
+    if (methodBody) {
+      replaceThisProps(methodBody, j);
+      replaceThisMethods(methodBody, methodNames, j);
+      if (
+        isArrow ||
+        method.type === "Property" ||
+        method.type === "ClassProperty"
+      ) {
+        componentStatements.push(
+          j.variableDeclaration("const", [
+            j.variableDeclarator(
+              j.identifier(methodName),
+              j.arrowFunctionExpression(params, methodBody)
+            ),
+          ])
+        );
+      } else {
+        componentStatements.push(
+          j.variableDeclaration("const", [
+            j.variableDeclarator(
+              j.identifier(methodName),
+              j.functionExpression(null, params, methodBody)
+            ),
+          ])
+        );
+      }
+    }
+  });
+  replaceThisProps(renderBody, j);
+  replaceThisMethods(renderBody, methodNames, j);
+  let componentBody;
+  if (renderBody.type === "BlockStatement") {
+    componentBody = j.blockStatement([
+      ...componentStatements,
+      ...renderBody.body,
+    ]);
+  } else {
+    componentBody = j.blockStatement([
+      ...componentStatements,
+      j.returnStatement(renderBody),
+    ]);
+  }
+  const componentParams = [j.identifier("props")];
+  const arrowFunction = j.arrowFunctionExpression(
+    componentParams,
+    componentBody
+  );
+  let componentDeclaration;
+  if (className) {
+    componentDeclaration = j.variableDeclaration("const", [
+      j.variableDeclarator(j.identifier(className), arrowFunction),
+    ]);
+  } else {
+    componentDeclaration = j.variableDeclaration("const", [
+      j.variableDeclarator(j.identifier("Component"), arrowFunction),
+    ]);
+  }
+  const result = [componentDeclaration];
+  if (staticProperties.length > 0 && className) {
+    staticProperties.forEach((staticProp) => {
+      const propName = staticProp.key.name;
+      result.push(
+        j.expressionStatement(
+          j.assignmentExpression(
+            "=",
+            j.memberExpression(j.identifier(className), j.identifier(propName)),
+            staticProp.value
+          )
+        )
+      );
+    });
+  }
+  return { result, needsUseEffect };
+}
+
+module.exports = function transformer(file, api) {
+  const j = api.jscodeshift;
+  const root = j(file.source);
+  let hasTransformations = false;
+  let needsUseEffect = false;
+  root.find(j.ClassDeclaration).forEach((path) => {
+    if (isReactComponentClass(path.node)) {
+      const transformed = createFunctionalComponent(path.node, j, path);
+      if (transformed) {
+        j(path).replaceWith(...transformed.result);
+        if (transformed.needsUseEffect) {
+          needsUseEffect = true;
+        }
+        hasTransformations = true;
+      }
+    }
+  });
+  root.find(j.ClassExpression).forEach((path) => {
+    if (isReactComponentClass(path.node)) {
+      const transformed = createFunctionalComponent(path.node, j, path);
+      if (transformed) {
+        const parent = path.parent.value;
+        if (parent && parent.type === "ReturnStatement") {
+          const arrowFunction = transformed.result[0].declarations[0].init;
+          j(path.parent).replaceWith(j.returnStatement(arrowFunction));
+        } else if (parent && parent.type === "VariableDeclarator") {
+          j(path.parent.parent).replaceWith(...transformed.result);
+        } else {
+          j(path).replaceWith(...transformed.result);
+        }
+        if (transformed.needsUseEffect) {
+          needsUseEffect = true;
+        }
+        hasTransformations = true;
+      }
+    }
+  });
+  root
+    .find(j.ImportDeclaration, {
+      source: { value: "react" },
+    })
+    .forEach((path) => {
+      const specifiers = path.value.specifiers || [];
+      const componentSpecifier = specifiers.find(
+        (s) => s.type === "ImportSpecifier" && s.imported.name === "Component"
+      );
+      const useEffectSpecifier = specifiers.find(
+        (s) => s.type === "ImportSpecifier" && s.imported.name === "useEffect"
+      );
+      if (needsUseEffect && !useEffectSpecifier) {
+        const newSpecifier = j.importSpecifier(j.identifier("useEffect"));
+        if (specifiers.length === 0) {
+          path.value.specifiers = [newSpecifier];
+        } else {
+          path.value.specifiers.push(newSpecifier);
+        }
+      }
+      if (componentSpecifier) {
+        const componentName = componentSpecifier.local.name;
+        const hasOtherUsage = root
+          .find(j.Identifier, { name: componentName })
+          .some((p) => {
+            const parent = p.parent.value;
+            return (
+              parent.type !== "ImportSpecifier" ||
+              (parent.type === "ImportSpecifier" &&
+                parent.imported.name !== "Component")
+            );
+          });
+        if (!hasOtherUsage) {
+          const newSpecifiers = specifiers.filter(
+            (s) => s !== componentSpecifier
+          );
+          if (newSpecifiers.length === 0) {
+            const hasDefault = specifiers.some(
+              (s) =>
+                s.type === "ImportDefaultSpecifier" ||
+                s.type === "ImportNamespaceSpecifier"
+            );
+            if (!hasDefault) {
+              j(path).remove();
+            } else {
+              path.value.specifiers = newSpecifiers;
+            }
+          } else {
+            path.value.specifiers = newSpecifiers;
+          }
+        }
+      }
+    });
+  if (needsUseEffect) {
+    const reactImports = root.find(j.ImportDeclaration, {
+      source: { value: "react" },
+    });
+    if (reactImports.length === 0) {
+      const useEffectImport = j.importDeclaration(
+        [j.importSpecifier(j.identifier("useEffect"))],
+        j.literal("react")
+      );
+      root.find(j.Program).get("body", 0).insertBefore(useEffectImport);
+    }
+  }
+  return hasTransformations
+    ? root.toSource({ quote: "single", trailingComma: true })
+    : null;
+};

package/scripts/classToFC/run-codemod.js

@@ -0,0 +1,58 @@
+#!/usr/bin/env node
+
+/**
+ * Обертка для запуска codemod скрипта
+ *
+ * Использование:
+ * node node_modules/power-linter/scripts/classToFC/run-codemod.js <file-path>
+ */
+
+const { execSync } = require("child_process");
+const path = require("path");
+const fs = require("fs");
+
+const filePath = process.argv[2];
+if (!filePath) {
+  console.error("Ошибка: Укажите путь к файлу для преобразования");
+  console.error("Использование: npm run codemod:classToFC -- <file-path>");
+  process.exit(1);
+}
+// Определяем корень проекта: если запускаемся из power-linter, используем родительскую директорию
+const currentDir = process.cwd();
+const isPowerLinterDir =
+  currentDir.endsWith("power-linter") ||
+  path.basename(currentDir) === "power-linter";
+const projectRoot = isPowerLinterDir ? path.join(currentDir, "..") : currentDir;
+const absolutePath = path.isAbsolute(filePath)
+  ? filePath
+  : path.join(projectRoot, filePath);
+if (!fs.existsSync(absolutePath)) {
+  console.error(`Ошибка: Файл не найден: ${absolutePath}`);
+  process.exit(1);
+}
+const ext = path.extname(absolutePath);
+if (![".js", ".jsx", ".ts", ".tsx"].includes(ext)) {
+  console.error(`Ошибка: Файл должен иметь расширение .js, .jsx, .ts или .tsx`);
+  process.exit(1);
+}
+const codemodPath = path.join(__dirname, "class-to-functional.js");
+// eslint-disable-next-line no-console
+console.log(`Преобразование файла: ${filePath}`);
+// eslint-disable-next-line no-console
+console.log(`Использование codemod: ${codemodPath}`);
+try {
+  const command = `npx jscodeshift -t "${codemodPath}" "${absolutePath}"`;
+  // eslint-disable-next-line no-console
+  console.log(`Выполнение: ${command}`);
+  execSync(command, {
+    stdio: "inherit",
+    cwd: projectRoot,
+  });
+  // eslint-disable-next-line no-console
+  console.log("\n✓ Преобразование завершено успешно!");
+  // eslint-disable-next-line no-console
+  console.log("Проверьте файл и при необходимости внесите ручные исправления.");
+} catch (error) {
+  console.error("\n✗ Ошибка при выполнении преобразования:", error.message);
+  process.exit(1);
+}

package/src/eslint/config.js

@@ -0,0 +1,73 @@
+module.exports = {
+  root: true,
+  env: {
+    browser: true,
+    node: true,
+    es2021: true,
+  },
+  extends: [
+    "airbnb",
+    "airbnb/hooks",
+    "eslint:recommended",
+    "prettier",
+    "plugin:power-esrules/recommended",
+  ],
+  plugins: ["power-esrules"],
+  parser: "@babel/eslint-parser",
+  parserOptions: {
+    requireConfigFile: false,
+  },
+  globals: {
+    document: true,
+    localStorage: true,
+    Headers: true,
+    fetch: true,
+  },
+  rules: {
+    "no-continue": 0,
+    "consistent-return": 0,
+    "no-constant-condition": 0,
+    "arrow-parens": 0,
+    "no-else-return": 0,
+    "global-require": 0,
+    "max-len": ["error", { code: 120, ignorePattern: "^import\\W.*" }],
+    "linebreak-style": 0,
+    indent: 0,
+    "prefer-template": ["warn"],
+    "no-restricted-syntax": 0,
+    "no-prototype-builtins": 0,
+    "no-param-reassign": ["error", { props: false }],
+    "comma-dangle": ["error", "only-multiline"],
+    "no-undef": 0,
+    "no-shadow": 0,
+    "no-plusplus": 0,
+    "arrow-body-style": ["error", "as-needed"],
+    "default-param-last": 0,
+    "class-methods-use-this": ["error", { enforceForClassFields: false }],
+    "no-use-before-define": [
+      "error",
+      { functions: false, classes: true, variables: true },
+    ],
+    "no-useless-escape": "warn",
+    "no-console": ["error", { allow: ["warn", "error"] }],
+    "func-names": 0,
+    "jsx-a11y/anchor-is-valid": ["warn"],
+    "jsx-a11y/no-static-element-interactions": 0,
+    "jsx-a11y/click-events-have-key-events": ["warn"],
+    "import/prefer-default-export": 0,
+    "import/extensions": ["warn", { jsx: "never" }],
+    "import/no-unresolved": 0,
+    "import/no-extraneous-dependencies": 0,
+    "react/jsx-curly-brace-presence": 0,
+    "react/jsx-filename-extension": ["warn", { extensions: [".js", ".jsx"] }],
+    "react/require-default-props": 0,
+    "react/jsx-curly-spacing": 0,
+    "react/jsx-indent": ["error", 4],
+    "react/jsx-indent-props": 0,
+    "react/forbid-prop-types": 0,
+    "react/sort-comp": 0,
+    "react/prop-types": 0,
+    "react/jsx-props-no-spreading": 0,
+    "react/jsx-no-bind": 0,
+  },
+};

package/src/index.js

@@ -0,0 +1,7 @@
+const eslintConfig = require('./eslint/config');
+const prettierConfig = require('./prettier/config');
+
+module.exports = {
+    eslintConfig,
+    prettierConfig,
+};

package/src/prettier/config.js

@@ -0,0 +1,8 @@
+module.exports = {
+    printWidth: 120,
+    tabWidth: 4,
+    singleQuote: true,
+    semi: true,
+    trailingComma: 'es5',
+    arrowParens: 'always',
+};