From d667cb2375a3ee8072cc408eed26fadd5c82d9cd Mon Sep 17 00:00:00 2001
From: Ilya Olovyannikov <excaliburgyro@gmail.com>
Date: Sun, 14 Dec 2025 13:27:37 +0300
Subject: [PATCH 1/3] feat(prefer-single-binding): add rule

---
 .idea/workspace.xml                           | 152 +++++++++++++
 config/recommended.js                         |   1 +
 docs/rules/prefer-single-binding.md           | 215 ++++++++++++++++++
 index.js                                      |   1 +
 .../prefer-single-binding.js                  | 182 +++++++++++++++
 .../prefer-single-binding.test.js             | 152 +++++++++++++
 6 files changed, 703 insertions(+)
 create mode 100644 .idea/workspace.xml
 create mode 100644 docs/rules/prefer-single-binding.md
 create mode 100644 rules/prefer-single-binding/prefer-single-binding.js
 create mode 100644 rules/prefer-single-binding/prefer-single-binding.test.js

diff --git a/.idea/workspace.xml b/.idea/workspace.xml
new file mode 100644
index 0000000..40407e4
--- /dev/null
+++ b/.idea/workspace.xml
@@ -0,0 +1,152 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="AutoImportSettings">
+    <option name="autoReloadType" value="SELECTIVE" />
+  </component>
+  <component name="ChangeListManager">
+    <list default="true" id="698c7401-8c22-499e-8d8e-b2be1446ed6c" name="Changes" comment="">
+      <change afterPath="$PROJECT_DIR$/docs/rules/prefer-single-binding.md" afterDir="false" />
+      <change afterPath="$PROJECT_DIR$/rules/prefer-single-binding/prefer-single-binding.js" afterDir="false" />
+      <change afterPath="$PROJECT_DIR$/rules/prefer-single-binding/prefer-single-binding.test.js" afterDir="false" />
+      <change beforePath="$PROJECT_DIR$/config/recommended.js" beforeDir="false" afterPath="$PROJECT_DIR$/config/recommended.js" afterDir="false" />
+      <change beforePath="$PROJECT_DIR$/index.js" beforeDir="false" afterPath="$PROJECT_DIR$/index.js" afterDir="false" />
+    </list>
+    <option name="SHOW_DIALOG" value="false" />
+    <option name="HIGHLIGHT_CONFLICTS" value="true" />
+    <option name="HIGHLIGHT_NON_ACTIVE_CHANGELIST" value="false" />
+    <option name="LAST_RESOLUTION" value="IGNORE" />
+  </component>
+  <component name="Git.Settings">
+    <option name="RECENT_GIT_ROOT_PATH" value="$PROJECT_DIR$" />
+  </component>
+  <component name="GitHubPullRequestSearchHistory">{
+  &quot;lastFilter&quot;: {
+    &quot;state&quot;: &quot;OPEN&quot;,
+    &quot;assignee&quot;: &quot;Olovyannikov&quot;
+  }
+}</component>
+  <component name="GithubPullRequestsUISettings">{
+  &quot;selectedUrlAndAccountId&quot;: {
+    &quot;url&quot;: &quot;git@github.com:Olovyannikov/eslint-plugin.git&quot;,
+    &quot;accountId&quot;: &quot;576c952f-7d03-4613-af04-3b4bd892ceab&quot;
+  }
+}</component>
+  <component name="ProjectColorInfo">{
+  &quot;associatedIndex&quot;: 5
+}</component>
+  <component name="ProjectId" id="36bT1fS1RHSdxPfjFZvw2qNWdkJ" />
+  <component name="ProjectLevelVcsManager">
+    <ConfirmationsSetting value="2" id="Add" />
+  </component>
+  <component name="ProjectViewState">
+    <option name="hideEmptyMiddlePackages" value="true" />
+    <option name="showLibraryContents" value="true" />
+  </component>
+  <component name="PropertiesComponent">{
+  &quot;keyToString&quot;: {
+    &quot;ModuleVcsDetector.initialDetectionPerformed&quot;: &quot;true&quot;,
+    &quot;RunOnceActivity.ShowReadmeOnStart&quot;: &quot;true&quot;,
+    &quot;RunOnceActivity.git.unshallow&quot;: &quot;true&quot;,
+    &quot;com.intellij.ml.llm.matterhorn.ej.ui.settings.DefaultModelSelectionForGA.v1&quot;: &quot;true&quot;,
+    &quot;git-widget-placeholder&quot;: &quot;new/prefer-single-binding&quot;,
+    &quot;junie.onboarding.icon.badge.shown&quot;: &quot;true&quot;,
+    &quot;last_opened_file_path&quot;: &quot;/Users/ilaolovannikov/WebstormProjects/eslint-plugin-fork/docs&quot;,
+    &quot;node.js.detected.package.eslint&quot;: &quot;true&quot;,
+    &quot;node.js.detected.package.tslint&quot;: &quot;true&quot;,
+    &quot;node.js.selected.package.eslint&quot;: &quot;(autodetect)&quot;,
+    &quot;node.js.selected.package.tslint&quot;: &quot;(autodetect)&quot;,
+    &quot;nodejs_package_manager_path&quot;: &quot;pnpm&quot;,
+    &quot;npm.docs:build.executor&quot;: &quot;Run&quot;,
+    &quot;npm.docs:prepare.executor&quot;: &quot;Run&quot;,
+    &quot;npm.test.executor&quot;: &quot;Run&quot;,
+    &quot;to.speed.mode.migration.done&quot;: &quot;true&quot;,
+    &quot;vue.rearranger.settings.migration&quot;: &quot;true&quot;
+  }
+}</component>
+  <component name="RecentsManager">
+    <key name="CopyFile.RECENT_KEYS">
+      <recent name="$PROJECT_DIR$/docs" />
+      <recent name="$PROJECT_DIR$/rules" />
+    </key>
+    <key name="MoveFile.RECENT_KEYS">
+      <recent name="$PROJECT_DIR$/docs/rules" />
+    </key>
+  </component>
+  <component name="RunManager" selected="npm.test">
+    <configuration name="docs:build" type="js.build_tools.npm" temporary="true" nameIsGenerated="true">
+      <package-json value="$PROJECT_DIR$/package.json" />
+      <command value="run" />
+      <scripts>
+        <script value="docs:build" />
+      </scripts>
+      <node-interpreter value="project" />
+      <envs />
+      <method v="2" />
+    </configuration>
+    <configuration name="docs:prepare" type="js.build_tools.npm" temporary="true" nameIsGenerated="true">
+      <package-json value="$PROJECT_DIR$/package.json" />
+      <command value="run" />
+      <scripts>
+        <script value="docs:prepare" />
+      </scripts>
+      <node-interpreter value="project" />
+      <envs />
+      <method v="2" />
+    </configuration>
+    <configuration name="test" type="js.build_tools.npm" temporary="true" nameIsGenerated="true">
+      <package-json value="$PROJECT_DIR$/package.json" />
+      <command value="run" />
+      <scripts>
+        <script value="test" />
+      </scripts>
+      <node-interpreter value="project" />
+      <envs />
+      <method v="2" />
+    </configuration>
+    <recent_temporary>
+      <list>
+        <item itemvalue="npm.test" />
+        <item itemvalue="npm.docs:build" />
+        <item itemvalue="npm.docs:prepare" />
+      </list>
+    </recent_temporary>
+  </component>
+  <component name="SharedIndexes">
+    <attachedChunks>
+      <set>
+        <option value="bundled-js-predefined-d6986cc7102b-09060db00ec0-JavaScript-WS-251.26927.40" />
+      </set>
+    </attachedChunks>
+  </component>
+  <component name="TaskManager">
+    <task active="true" id="Default" summary="Default task">
+      <changelist id="698c7401-8c22-499e-8d8e-b2be1446ed6c" name="Changes" comment="" />
+      <created>1765274057645</created>
+      <option name="number" value="Default" />
+      <option name="presentableId" value="Default" />
+      <updated>1765274057645</updated>
+      <workItem from="1765274058707" duration="3652000" />
+    </task>
+    <servers />
+  </component>
+  <component name="TypeScriptGeneratedFilesManager">
+    <option name="version" value="3" />
+    <option name="exactExcludedFiles">
+      <list>
+        <option value="$PROJECT_DIR$/rules/strict-effect-handlers/examples/incorrect-mix-async-fx.js" />
+        <option value="$PROJECT_DIR$/rules/enforce-store-naming-convention/postfix/examples/correct-store-naming.js" />
+        <option value="$PROJECT_DIR$/rules/strict-effect-handlers/examples/incorrect-mix-in-simple-function.js" />
+        <option value="$PROJECT_DIR$/rules/strict-effect-handlers/examples/incorrect-mix-async-fx-in-named-func.js" />
+        <option value="$PROJECT_DIR$/rules/enforce-gate-naming-convention/examples/correct-gate-naming.js" />
+        <option value="$PROJECT_DIR$/rules/enforce-effect-naming-convention/examples/correct-effect-naming.js" />
+        <option value="$PROJECT_DIR$/rules/strict-effect-handlers/examples/incorrect-mix-async-fx-in-func.js" />
+        <option value="$PROJECT_DIR$/rules/enforce-store-naming-convention/prefix/examples/correct-store-naming.js" />
+        <option value="$PROJECT_DIR$/rules/prefer-useUnit/examples/incorrect-useStore.jsx" />
+        <option value="$PROJECT_DIR$/rules/prefer-useUnit/examples/correct-single-useUnit.jsx" />
+        <option value="$PROJECT_DIR$/rules/prefer-useUnit/examples/incorrect-useEvent-with-effect.jsx" />
+        <option value="$PROJECT_DIR$/rules/prefer-useUnit/examples/incorrect-useEvent-with-event.jsx" />
+        <option value="$PROJECT_DIR$/rules/prefer-useUnit/examples/correct-multiple-useUnit.jsx" />
+      </list>
+    </option>
+  </component>
+</project>
\ No newline at end of file
diff --git a/config/recommended.js b/config/recommended.js
index 8f2f4a8..4653173 100644
--- a/config/recommended.js
+++ b/config/recommended.js
@@ -11,5 +11,6 @@ module.exports = {
     "effector/no-unnecessary-combination": "warn",
     "effector/no-duplicate-on": "error",
     "effector/keep-options-order": "warn",
+    "effector/prefer-single-binding": "warn",
   },
 };
diff --git a/docs/rules/prefer-single-binding.md b/docs/rules/prefer-single-binding.md
new file mode 100644
index 0000000..b7c70c5
--- /dev/null
+++ b/docs/rules/prefer-single-binding.md
@@ -0,0 +1,215 @@
+# effector/no-multiple-use-unit
+
+[Related documentation](https://effector.dev/en/api/effector-react/useunit/)
+
+Recommends combining multiple `useUnit` calls into a single call for better performance and cleaner code.
+
+## Rule Details
+
+This rule detects when multiple `useUnit` hooks are called in the same component and suggests combining them into a single call.
+
+Multiple `useUnit` calls can lead to:
+- **Performance overhead**: Each `useUnit` creates separate subscriptions without batch-updates
+- **Code duplication**: Repetitive hook calls make code harder to read
+- **Maintenance issues**: Harder to track all units used in a component
+
+### Examples
+
+```tsx
+// 👎 incorrect - multiple useUnit calls
+const Component = () => {
+  const [store] = useUnit([$store]);
+  const [event] = useUnit([$event]);
+  
+  return <button onClick={event}>{store}</button>;
+};
+```
+
+```tsx
+// 👍 correct - single useUnit call
+const Component = () => {
+  const [store, event] = useUnit([$store, $event]);
+  
+  return <button onClick={event}>{store}</button>;
+};
+```
+
+## Why is this important?
+
+### Performance
+
+Each `useUnit` call creates its own subscription management overhead. Combining them reduces:
+- Number of hook calls
+- Subscription management overhead
+- Re-render coordination complexity
+
+### Code clarity
+
+A single `useUnit` call makes it easier to:
+- See all dependencies at a glance
+- Understand component's reactive logic
+- Maintain and refactor code
+
+## Array shape examples
+
+```tsx
+// 👎 incorrect
+const Component = () => {
+  const [userName] = useUnit([$userName]);
+  const [userAge] = useUnit([$userAge]);
+  const [updateUser] = useUnit([updateUserEvent]);
+  
+  return (
+    <div>
+      <p>{userName}, {userAge}</p>
+      <button onClick={updateUser}>Update</button>
+    </div>
+  );
+};
+```
+
+```tsx
+// 👍 correct
+const Component = () => {
+  const [userName, userAge, updateUser] = useUnit([
+    $userName,
+    $userAge,
+    updateUserEvent,
+  ]);
+  
+  return (
+    <div>
+      <p>{userName}, {userAge}</p>
+      <button onClick={updateUser}>Update</button>
+    </div>
+  );
+};
+```
+
+## Object shape examples
+
+```tsx
+// 👎 incorrect
+const Component = () => {
+  const { userName } = useUnit({ userName: $userName });
+  const { userAge } = useUnit({ userAge: $userAge });
+  const { updateUser } = useUnit({ updateUser: updateUserEvent });
+  
+  return (
+    <div>
+      <p>{userName}, {userAge}</p>
+      <button onClick={updateUser}>Update</button>
+    </div>
+  );
+};
+```
+
+```tsx
+// 👍 correct
+const Component = () => {
+  const { userName, userAge, updateUser } = useUnit({
+    userName: $userName,
+    userAge: $userAge,
+    updateUser: updateUserEvent,
+  });
+  
+  return (
+    <div>
+      <p>{userName}, {userAge}</p>
+      <button onClick={updateUser}>Update</button>
+    </div>
+  );
+};
+```
+
+## Real-world example
+
+```tsx
+import React from "react";
+import { createEvent, createStore } from "effector";
+import { useUnit } from "effector-react";
+
+const $userName = createStore("John");
+const $userEmail = createStore("john@example.com");
+const $isLoading = createStore(false);
+const updateNameEvent = createEvent<string>();
+const updateEmailEvent = createEvent<string>();
+
+// 👎 incorrect - scattered useUnit calls
+const UserProfile = () => {
+  const [userName] = useUnit([$userName]);
+  const [userEmail] = useUnit([$userEmail]);
+  const [isLoading] = useUnit([$isLoading]);
+  const [updateName] = useUnit([updateNameEvent]);
+  const [updateEmail] = useUnit([updateEmailEvent]);
+
+  return (
+    <div>
+      {isLoading ? (
+        <p>Loading...</p>
+      ) : (
+        <>
+          <input value={userName} onChange={(e) => updateName(e.target.value)} />
+          <input value={userEmail} onChange={(e) => updateEmail(e.target.value)} />
+        </>
+      )}
+    </div>
+  );
+};
+
+// 👍 correct - single useUnit call
+const UserProfile = () => {
+  const [userName, userEmail, isLoading, updateName, updateEmail] = useUnit([
+    $userName,
+    $userEmail,
+    $isLoading,
+    updateNameEvent,
+    updateEmailEvent,
+  ]);
+
+  return (
+    <div>
+      {isLoading ? (
+        <p>Loading...</p>
+      ) : (
+        <>
+          <input value={userName} onChange={(e) => updateName(e.target.value)} />
+          <input value={userEmail} onChange={(e) => updateEmail(e.target.value)} />
+        </>
+      )}
+    </div>
+  );
+};
+```
+
+## Auto-fix
+
+This rule provides an automatic fix that combines all `useUnit` calls into a single one. When you run ESLint with the `--fix` flag, it will automatically refactor your code:
+
+```bash
+eslint --fix your-file.tsx
+```
+
+## When Not To Use It
+
+In rare cases, you might want to keep `useUnit` calls separate for logical grouping or conditional logic. In such cases, you can disable the rule:
+
+```tsx
+/* eslint-disable effector/no-multiple-use-unit */
+const Component = () => {
+  const [userStore] = useUnit([$userStore]);
+  
+  // Some complex logic here...
+  
+  const [settingsStore] = useUnit([$settingsStore]);
+  
+  return null;
+};
+/* eslint-enable effector/no-multiple-use-unit */
+```
+
+However, even in these cases, consider refactoring to use a single `useUnit` call for better performance and clarity.
+
+## Related Rules
+
+- [effector/use-unit-destructuring](./use-unit-destructuring.md) - Ensures proper destructuring of useUnit results
\ No newline at end of file
diff --git a/index.js b/index.js
index 66b7952..1184b8b 100644
--- a/index.js
+++ b/index.js
@@ -20,6 +20,7 @@ module.exports = {
     "prefer-useUnit": require("./rules/prefer-useUnit/prefer-useUnit"),
     "require-pickup-in-persist": require("./rules/require-pickup-in-persist/require-pickup-in-persist"),
     "no-patronum-debug": require("./rules/no-patronum-debug/no-patronum-debug"),
+    "prefer-single-binding": require("./rules/prefer-single-binding/prefer-single-binding"),
   },
   configs: {
     recommended: require("./config/recommended"),
diff --git a/rules/prefer-single-binding/prefer-single-binding.js b/rules/prefer-single-binding/prefer-single-binding.js
new file mode 100644
index 0000000..6f7d936
--- /dev/null
+++ b/rules/prefer-single-binding/prefer-single-binding.js
@@ -0,0 +1,182 @@
+const {createLinkToRule} = require("../../utils/create-link-to-rule");
+module.exports = {
+    meta: {
+        type: 'suggestion',
+        docs: {
+            description: 'Recommend using a single useUnit call instead of multiple',
+            category: 'Best Practices',
+            recommended: true,
+            url: createLinkToRule("prefer-single-binding"),
+        },
+        messages: {
+            multipleUseUnit: 'Multiple useUnit calls detected. Consider combining them into a single call for better performance.',
+        },
+        schema: [],
+        fixable: 'code',
+    },
+    create(context) {
+        return {
+            'FunctionDeclaration, FunctionExpression, ArrowFunctionExpression'(node) {
+                const body = node.body.type === 'BlockStatement' ? node.body.body : null;
+                if (!body) return;
+
+                const useUnitCalls = [];
+
+                // Ищем все вызовы useUnit в теле функции
+                body.forEach((statement) => {
+                    if (
+                        statement.type === 'VariableDeclaration' &&
+                        statement.declarations.length > 0
+                    ) {
+                        statement.declarations.forEach((declarator) => {
+                            if (
+                                declarator.init &&
+                                declarator.init.type === 'CallExpression' &&
+                                declarator.init.callee.type === 'Identifier' &&
+                                declarator.init.callee.name === 'useUnit'
+                            ) {
+                                useUnitCalls.push({
+                                    statement,
+                                    declarator,
+                                    init: declarator.init,
+                                    id: declarator.id,
+                                });
+                            }
+                        });
+                    }
+                });
+
+                // Если найдено более одного useUnit, сообщаем об ошибке
+                if (useUnitCalls.length > 1) {
+                    useUnitCalls.forEach((call, index) => {
+                        if (index > 0) {
+                            context.report({
+                                node: call.init,
+                                messageId: 'multipleUseUnit',
+                                fix(fixer) {
+                                    return generateFix(fixer, useUnitCalls, context);
+                                },
+                            });
+                        }
+                    });
+                }
+            },
+        };
+    },
+};
+
+function generateFix(fixer, useUnitCalls, context) {
+    const sourceCode = context.getSourceCode ? context.getSourceCode() : context.sourceCode;
+
+    // Определяем, используется ли объектная или массивная форма
+    const firstArg = useUnitCalls[0].init.arguments[0];
+    const isArrayForm = firstArg && firstArg.type === 'ArrayExpression';
+    const isObjectForm = firstArg && firstArg.type === 'ObjectExpression';
+
+    // Если формы смешанные или неопределенные, не пытаемся исправить автоматически
+    const allSameForm = useUnitCalls.every((call) => {
+        const arg = call.init.arguments[0];
+        if (isArrayForm) return arg && arg.type === 'ArrayExpression';
+        if (isObjectForm) return arg && arg.type === 'ObjectExpression';
+        return false;
+    });
+
+    if (!allSameForm) return null;
+
+    const fixes = [];
+
+    if (isArrayForm) {
+        // Собираем все элементы массивов
+        const allElements = [];
+        const allDestructured = [];
+
+        useUnitCalls.forEach((call) => {
+            const arg = call.init.arguments[0];
+            if (arg.elements) {
+                allElements.push(...arg.elements.map(el => sourceCode.getText(el)));
+            }
+
+            if (call.id.type === 'ArrayPattern') {
+                allDestructured.push(
+                    ...call.id.elements.map(el => el ? sourceCode.getText(el) : null).filter(Boolean)
+                );
+            }
+        });
+
+        // Создаем объединенный вызов
+        const combinedCode = `const [${allDestructured.join(', ')}] = useUnit([${allElements.join(', ')}]);`;
+
+        // Заменяем первый вызов на объединенный
+        fixes.push(fixer.replaceText(useUnitCalls[0].statement, combinedCode));
+
+        // Удаляем остальные вызовы
+        for (let i = 1; i < useUnitCalls.length; i++) {
+            const statement = useUnitCalls[i].statement;
+            const token = sourceCode.getTokenBefore(statement);
+
+            // Находим начало строки (включая отступы)
+            let startIndex = statement.range[0];
+            const lineStart = sourceCode.text.lastIndexOf('\n', startIndex - 1) + 1;
+            const textBeforeStatement = sourceCode.text.slice(lineStart, startIndex);
+
+            // Если перед statement только пробелы, удаляем всю строку
+            if (/^\s*$/.test(textBeforeStatement)) {
+                startIndex = lineStart;
+            }
+
+            // Находим конец (включая перенос строки)
+            const endIndex = statement.range[1];
+            const nextChar = sourceCode.text[endIndex];
+            const removeEnd = (nextChar === '\n' || nextChar === '\r') ? endIndex + 1 : endIndex;
+
+            fixes.push(fixer.removeRange([startIndex, removeEnd]));
+        }
+    } else if (isObjectForm) {
+        // Собираем все свойства объектов
+        const allProperties = [];
+        const allDestructuredProps = [];
+
+        useUnitCalls.forEach((call) => {
+            const arg = call.init.arguments[0];
+            if (arg.properties) {
+                allProperties.push(...arg.properties.map(prop => sourceCode.getText(prop)));
+            }
+
+            if (call.id.type === 'ObjectPattern') {
+                allDestructuredProps.push(
+                    ...call.id.properties.map(prop => sourceCode.getText(prop))
+                );
+            }
+        });
+
+        // Создаем объединенный вызов
+        const combinedCode = `const { ${allDestructuredProps.join(', ')} } = useUnit({ ${allProperties.join(', ')} });`;
+
+        // Заменяем первый вызов на объединенный
+        fixes.push(fixer.replaceText(useUnitCalls[0].statement, combinedCode));
+
+        // Удаляем остальные вызовы
+        for (let i = 1; i < useUnitCalls.length; i++) {
+            const statement = useUnitCalls[i].statement;
+
+            // Находим начало строки (включая отступы)
+            let startIndex = statement.range[0];
+            const lineStart = sourceCode.text.lastIndexOf('\n', startIndex - 1) + 1;
+            const textBeforeStatement = sourceCode.text.slice(lineStart, startIndex);
+
+            // Если перед statement только пробелы, удаляем всю строку
+            if (/^\s*$/.test(textBeforeStatement)) {
+                startIndex = lineStart;
+            }
+
+            // Находим конец (включая перенос строки)
+            const endIndex = statement.range[1];
+            const nextChar = sourceCode.text[endIndex];
+            const removeEnd = (nextChar === '\n' || nextChar === '\r') ? endIndex + 1 : endIndex;
+
+            fixes.push(fixer.removeRange([startIndex, removeEnd]));
+        }
+    }
+
+    return fixes;
+}
\ No newline at end of file
diff --git a/rules/prefer-single-binding/prefer-single-binding.test.js b/rules/prefer-single-binding/prefer-single-binding.test.js
new file mode 100644
index 0000000..770da7f
--- /dev/null
+++ b/rules/prefer-single-binding/prefer-single-binding.test.js
@@ -0,0 +1,152 @@
+const { RuleTester } = require("eslint");
+const rule = require("./prefer-single-binding");
+
+const ruleTester = new RuleTester({
+    parserOptions: {
+        ecmaVersion: 2020,
+        sourceType: "module",
+        ecmaFeatures: { jsx: true },
+    },
+});
+
+ruleTester.run("effector/prefer-single-binding.test", rule, {
+    valid: [
+        // Once useUnit call - OK
+        {
+            code: `
+        import { useUnit } from "effector-react";
+        const Component = () => {
+          const [store, event] = useUnit([$store, $event]);
+          
+          return null;
+        };
+      `,
+        },
+        // Once useUnit with object-shape - OK
+        {
+            code: `
+        import { useUnit } from "effector-react";
+        const Component = () => {
+          const { store, event } = useUnit({ store: $store, event: $event });
+          
+          return null;
+        };
+      `,
+        },
+        // useUnit outside of components - dont check
+        {
+            code: `
+        import { useUnit } from "effector-react";
+        const store = useUnit([$store]);
+        const event = useUnit([$event]);
+      `,
+        },
+    ],
+
+    invalid: [
+        // Two useUnit calls with array-shape
+        {
+            code: `
+        import { useUnit } from "effector-react";
+        const Component = () => {
+          const [store] = useUnit([$store]);
+          const [event] = useUnit([$event]);
+          
+          return null;
+        };
+      `,
+            errors: [
+                {
+                    messageId: "multipleUseUnit",
+                },
+            ],
+            output: `
+        import { useUnit } from "effector-react";
+        const Component = () => {
+          const [store, event] = useUnit([$store, $event]);
+          
+          return null;
+        };
+      `,
+        },
+        // Three useUnit with array-shape
+        {
+            code: `
+        import { useUnit } from "effector-react";
+        const Component = () => {
+          const [store] = useUnit([$store]);
+          const [event] = useUnit([$event]);
+          const [another] = useUnit([$another]);
+          
+          return null;
+        };
+      `,
+            errors: [
+                {
+                    messageId: "multipleUseUnit",
+                },
+                {
+                    messageId: "multipleUseUnit",
+                },
+            ],
+            output: `
+        import { useUnit } from "effector-react";
+        const Component = () => {
+          const [store, event, another] = useUnit([$store, $event, $another]);
+          
+          return null;
+        };
+      `,
+        },
+        // Two useUnit calls with object-shape
+        {
+            code: `
+        import { useUnit } from "effector-react";
+        const Component = () => {
+          const { store } = useUnit({ store: $store });
+          const { event } = useUnit({ event: $event });
+          
+          return null;
+        };
+      `,
+            errors: [
+                {
+                    messageId: "multipleUseUnit",
+                },
+            ],
+            output: `
+        import { useUnit } from "effector-react";
+        const Component = () => {
+          const { store, event } = useUnit({ store: $store, event: $event });
+          
+          return null;
+        };
+      `,
+        },
+        // Multiple useUnit calls
+        {
+            code: `
+        import { useUnit } from "effector-react";
+        const Component = () => {
+          const [store1, store2] = useUnit([$store1, $store2]);
+          const [event1, event2] = useUnit([event1, event2]);
+          
+          return null;
+        };
+      `,
+            errors: [
+                {
+                    messageId: "multipleUseUnit",
+                },
+            ],
+            output: `
+        import { useUnit } from "effector-react";
+        const Component = () => {
+          const [store1, store2, event1, event2] = useUnit([$store1, $store2, $event1, $event2]);
+          
+          return null;
+        };
+      `,
+        },
+    ],
+});
\ No newline at end of file

From 15906fe3d5016a12208149f6bc215ff1c87f7643 Mon Sep 17 00:00:00 2001
From: Ilya Olovyannikov <excaliburgyro@gmail.com>
Date: Sun, 14 Dec 2025 13:58:30 +0300
Subject: [PATCH 2/3] feat(prefer-single-binding): add separate events and
 stores flag

---
 .idea/workspace.xml                           |  11 +-
 docs/rules/prefer-single-binding.md           | 395 ++++++++++++++++-
 .../prefer-single-binding.js                  | 397 ++++++++++++++++--
 .../prefer-single-binding.test.js             | 257 +++++++++++-
 4 files changed, 1007 insertions(+), 53 deletions(-)

diff --git a/.idea/workspace.xml b/.idea/workspace.xml
index 40407e4..1bb10ab 100644
--- a/.idea/workspace.xml
+++ b/.idea/workspace.xml
@@ -5,11 +5,10 @@
   </component>
   <component name="ChangeListManager">
     <list default="true" id="698c7401-8c22-499e-8d8e-b2be1446ed6c" name="Changes" comment="">
-      <change afterPath="$PROJECT_DIR$/docs/rules/prefer-single-binding.md" afterDir="false" />
-      <change afterPath="$PROJECT_DIR$/rules/prefer-single-binding/prefer-single-binding.js" afterDir="false" />
-      <change afterPath="$PROJECT_DIR$/rules/prefer-single-binding/prefer-single-binding.test.js" afterDir="false" />
-      <change beforePath="$PROJECT_DIR$/config/recommended.js" beforeDir="false" afterPath="$PROJECT_DIR$/config/recommended.js" afterDir="false" />
-      <change beforePath="$PROJECT_DIR$/index.js" beforeDir="false" afterPath="$PROJECT_DIR$/index.js" afterDir="false" />
+      <change beforePath="$PROJECT_DIR$/.idea/workspace.xml" beforeDir="false" afterPath="$PROJECT_DIR$/.idea/workspace.xml" afterDir="false" />
+      <change beforePath="$PROJECT_DIR$/docs/rules/prefer-single-binding.md" beforeDir="false" afterPath="$PROJECT_DIR$/docs/rules/prefer-single-binding.md" afterDir="false" />
+      <change beforePath="$PROJECT_DIR$/rules/prefer-single-binding/prefer-single-binding.js" beforeDir="false" afterPath="$PROJECT_DIR$/rules/prefer-single-binding/prefer-single-binding.js" afterDir="false" />
+      <change beforePath="$PROJECT_DIR$/rules/prefer-single-binding/prefer-single-binding.test.js" beforeDir="false" afterPath="$PROJECT_DIR$/rules/prefer-single-binding/prefer-single-binding.test.js" afterDir="false" />
     </list>
     <option name="SHOW_DIALOG" value="false" />
     <option name="HIGHLIGHT_CONFLICTS" value="true" />
@@ -125,7 +124,7 @@
       <option name="number" value="Default" />
       <option name="presentableId" value="Default" />
       <updated>1765274057645</updated>
-      <workItem from="1765274058707" duration="3652000" />
+      <workItem from="1765274058707" duration="7034000" />
     </task>
     <servers />
   </component>
diff --git a/docs/rules/prefer-single-binding.md b/docs/rules/prefer-single-binding.md
index b7c70c5..68c784e 100644
--- a/docs/rules/prefer-single-binding.md
+++ b/docs/rules/prefer-single-binding.md
@@ -34,6 +34,237 @@ const Component = () => {
 };
 ```
 
+## Options
+
+This rule accepts an options object with the following properties:
+
+```typescript
+type Options = {
+  allowSeparateStoresAndEvents?: boolean;
+  enforceStoresAndEventsSeparation?: boolean;
+};
+```
+
+### `allowSeparateStoresAndEvents`
+
+**Default:** `false`
+
+When set to `true`, allows separate `useUnit` calls for stores and events, but still enforces combining multiple calls within each group.
+
+The rule uses heuristics to determine whether a unit is a store or an event:
+- **Stores**: Names starting with `$`, or matching patterns like `is*`, `has*`, `*Store`, `*State`, `data`, `value`, `items`
+- **Events**: Names ending with `*Event`, `*Changed`, `*Triggered`, `*Clicked`, `*Pressed`, or starting with `on*`, `handle*`, `set*`, `update*`, `submit*`
+
+#### Configuration
+
+```javascript
+// .eslintrc.js
+module.exports = {
+  rules: {
+    'effector/no-multiple-use-unit': ['warn', {
+      allowSeparateStoresAndEvents: true
+    }]
+  }
+};
+```
+
+#### Examples with `allowSeparateStoresAndEvents: true`
+
+```tsx
+// 👍 correct - separate groups for stores and events
+const Component = () => {
+  const [userName, userAge] = useUnit([$userName, $userAge]);
+  const [updateUser, deleteUser] = useUnit([updateUserEvent, deleteUserEvent]);
+  
+  return (
+    <div>
+      <p>{userName}, {userAge}</p>
+      <button onClick={updateUser}>Update</button>
+      <button onClick={deleteUser}>Delete</button>
+    </div>
+  );
+};
+```
+
+```tsx
+// 👎 incorrect - multiple stores in separate calls
+const Component = () => {
+  const [userName] = useUnit([$userName]);
+  const [userAge] = useUnit([$userAge]);
+  const [updateUser, deleteUser] = useUnit([updateUserEvent, deleteUserEvent]);
+  
+  return <div>...</div>;
+};
+```
+
+```tsx
+// 👎 incorrect - multiple events in separate calls
+const Component = () => {
+  const [userName, userAge] = useUnit([$userName, $userAge]);
+  const [updateUser] = useUnit([updateUserEvent]);
+  const [deleteUser] = useUnit([deleteUserEvent]);
+  
+  return <div>...</div>;
+};
+```
+
+### `enforceStoresAndEventsSeparation`
+
+**Default:** `false`
+
+When set to `true`, enforces separation of stores and events into different `useUnit` calls. This option detects when a single `useUnit` call contains both stores and events and suggests splitting them.
+
+This is useful when you want to maintain clear logical separation between state (stores) and actions (events) in your components.
+
+#### Configuration
+
+```javascript
+// .eslintrc.js
+module.exports = {
+  rules: {
+    'effector/no-multiple-use-unit': ['warn', {
+      enforceStoresAndEventsSeparation: true
+    }]
+  }
+};
+```
+
+#### Examples with `enforceStoresAndEventsSeparation: true`
+
+```tsx
+// 👎 incorrect - mixed stores and events
+const Component = () => {
+  const [value, setValue] = useUnit([$store, event]);
+  
+  return <input value={value} onChange={setValue} />;
+};
+```
+
+```tsx
+// 👍 correct - separated stores and events
+const Component = () => {
+  const [value] = useUnit([$store]);
+  const [setValue] = useUnit([event]);
+  
+  return <input value={value} onChange={setValue} />;
+};
+```
+
+```tsx
+// 👎 incorrect - mixed in object form
+const Component = () => {
+  const { value, setValue } = useUnit({ 
+    value: $store, 
+    setValue: event 
+  });
+  
+  return <input value={value} onChange={setValue} />;
+};
+```
+
+```tsx
+// 👍 correct - separated in object form
+const Component = () => {
+  const { value } = useUnit({ value: $store });
+  const { setValue } = useUnit({ setValue: event });
+  
+  return <input value={value} onChange={setValue} />;
+};
+```
+
+### Combining both options
+
+You can use both options together to enforce a specific code style:
+
+```javascript
+// .eslintrc.js
+module.exports = {
+  rules: {
+    'effector/no-multiple-use-unit': ['warn', {
+      allowSeparateStoresAndEvents: true,
+      enforceStoresAndEventsSeparation: true
+    }]
+  }
+};
+```
+
+With both options enabled:
+- Mixed `useUnit` calls will be split into separate calls for stores and events
+- Multiple calls of the same type (stores or events) will be combined
+
+```tsx
+// 👎 incorrect - mixed types
+const Component = () => {
+  const [value1, setValue1, value2, setValue2] = useUnit([
+    $store1, 
+    event1, 
+    $store2, 
+    event2
+  ]);
+  
+  return null;
+};
+```
+
+```tsx
+// 👍 correct - separated and combined by type
+const Component = () => {
+  const [value1, value2] = useUnit([$store1, $store2]);
+  const [setValue1, setValue2] = useUnit([event1, event2]);
+  
+  return null;
+};
+```
+
+#### Working with models
+
+This combination is especially useful when working with Effector models:
+
+```tsx
+// 👎 incorrect - mixed stores and events
+const Component = () => {
+  const [isFormSent, submit, reset, isLoading] = useUnit([
+    FormModel.$isFormSent,
+    FormModel.submitForm,
+    FormModel.resetForm,
+    FormModel.$isLoading,
+  ]);
+  
+  return (
+    <form onSubmit={submit}>
+      {isLoading && <Spinner />}
+      <button type="submit" disabled={isFormSent}>Submit</button>
+      <button type="button" onClick={reset}>Reset</button>
+    </form>
+  );
+};
+```
+
+```tsx
+// 👍 correct - stores and events are separated by logical groups
+const Component = () => {
+  // All stores from the model
+  const [isFormSent, isLoading] = useUnit([
+    FormModel.$isFormSent,
+    FormModel.$isLoading,
+  ]);
+  
+  // All events from the model
+  const [submit, reset] = useUnit([
+    FormModel.submitForm,
+    FormModel.resetForm,
+  ]);
+  
+  return (
+    <form onSubmit={submit}>
+      {isLoading && <Spinner />}
+      <button type="submit" disabled={isFormSent}>Submit</button>
+      <button type="button" onClick={reset}>Reset</button>
+    </form>
+  );
+};
+```
+
 ## Why is this important?
 
 ### Performance
@@ -45,7 +276,7 @@ Each `useUnit` call creates its own subscription management overhead. Combining
 
 ### Code clarity
 
-A single `useUnit` call makes it easier to:
+A single `useUnit` call (or logically separated calls) makes it easier to:
 - See all dependencies at a glance
 - Understand component's reactive logic
 - Maintain and refactor code
@@ -69,7 +300,7 @@ const Component = () => {
 ```
 
 ```tsx
-// 👍 correct
+// 👍 correct - combined (default behavior)
 const Component = () => {
   const [userName, userAge, updateUser] = useUnit([
     $userName,
@@ -86,6 +317,21 @@ const Component = () => {
 };
 ```
 
+```tsx
+// 👍 also correct - separated (with enforceStoresAndEventsSeparation: true)
+const Component = () => {
+  const [userName, userAge] = useUnit([$userName, $userAge]);
+  const [updateUser] = useUnit([updateUserEvent]);
+  
+  return (
+    <div>
+      <p>{userName}, {userAge}</p>
+      <button onClick={updateUser}>Update</button>
+    </div>
+  );
+};
+```
+
 ## Object shape examples
 
 ```tsx
@@ -105,7 +351,7 @@ const Component = () => {
 ```
 
 ```tsx
-// 👍 correct
+// 👍 correct - combined (default behavior)
 const Component = () => {
   const { userName, userAge, updateUser } = useUnit({
     userName: $userName,
@@ -122,6 +368,24 @@ const Component = () => {
 };
 ```
 
+```tsx
+// 👍 also correct - separated (with enforceStoresAndEventsSeparation: true)
+const Component = () => {
+  const { userName, userAge } = useUnit({
+    userName: $userName,
+    userAge: $userAge,
+  });
+  const { updateUser } = useUnit({ updateUser: updateUserEvent });
+  
+  return (
+    <div>
+      <p>{userName}, {userAge}</p>
+      <button onClick={updateUser}>Update</button>
+    </div>
+  );
+};
+```
+
 ## Real-world example
 
 ```tsx
@@ -135,7 +399,7 @@ const $isLoading = createStore(false);
 const updateNameEvent = createEvent<string>();
 const updateEmailEvent = createEvent<string>();
 
-// 👎 incorrect - scattered useUnit calls
+// 👎 incorrect - scattered useUnit calls (default behavior)
 const UserProfile = () => {
   const [userName] = useUnit([$userName]);
   const [userEmail] = useUnit([$userEmail]);
@@ -157,7 +421,7 @@ const UserProfile = () => {
   );
 };
 
-// 👍 correct - single useUnit call
+// 👍 correct - single useUnit call (default behavior)
 const UserProfile = () => {
   const [userName, userEmail, isLoading, updateName, updateEmail] = useUnit([
     $userName,
@@ -180,26 +444,133 @@ const UserProfile = () => {
     </div>
   );
 };
+
+// 👍 also correct - separated stores and events 
+// (with allowSeparateStoresAndEvents: true or enforceStoresAndEventsSeparation: true)
+const UserProfile = () => {
+  const [userName, userEmail, isLoading] = useUnit([
+    $userName,
+    $userEmail,
+    $isLoading,
+  ]);
+  
+  const [updateName, updateEmail] = useUnit([
+    updateNameEvent,
+    updateEmailEvent,
+  ]);
+
+  return (
+    <div>
+      {isLoading ? (
+        <p>Loading...</p>
+      ) : (
+        <>
+          <input value={userName} onChange={(e) => updateName(e.target.value)} />
+          <input value={userEmail} onChange={(e) => updateEmail(e.target.value)} />
+        </>
+      )}
+    </div>
+  );
+};
 ```
 
 ## Auto-fix
 
-This rule provides an automatic fix that combines all `useUnit` calls into a single one. When you run ESLint with the `--fix` flag, it will automatically refactor your code:
+This rule provides automatic fixes based on the configuration:
+
+### Default behavior
+When you run ESLint with the `--fix` flag, it will combine all `useUnit` calls into a single one:
 
 ```bash
 eslint --fix your-file.tsx
 ```
 
+### With `enforceStoresAndEventsSeparation: true`
+The auto-fix will split mixed `useUnit` calls into separate calls for stores and events:
+
+```tsx
+// Before
+const [value, setValue] = useUnit([$store, event]);
+
+// After auto-fix
+const [value] = useUnit([$store]);
+const [setValue] = useUnit([event]);
+```
+
+### With both options enabled
+The auto-fix will both split mixed calls and combine multiple calls of the same type:
+
+```tsx
+// Before
+const [value1] = useUnit([$store1]);
+const [value2, handler] = useUnit([$store2, event1]);
+const [handler2] = useUnit([event2]);
+
+// After auto-fix
+const [value1, value2] = useUnit([$store1, $store2]);
+const [handler, handler2] = useUnit([event1, event2]);
+```
+
+## Configuration examples
+
+### Strict single call (default)
+```javascript
+// .eslintrc.js
+module.exports = {
+  rules: {
+    'effector/no-multiple-use-unit': 'warn'
+  }
+};
+```
+
+### Allow stores/events separation
+```javascript
+// .eslintrc.js
+module.exports = {
+  rules: {
+    'effector/no-multiple-use-unit': ['warn', {
+      allowSeparateStoresAndEvents: true
+    }]
+  }
+};
+```
+
+### Enforce stores/events separation
+```javascript
+// .eslintrc.js
+module.exports = {
+  rules: {
+    'effector/no-multiple-use-unit': ['warn', {
+      enforceStoresAndEventsSeparation: true
+    }]
+  }
+};
+```
+
+### Enforce separation and combine duplicates
+```javascript
+// .eslintrc.js
+module.exports = {
+  rules: {
+    'effector/no-multiple-use-unit': ['warn', {
+      allowSeparateStoresAndEvents: true,
+      enforceStoresAndEventsSeparation: true
+    }]
+  }
+};
+```
+
 ## When Not To Use It
 
-In rare cases, you might want to keep `useUnit` calls separate for logical grouping or conditional logic. In such cases, you can disable the rule:
+In rare cases, you might want to keep `useUnit` calls separate for specific reasons:
 
 ```tsx
 /* eslint-disable effector/no-multiple-use-unit */
 const Component = () => {
   const [userStore] = useUnit([$userStore]);
   
-  // Some complex logic here...
+  // Some complex logic that depends on userStore...
+  if (!userStore) return null;
   
   const [settingsStore] = useUnit([$settingsStore]);
   
@@ -208,8 +579,10 @@ const Component = () => {
 /* eslint-enable effector/no-multiple-use-unit */
 ```
 
-However, even in these cases, consider refactoring to use a single `useUnit` call for better performance and clarity.
+However, even in these cases, consider refactoring to use a single `useUnit` call (or enabling the appropriate options) for better performance and clarity.
 
-## Related Rules
+## References
 
-- [effector/use-unit-destructuring](./use-unit-destructuring.md) - Ensures proper destructuring of useUnit results
\ No newline at end of file
+- [useUnit API documentation](https://effector.dev/en/api/effector-react/useunit/)
+- [Effector React hooks best practices](https://effector.dev/en/api/effector-react/)
+```
diff --git a/rules/prefer-single-binding/prefer-single-binding.js b/rules/prefer-single-binding/prefer-single-binding.js
index 6f7d936..8d8824a 100644
--- a/rules/prefer-single-binding/prefer-single-binding.js
+++ b/rules/prefer-single-binding/prefer-single-binding.js
@@ -6,15 +6,35 @@ module.exports = {
             description: 'Recommend using a single useUnit call instead of multiple',
             category: 'Best Practices',
             recommended: true,
-            url: createLinkToRule("prefer-single-binding"),
+            url: createLinkToRule('prefer-single-binding'),
         },
         messages: {
             multipleUseUnit: 'Multiple useUnit calls detected. Consider combining them into a single call for better performance.',
+            mixedStoresAndEvents: 'useUnit call contains both stores and events. Consider separating them into different calls.',
         },
-        schema: [],
+        schema: [
+            {
+                type: 'object',
+                properties: {
+                    allowSeparateStoresAndEvents: {
+                        type: 'boolean',
+                        default: false,
+                    },
+                    enforceStoresAndEventsSeparation: {
+                        type: 'boolean',
+                        default: false,
+                    },
+                },
+                additionalProperties: false,
+            },
+        ],
         fixable: 'code',
     },
     create(context) {
+        const options = context.options[0] || {};
+        const allowSeparateStoresAndEvents = options.allowSeparateStoresAndEvents || false;
+        const enforceStoresAndEventsSeparation = options.enforceStoresAndEventsSeparation || false;
+
         return {
             'FunctionDeclaration, FunctionExpression, ArrowFunctionExpression'(node) {
                 const body = node.body.type === 'BlockStatement' ? node.body.body : null;
@@ -22,7 +42,7 @@ module.exports = {
 
                 const useUnitCalls = [];
 
-                // Ищем все вызовы useUnit в теле функции
+                // Find all useUnit calls in the function body
                 body.forEach((statement) => {
                     if (
                         statement.type === 'VariableDeclaration' &&
@@ -46,34 +66,360 @@ module.exports = {
                     }
                 });
 
-                // Если найдено более одного useUnit, сообщаем об ошибке
-                if (useUnitCalls.length > 1) {
-                    useUnitCalls.forEach((call, index) => {
-                        if (index > 0) {
+                // Check if enforceStoresAndEventsSeparation is enabled
+                if (enforceStoresAndEventsSeparation) {
+                    useUnitCalls.forEach((call) => {
+                        const mixedTypes = checkMixedTypes(call);
+                        if (mixedTypes) {
                             context.report({
                                 node: call.init,
-                                messageId: 'multipleUseUnit',
+                                messageId: 'mixedStoresAndEvents',
                                 fix(fixer) {
-                                    return generateFix(fixer, useUnitCalls, context);
+                                    return generateSeparationFix(fixer, call, mixedTypes, context);
                                 },
                             });
                         }
                     });
+
+                    // When enforceStoresAndEventsSeparation is true, don't check for multiple calls
+                    // because we want separate calls for stores and events
+                    return;
+                }
+
+                // If more than one useUnit call is found
+                if (useUnitCalls.length > 1) {
+                    // If the option to separate stores and events is enabled
+                    if (allowSeparateStoresAndEvents) {
+                        const groups = groupByType(useUnitCalls);
+
+                        // Check stores group
+                        if (groups.stores.length > 1) {
+                            reportMultipleCalls(context, groups.stores);
+                        }
+
+                        // Check events group
+                        if (groups.events.length > 1) {
+                            reportMultipleCalls(context, groups.events);
+                        }
+
+                        // Check unknown group (also merge if more than one)
+                        if (groups.unknown.length > 1) {
+                            reportMultipleCalls(context, groups.unknown);
+                        }
+                    } else {
+                        // Default behavior - all useUnit calls should be combined
+                        useUnitCalls.forEach((call, index) => {
+                            if (index > 0) {
+                                context.report({
+                                    node: call.init,
+                                    messageId: 'multipleUseUnit',
+                                    fix(fixer) {
+                                        return generateFix(fixer, useUnitCalls, context);
+                                    },
+                                });
+                            }
+                        });
+                    }
                 }
             },
         };
     },
 };
 
+// Check if a single useUnit call contains mixed types (stores and events)
+function checkMixedTypes(call) {
+    const argument = call.init.arguments[0];
+
+    if (!argument) return null;
+
+    // Only check array form
+    if (argument.type === 'ArrayExpression') {
+        const elements = argument.elements.filter(el => el !== null);
+        if (elements.length === 0) return null;
+
+        const types = elements.map((element, index) => ({
+            element,
+            type: getElementType(element),
+            index,
+        }));
+
+        const stores = types.filter(t => t.type === 'store');
+        const events = types.filter(t => t.type === 'event');
+
+        // If we have both stores and events, return the separation data
+        if (stores.length > 0 && events.length > 0) {
+            return { stores, events, allTypes: types };
+        }
+    }
+
+    // Only check object form
+    if (argument.type === 'ObjectExpression') {
+        const properties = argument.properties.filter(prop => prop.type === 'Property');
+        if (properties.length === 0) return null;
+
+        const types = properties.map((prop, index) => ({
+            property: prop,
+            type: prop.value ? getElementType(prop.value) : 'unknown',
+            index,
+        }));
+
+        const stores = types.filter(t => t.type === 'store');
+        const events = types.filter(t => t.type === 'event');
+
+        // If we have both stores and events, return the separation data
+        if (stores.length > 0 && events.length > 0) {
+            return { stores, events, allTypes: types, isObject: true };
+        }
+    }
+
+    return null;
+}
+
+// Generate fix to separate mixed stores and events into different useUnit calls
+function generateSeparationFix(fixer, call, mixedTypes, context) {
+    const sourceCode = context.getSourceCode ? context.getSourceCode() : context.sourceCode;
+
+    const { stores, events, isObject } = mixedTypes;
+
+    const fixes = [];
+
+    if (isObject) {
+        // Object form
+        const storeProps = stores.map(s => sourceCode.getText(s.property));
+        const eventProps = events.map(e => sourceCode.getText(e.property));
+
+        const storeKeys = stores.map(s => {
+            const prop = s.property;
+            if (prop.key && prop.key.type === 'Identifier') {
+                return prop.key.name;
+            }
+            return sourceCode.getText(prop.key);
+        });
+
+        const eventKeys = events.map(e => {
+            const prop = e.property;
+            if (prop.key && prop.key.type === 'Identifier') {
+                return prop.key.name;
+            }
+            return sourceCode.getText(prop.key);
+        });
+
+        // Get indentation
+        const statementStart = call.statement.range[0];
+        const lineStart = sourceCode.text.lastIndexOf('\n', statementStart - 1) + 1;
+        const indent = sourceCode.text.slice(lineStart, statementStart);
+
+        const storesCode = `const { ${storeKeys.join(', ')} } = useUnit({ ${storeProps.join(', ')} });`;
+        const eventsCode = `const { ${eventKeys.join(', ')} } = useUnit({ ${eventProps.join(', ')} });`;
+
+        const combinedCode = `${storesCode}\n${indent}${eventsCode}`;
+
+        fixes.push(fixer.replaceText(call.statement, combinedCode));
+    } else {
+        // Array form
+        const storeElements = stores.map(s => sourceCode.getText(s.element));
+        const eventElements = events.map(e => sourceCode.getText(e.element));
+
+        // Get destructured names
+        const destructured = call.id.type === 'ArrayPattern' ? call.id.elements : [];
+        const storeNames = stores.map(s => {
+            const el = destructured[s.index];
+            return el ? sourceCode.getText(el) : null;
+        }).filter(Boolean);
+
+        const eventNames = events.map(e => {
+            const el = destructured[e.index];
+            return el ? sourceCode.getText(el) : null;
+        }).filter(Boolean);
+
+        // Get indentation
+        const statementStart = call.statement.range[0];
+        const lineStart = sourceCode.text.lastIndexOf('\n', statementStart - 1) + 1;
+        const indent = sourceCode.text.slice(lineStart, statementStart);
+
+        const storesCode = `const [${storeNames.join(', ')}] = useUnit([${storeElements.join(', ')}]);`;
+        const eventsCode = `const [${eventNames.join(', ')}] = useUnit([${eventElements.join(', ')}]);`;
+
+        const combinedCode = `${storesCode}\n${indent}${eventsCode}`;
+
+        fixes.push(fixer.replaceText(call.statement, combinedCode));
+    }
+
+    return fixes;
+}
+
+// Determine the type of a single element
+function getElementType(element) {
+    if (!element) return 'unknown';
+
+    // Simple identifier: $store or event
+    if (element.type === 'Identifier') {
+        const name = element.name;
+        return name.startsWith('$') ? 'store' : 'event';
+    }
+
+    // MemberExpression: Model.$store or Model.event
+    if (element.type === 'MemberExpression') {
+        const property = element.property;
+
+        if (property && property.type === 'Identifier') {
+            const name = property.name;
+
+            // Check by property name
+            if (name.startsWith('$')) return 'store';
+
+            // Heuristics to determine type by name
+            const eventPatterns = [
+                /Event$/i,        // submitEvent, clickEvent
+                /Changed$/i,      // valueChanged, statusChanged
+                /Triggered$/i,    // actionTriggered
+                /Clicked$/i,      // buttonClicked
+                /Pressed$/i,      // keyPressed
+                /^on[A-Z]/,       // onClick, onSubmit
+                /^handle[A-Z]/,   // handleClick, handleSubmit
+                /^set[A-Z]/,      // setValue, setData
+                /^update[A-Z]/,   // updateValue, updateData
+                /^submit[A-Z]/,   // submitForm, submitData
+            ];
+
+            const storePatterns = [
+                /^is[A-Z]/,       // isLoading, isVisible
+                /^has[A-Z]/,      // hasError, hasData
+                /Store$/i,        // userStore, dataStore
+                /State$/i,        // appState, formState
+                /^data$/i,        // data
+                /^value$/i,       // value
+                /^items$/i,       // items
+            ];
+
+            // Check event patterns
+            if (eventPatterns.some(pattern => pattern.test(name))) {
+                return 'event';
+            }
+
+            // Check store patterns
+            if (storePatterns.some(pattern => pattern.test(name))) {
+                return 'store';
+            }
+
+            // Default for MemberExpression without explicit $ - consider it an event
+            // since methods are usually events
+            return 'event';
+        }
+    }
+
+    return 'unknown';
+}
+
+// Determine the unit type (store or event) by variable name
+function getUnitType(call) {
+    const argument = call.init.arguments[0];
+
+    if (!argument) return 'unknown';
+
+    // For arrays, look at elements
+    if (argument.type === 'ArrayExpression') {
+        const elements = argument.elements.filter(el => el !== null);
+        if (elements.length === 0) return 'unknown';
+
+        // Collect types of all elements
+        const types = elements.map(element => getElementType(element));
+
+        // Count each type
+        const storeCount = types.filter(t => t === 'store').length;
+        const eventCount = types.filter(t => t === 'event').length;
+        const unknownCount = types.filter(t => t === 'unknown').length;
+
+        // If all elements are of the same type
+        if (storeCount === types.length) return 'store';
+        if (eventCount === types.length) return 'event';
+        if (unknownCount === types.length) return 'unknown';
+
+        // If there's a mix, return the predominant type
+        if (storeCount > eventCount && storeCount > unknownCount) return 'store';
+        if (eventCount > storeCount && eventCount > unknownCount) return 'event';
+
+        // If unclear, return unknown
+        return 'unknown';
+    }
+
+    // For objects, look at properties
+    if (argument.type === 'ObjectExpression') {
+        const properties = argument.properties.filter(prop => prop.type === 'Property');
+        if (properties.length === 0) return 'unknown';
+
+        // Collect types of all properties
+        const types = properties.map(prop => {
+            if (prop.value) {
+                return getElementType(prop.value);
+            }
+            return 'unknown';
+        });
+
+        // Count each type
+        const storeCount = types.filter(t => t === 'store').length;
+        const eventCount = types.filter(t => t === 'event').length;
+        const unknownCount = types.filter(t => t === 'unknown').length;
+
+        // If all properties are of the same type
+        if (storeCount === types.length) return 'store';
+        if (eventCount === types.length) return 'event';
+        if (unknownCount === types.length) return 'unknown';
+
+        // If there's a mix, return the predominant type
+        if (storeCount > eventCount && storeCount > unknownCount) return 'store';
+        if (eventCount > storeCount && eventCount > unknownCount) return 'event';
+
+        return 'unknown';
+    }
+
+    return 'unknown';
+}
+
+// Group calls by type
+function groupByType(useUnitCalls) {
+    const stores = [];
+    const events = [];
+    const unknown = [];
+
+    useUnitCalls.forEach(call => {
+        const type = getUnitType(call);
+        if (type === 'store') {
+            stores.push(call);
+        } else if (type === 'event') {
+            events.push(call);
+        } else {
+            unknown.push(call);
+        }
+    });
+
+    return { stores, events, unknown };
+}
+
+// Report error for a group of calls
+function reportMultipleCalls(context, calls) {
+    calls.forEach((call, index) => {
+        if (index > 0) {
+            context.report({
+                node: call.init,
+                messageId: 'multipleUseUnit',
+                fix(fixer) {
+                    return generateFix(fixer, calls, context);
+                },
+            });
+        }
+    });
+}
+
 function generateFix(fixer, useUnitCalls, context) {
     const sourceCode = context.getSourceCode ? context.getSourceCode() : context.sourceCode;
 
-    // Определяем, используется ли объектная или массивная форма
+    // Determine if object or array form is used
     const firstArg = useUnitCalls[0].init.arguments[0];
     const isArrayForm = firstArg && firstArg.type === 'ArrayExpression';
     const isObjectForm = firstArg && firstArg.type === 'ObjectExpression';
 
-    // Если формы смешанные или неопределенные, не пытаемся исправить автоматически
+    // If forms are mixed or undefined, don't try to fix automatically
     const allSameForm = useUnitCalls.every((call) => {
         const arg = call.init.arguments[0];
         if (isArrayForm) return arg && arg.type === 'ArrayExpression';
@@ -86,7 +432,7 @@ function generateFix(fixer, useUnitCalls, context) {
     const fixes = [];
 
     if (isArrayForm) {
-        // Собираем все элементы массивов
+        // Collect all array elements
         const allElements = [];
         const allDestructured = [];
 
@@ -103,28 +449,27 @@ function generateFix(fixer, useUnitCalls, context) {
             }
         });
 
-        // Создаем объединенный вызов
+        // Create combined call
         const combinedCode = `const [${allDestructured.join(', ')}] = useUnit([${allElements.join(', ')}]);`;
 
-        // Заменяем первый вызов на объединенный
+        // Replace first call with combined one
         fixes.push(fixer.replaceText(useUnitCalls[0].statement, combinedCode));
 
-        // Удаляем остальные вызовы
+        // Remove remaining calls
         for (let i = 1; i < useUnitCalls.length; i++) {
             const statement = useUnitCalls[i].statement;
-            const token = sourceCode.getTokenBefore(statement);
 
-            // Находим начало строки (включая отступы)
+            // Find line start (including indentation)
             let startIndex = statement.range[0];
             const lineStart = sourceCode.text.lastIndexOf('\n', startIndex - 1) + 1;
             const textBeforeStatement = sourceCode.text.slice(lineStart, startIndex);
 
-            // Если перед statement только пробелы, удаляем всю строку
+            // If only spaces before statement, remove the entire line
             if (/^\s*$/.test(textBeforeStatement)) {
                 startIndex = lineStart;
             }
 
-            // Находим конец (включая перенос строки)
+            // Find end (including newline)
             const endIndex = statement.range[1];
             const nextChar = sourceCode.text[endIndex];
             const removeEnd = (nextChar === '\n' || nextChar === '\r') ? endIndex + 1 : endIndex;
@@ -132,7 +477,7 @@ function generateFix(fixer, useUnitCalls, context) {
             fixes.push(fixer.removeRange([startIndex, removeEnd]));
         }
     } else if (isObjectForm) {
-        // Собираем все свойства объектов
+        // Collect all object properties
         const allProperties = [];
         const allDestructuredProps = [];
 
@@ -149,27 +494,27 @@ function generateFix(fixer, useUnitCalls, context) {
             }
         });
 
-        // Создаем объединенный вызов
+        // Create combined call
         const combinedCode = `const { ${allDestructuredProps.join(', ')} } = useUnit({ ${allProperties.join(', ')} });`;
 
-        // Заменяем первый вызов на объединенный
+        // Replace first call with combined one
         fixes.push(fixer.replaceText(useUnitCalls[0].statement, combinedCode));
 
-        // Удаляем остальные вызовы
+        // Remove remaining calls
         for (let i = 1; i < useUnitCalls.length; i++) {
             const statement = useUnitCalls[i].statement;
 
-            // Находим начало строки (включая отступы)
+            // Find line start (including indentation)
             let startIndex = statement.range[0];
             const lineStart = sourceCode.text.lastIndexOf('\n', startIndex - 1) + 1;
             const textBeforeStatement = sourceCode.text.slice(lineStart, startIndex);
 
-            // Если перед statement только пробелы, удаляем всю строку
+            // If only spaces before statement, remove the entire line
             if (/^\s*$/.test(textBeforeStatement)) {
                 startIndex = lineStart;
             }
 
-            // Находим конец (включая перенос строки)
+            // Find end (including newline)
             const endIndex = statement.range[1];
             const nextChar = sourceCode.text[endIndex];
             const removeEnd = (nextChar === '\n' || nextChar === '\r') ? endIndex + 1 : endIndex;
diff --git a/rules/prefer-single-binding/prefer-single-binding.test.js b/rules/prefer-single-binding/prefer-single-binding.test.js
index 770da7f..70d8e0b 100644
--- a/rules/prefer-single-binding/prefer-single-binding.test.js
+++ b/rules/prefer-single-binding/prefer-single-binding.test.js
@@ -11,12 +11,35 @@ const ruleTester = new RuleTester({
 
 ruleTester.run("effector/prefer-single-binding.test", rule, {
     valid: [
+        // With enforceStoresAndEventsSeparation - already separated
+        {
+            code: `
+        import { useUnit } from "effector-react";
+        const Component = () => {
+          const [store] = useUnit([$store]);
+          const [event] = useUnit([event]);
+          return null;
+        };
+      `,
+            options: [{ enforceStoresAndEventsSeparation: true }],
+        },
+        {
+            code: `
+        import { useUnit } from "effector-react";
+        const Component = () => {
+          const [isFormSent] = useUnit([HelpFormModel.$isFormSent]);
+          const [sent, submit] = useUnit([HelpFormModel.sentFormChanged, HelpFormModel.submitHelpForm]);
+          return null;
+        };
+      `,
+            options: [{ allowSeparateStoresAndEvents: true }],
+        },
         // Once useUnit call - OK
         {
             code: `
         import { useUnit } from "effector-react";
         const Component = () => {
-          const [store, event] = useUnit([$store, $event]);
+          const [store, event] = useUnit([$store, event]);
           
           return null;
         };
@@ -27,7 +50,7 @@ ruleTester.run("effector/prefer-single-binding.test", rule, {
             code: `
         import { useUnit } from "effector-react";
         const Component = () => {
-          const { store, event } = useUnit({ store: $store, event: $event });
+          const { store, event } = useUnit({ store: $store, event: event });
           
           return null;
         };
@@ -38,7 +61,7 @@ ruleTester.run("effector/prefer-single-binding.test", rule, {
             code: `
         import { useUnit } from "effector-react";
         const store = useUnit([$store]);
-        const event = useUnit([$event]);
+        const event = useUnit([event]);
       `,
         },
     ],
@@ -50,7 +73,7 @@ ruleTester.run("effector/prefer-single-binding.test", rule, {
         import { useUnit } from "effector-react";
         const Component = () => {
           const [store] = useUnit([$store]);
-          const [event] = useUnit([$event]);
+          const [event] = useUnit([event]);
           
           return null;
         };
@@ -63,7 +86,7 @@ ruleTester.run("effector/prefer-single-binding.test", rule, {
             output: `
         import { useUnit } from "effector-react";
         const Component = () => {
-          const [store, event] = useUnit([$store, $event]);
+          const [store, event] = useUnit([$store, event]);
           
           return null;
         };
@@ -75,7 +98,7 @@ ruleTester.run("effector/prefer-single-binding.test", rule, {
         import { useUnit } from "effector-react";
         const Component = () => {
           const [store] = useUnit([$store]);
-          const [event] = useUnit([$event]);
+          const [event] = useUnit([event]);
           const [another] = useUnit([$another]);
           
           return null;
@@ -92,7 +115,7 @@ ruleTester.run("effector/prefer-single-binding.test", rule, {
             output: `
         import { useUnit } from "effector-react";
         const Component = () => {
-          const [store, event, another] = useUnit([$store, $event, $another]);
+          const [store, event, another] = useUnit([$store, event, $another]);
           
           return null;
         };
@@ -104,7 +127,7 @@ ruleTester.run("effector/prefer-single-binding.test", rule, {
         import { useUnit } from "effector-react";
         const Component = () => {
           const { store } = useUnit({ store: $store });
-          const { event } = useUnit({ event: $event });
+          const { event } = useUnit({ event: event });
           
           return null;
         };
@@ -117,7 +140,7 @@ ruleTester.run("effector/prefer-single-binding.test", rule, {
             output: `
         import { useUnit } from "effector-react";
         const Component = () => {
-          const { store, event } = useUnit({ store: $store, event: $event });
+          const { store, event } = useUnit({ store: $store, event: event });
           
           return null;
         };
@@ -142,11 +165,225 @@ ruleTester.run("effector/prefer-single-binding.test", rule, {
             output: `
         import { useUnit } from "effector-react";
         const Component = () => {
-          const [store1, store2, event1, event2] = useUnit([$store1, $store2, $event1, $event2]);
+          const [store1, store2, event1, event2] = useUnit([$store1, $store2, event1, event2]);
           
           return null;
         };
       `,
         },
+        {
+            code: `
+        import { useUnit } from "effector-react";
+        const Component = () => {
+          const [isFormSent] = useUnit([HelpFormModel.$isFormSent]);
+          const [sent] = useUnit([HelpFormModel.sentFormChanged]);
+          const [submit] = useUnit([HelpFormModel.submitHelpForm]);
+          return null;
+        };
+      `,
+            options: [{ allowSeparateStoresAndEvents: true }],
+            errors: [
+                {
+                    messageId: "multipleUseUnit",
+                },
+            ],
+            output: `
+        import { useUnit } from "effector-react";
+        const Component = () => {
+          const [isFormSent] = useUnit([HelpFormModel.$isFormSent]);
+          const [sent, submit] = useUnit([HelpFormModel.sentFormChanged, HelpFormModel.submitHelpForm]);
+          return null;
+        };
+      `,
+        },
+
+        // MemberExpression - два стора должны объединиться
+        {
+            code: `
+        import { useUnit } from "effector-react";
+        const Component = () => {
+          const [isFormSent] = useUnit([HelpFormModel.$isFormSent]);
+          const [isLoading] = useUnit([HelpFormModel.$isLoading]);
+          const [submit] = useUnit([HelpFormModel.submitHelpForm]);
+          return null;
+        };
+      `,
+            options: [{ allowSeparateStoresAndEvents: true }],
+            errors: [
+                {
+                    messageId: "multipleUseUnit",
+                },
+            ],
+            output: `
+        import { useUnit } from "effector-react";
+        const Component = () => {
+          const [isFormSent, isLoading] = useUnit([HelpFormModel.$isFormSent, HelpFormModel.$isLoading]);
+          const [submit] = useUnit([HelpFormModel.submitHelpForm]);
+          return null;
+        };
+      `,
+        },
+
+        // Смешанные паттерны именования
+        {
+            code: `
+        import { useUnit } from "effector-react";
+        const Component = () => {
+          const [isVisible] = useUnit([Model.isVisible]);
+          const [hasError] = useUnit([Model.hasError]);
+          const [onClick] = useUnit([Model.onClick]);
+          const [handleSubmit] = useUnit([Model.handleSubmit]);
+          return null;
+        };
+      `,
+            options: [{ allowSeparateStoresAndEvents: true }],
+            errors: [
+                {
+                    messageId: "multipleUseUnit",
+                },
+                {
+                    messageId: "multipleUseUnit",
+                },
+            ],
+            output: `
+        import { useUnit } from "effector-react";
+        const Component = () => {
+          const [isVisible, hasError] = useUnit([Model.isVisible, Model.hasError]);
+          const [onClick, handleSubmit] = useUnit([Model.onClick, Model.handleSubmit]);
+          return null;
+        };
+      `,
+        },
+
+        // Без опции - все должно объединиться
+        {
+            code: `
+        import { useUnit } from "effector-react";
+        const Component = () => {
+          const [isFormSent] = useUnit([HelpFormModel.$isFormSent]);
+          const [sent] = useUnit([HelpFormModel.sentFormChanged]);
+          const [submit] = useUnit([HelpFormModel.submitHelpForm]);
+          return null;
+        };
+      `,
+            errors: [
+                {
+                    messageId: "multipleUseUnit",
+                },
+                {
+                    messageId: "multipleUseUnit",
+                },
+            ],
+            output: `
+        import { useUnit } from "effector-react";
+        const Component = () => {
+          const [isFormSent, sent, submit] = useUnit([HelpFormModel.$isFormSent, HelpFormModel.sentFormChanged, HelpFormModel.submitHelpForm]);
+          return null;
+        };
+      `,
+        },
+        // enforceStoresAndEventsSeparation - mixed array
+        {
+            code: `
+        import { useUnit } from "effector-react";
+        const Component = () => {
+          const [value, setValue] = useUnit([$store, event]);
+          return null;
+        };
+      `,
+            options: [{ enforceStoresAndEventsSeparation: true }],
+            errors: [
+                {
+                    messageId: "mixedStoresAndEvents",
+                },
+            ],
+            output: `
+        import { useUnit } from "effector-react";
+        const Component = () => {
+          const [value] = useUnit([$store]);
+          const [setValue] = useUnit([event]);
+          return null;
+        };
+      `,
+        },
+
+        // enforceStoresAndEventsSeparation - mixed array with multiple items
+        {
+            code: `
+        import { useUnit } from "effector-react";
+        const Component = () => {
+          const [value1, value2, handler1, handler2] = useUnit([$store1, $store2, event1, event2]);
+          return null;
+        };
+      `,
+            options: [{ enforceStoresAndEventsSeparation: true }],
+            errors: [
+                {
+                    messageId: "mixedStoresAndEvents",
+                },
+            ],
+            output: `
+        import { useUnit } from "effector-react";
+        const Component = () => {
+          const [value1, value2] = useUnit([$store1, $store2]);
+          const [handler1, handler2] = useUnit([event1, event2]);
+          return null;
+        };
+      `,
+        },
+
+        // enforceStoresAndEventsSeparation - mixed object
+        {
+            code: `
+        import { useUnit } from "effector-react";
+        const Component = () => {
+          const { value, setValue } = useUnit({ value: $store, setValue: event });
+          return null;
+        };
+      `,
+            options: [{ enforceStoresAndEventsSeparation: true }],
+            errors: [
+                {
+                    messageId: "mixedStoresAndEvents",
+                },
+            ],
+            output: `
+        import { useUnit } from "effector-react";
+        const Component = () => {
+          const { value } = useUnit({ value: $store });
+          const { setValue } = useUnit({ setValue: event });
+          return null;
+        };
+      `,
+        },
+
+        // Real example with model
+        {
+            code: `
+        import { useUnit } from "effector-react";
+        const Component = () => {
+          const [isFormSent, submit, reset] = useUnit([
+            FormModel.$isFormSent,
+            FormModel.submitForm,
+            FormModel.resetForm,
+          ]);
+          return null;
+        };
+      `,
+            options: [{ enforceStoresAndEventsSeparation: true }],
+            errors: [
+                {
+                    messageId: "mixedStoresAndEvents",
+                },
+            ],
+            output: `
+        import { useUnit } from "effector-react";
+        const Component = () => {
+          const [isFormSent] = useUnit([FormModel.$isFormSent]);
+          const [submit, reset] = useUnit([FormModel.submitForm, FormModel.resetForm]);
+          return null;
+        };
+      `,
+        },
     ],
 });
\ No newline at end of file

From d009b75e057e3534e8ba4c41d8897850821ae4bb Mon Sep 17 00:00:00 2001
From: Ilya Olovyannikov <excaliburgyro@gmail.com>
Date: Sun, 14 Dec 2025 14:59:03 +0300
Subject: [PATCH 3/3] docs(prefer-single-binding): update docs

---
 .idea/workspace.xml                 |  4 +---
 docs/rules/prefer-single-binding.md | 20 ++++++++++----------
 2 files changed, 11 insertions(+), 13 deletions(-)

diff --git a/.idea/workspace.xml b/.idea/workspace.xml
index 1bb10ab..e641109 100644
--- a/.idea/workspace.xml
+++ b/.idea/workspace.xml
@@ -7,8 +7,6 @@
     <list default="true" id="698c7401-8c22-499e-8d8e-b2be1446ed6c" name="Changes" comment="">
       <change beforePath="$PROJECT_DIR$/.idea/workspace.xml" beforeDir="false" afterPath="$PROJECT_DIR$/.idea/workspace.xml" afterDir="false" />
       <change beforePath="$PROJECT_DIR$/docs/rules/prefer-single-binding.md" beforeDir="false" afterPath="$PROJECT_DIR$/docs/rules/prefer-single-binding.md" afterDir="false" />
-      <change beforePath="$PROJECT_DIR$/rules/prefer-single-binding/prefer-single-binding.js" beforeDir="false" afterPath="$PROJECT_DIR$/rules/prefer-single-binding/prefer-single-binding.js" afterDir="false" />
-      <change beforePath="$PROJECT_DIR$/rules/prefer-single-binding/prefer-single-binding.test.js" beforeDir="false" afterPath="$PROJECT_DIR$/rules/prefer-single-binding/prefer-single-binding.test.js" afterDir="false" />
     </list>
     <option name="SHOW_DIALOG" value="false" />
     <option name="HIGHLIGHT_CONFLICTS" value="true" />
@@ -124,7 +122,7 @@
       <option name="number" value="Default" />
       <option name="presentableId" value="Default" />
       <updated>1765274057645</updated>
-      <workItem from="1765274058707" duration="7034000" />
+      <workItem from="1765274058707" duration="7670000" />
     </task>
     <servers />
   </component>
diff --git a/docs/rules/prefer-single-binding.md b/docs/rules/prefer-single-binding.md
index 68c784e..8416b30 100644
--- a/docs/rules/prefer-single-binding.md
+++ b/docs/rules/prefer-single-binding.md
@@ -1,4 +1,4 @@
-# effector/no-multiple-use-unit
+# effector/prefer-single-binding
 
 [Related documentation](https://effector.dev/en/api/effector-react/useunit/)
 
@@ -61,7 +61,7 @@ The rule uses heuristics to determine whether a unit is a store or an event:
 // .eslintrc.js
 module.exports = {
   rules: {
-    'effector/no-multiple-use-unit': ['warn', {
+    'effector/prefer-single-binding': ['warn', {
       allowSeparateStoresAndEvents: true
     }]
   }
@@ -122,7 +122,7 @@ This is useful when you want to maintain clear logical separation between state
 // .eslintrc.js
 module.exports = {
   rules: {
-    'effector/no-multiple-use-unit': ['warn', {
+    'effector/prefer-single-binding': ['warn', {
       enforceStoresAndEventsSeparation: true
     }]
   }
@@ -180,7 +180,7 @@ You can use both options together to enforce a specific code style:
 // .eslintrc.js
 module.exports = {
   rules: {
-    'effector/no-multiple-use-unit': ['warn', {
+    'effector/prefer-single-binding': ['warn', {
       allowSeparateStoresAndEvents: true,
       enforceStoresAndEventsSeparation: true
     }]
@@ -518,7 +518,7 @@ const [handler, handler2] = useUnit([event1, event2]);
 // .eslintrc.js
 module.exports = {
   rules: {
-    'effector/no-multiple-use-unit': 'warn'
+    'effector/prefer-single-binding': 'warn'
   }
 };
 ```
@@ -528,7 +528,7 @@ module.exports = {
 // .eslintrc.js
 module.exports = {
   rules: {
-    'effector/no-multiple-use-unit': ['warn', {
+    'effector/prefer-single-binding': ['warn', {
       allowSeparateStoresAndEvents: true
     }]
   }
@@ -540,7 +540,7 @@ module.exports = {
 // .eslintrc.js
 module.exports = {
   rules: {
-    'effector/no-multiple-use-unit': ['warn', {
+    'effector/prefer-single-binding': ['warn', {
       enforceStoresAndEventsSeparation: true
     }]
   }
@@ -552,7 +552,7 @@ module.exports = {
 // .eslintrc.js
 module.exports = {
   rules: {
-    'effector/no-multiple-use-unit': ['warn', {
+    'effector/prefer-single-binding': ['warn', {
       allowSeparateStoresAndEvents: true,
       enforceStoresAndEventsSeparation: true
     }]
@@ -565,7 +565,7 @@ module.exports = {
 In rare cases, you might want to keep `useUnit` calls separate for specific reasons:
 
 ```tsx
-/* eslint-disable effector/no-multiple-use-unit */
+/* eslint-disable effector/prefer-single-binding */
 const Component = () => {
   const [userStore] = useUnit([$userStore]);
   
@@ -576,7 +576,7 @@ const Component = () => {
   
   return null;
 };
-/* eslint-enable effector/no-multiple-use-unit */
+/* eslint-enable effector/prefer-single-binding */
 ```
 
 However, even in these cases, consider refactoring to use a single `useUnit` call (or enabling the appropriate options) for better performance and clarity.