eslint-plugin-effector-units-order 0.0.2 → 0.0.3

package/README.md

@@ -90,23 +90,63 @@ export default [
 
 ## ⚙️ Options
 
-| Option                    | Type       | Default                                                 | Description                                      |
-| ------------------------- | ---------- | ------------------------------------------------------- | ------------------------------------------------ |
-| `order`                   | `string[]` | `['domain', 'events', 'effects', 'stores', 'computed']` | Defines the order of unit groups                 |
-| `emptyLinesBetweenGroups` | `number`   | `1`                                                     | Number of empty lines between groups (0-3)       |
-| `groups`                  | `object`   | See below                                               | Custom group definitions and factory mappings    |
-| `customFactories`         | `object`   | `{}`                                                    | Maps custom factory functions to specific groups |
-| `packages`                | `string[]` | `['effector', 'patronum']`                              | Packages to detect imports from                  |
+| Option                    | Type       | Default                                                 | Description                                                 |
+| ------------------------- | ---------- | ------------------------------------------------------- | ----------------------------------------------------------- |
+| `order`                   | `string[]` | `['domain', 'events', 'effects', 'stores', 'computed']` | Defines the order of unit groups                            |
+| `emptyLinesBetweenGroups` | `number`   | `1`                                                     | Number of empty lines between groups (0-3)                  |
+| `groups`                  | `object`   | See below                                               | Custom group definitions with factories and derived methods |
+| `customFactories`         | `object`   | `{}`                                                    | Maps custom factory functions to specific groups            |
+| `packages`                | `string[]` | `['effector', 'patronum']`                              | Packages to detect imports from                             |
+
+**Group Options:**
+
+Each group in `groups` can have:
+
+- `factories: string[]` — Factory functions that create units of this type (e.g., `['createStore']`)
+- `derivedMethods?: string[]` — Methods and properties that create derived units (e.g., `['stores.map', 'effects.pending']`)
 
 ### Default Groups
 
 ```javascript
 {
-  domain: { factories: ['createDomain'] },
-  events: { factories: ['createEvent'] },
-  effects: { factories: ['createEffect'] },
-  stores: { factories: ['createStore'] },
-  computed: { factories: ['combine', 'or'] },
+  domain: {
+    factories: ['createDomain']
+  },
+  events: {
+    factories: ['createEvent'],
+    derivedMethods: [
+      'events.prepend',
+      'events.map',
+      'events.filter',
+      'events.filterMap',
+      'stores.updates',
+      'stores.reinit',
+      'effects.done',
+      'effects.doneData',
+      'effects.fail',
+      'effects.failData',
+      'effects.finally'
+    ]
+  },
+  effects: {
+    factories: ['createEffect'],
+    derivedMethods: [
+      'effects.map',
+      'effects.prepend',
+      'effects.filterMap'
+    ]
+  },
+  stores: {
+    factories: ['createStore']
+  },
+  computed: {
+    factories: ['or', 'combine', 'merge', 'attach', 'forward'],
+    derivedMethods: [
+      'stores.map',
+      'effects.pending',
+      'effects.inFlight'
+    ]
+  }
 }
 ```
 
@@ -153,10 +193,10 @@ export const $user = userDomain.createStore(null);
 
 ### Computed Stores
 
-Computed stores using `combine()` and `or()` from patronum are properly recognized:
+Computed stores using `combine()`, `merge()`, `attach()`, `forward()`, and `or()` from patronum are properly recognized:
 
 ```typescript
-import { createStore, combine } from "effector";
+import { createStore, combine, merge, attach, forward } from "effector";
 import { or } from "patronum";
 
 export const $isLoading = createStore(false);
@@ -169,6 +209,65 @@ export const $state = combine({
 });
 ```
 
+### Derived Units
+
+The plugin automatically recognizes derived stores and events created from existing units:
+
+#### Derived Stores
+
+```typescript
+import { createStore, createEffect } from "effector";
+
+export const $products = createStore([]);
+export const fetchProductsFx = createEffect();
+
+export const $enrichedProducts = $products.map((products) =>
+  products.map((p) => ({ ...p, priceWithTax: p.price * 1.2 }))
+);
+export const $loading = fetchProductsFx.pending;
+export const $isLoading = $loading.map((loading) => loading);
+```
+
+#### Derived Events
+
+```typescript
+import { createEvent, createEffect, createStore } from "effector";
+
+export const userLogin = createEvent();
+export const fetchUserFx = createEffect();
+export const $user = createStore(null);
+
+export const loginWithEmail = userLogin.map((email) => ({ email })); /
+export const fetchSucceeded = fetchUserFx.done;
+export const fetchFailed = fetchUserFx.fail;
+export const userUpdated = $user.updates;
+export const resetUser = $user.reinit;
+```
+
+#### ❌ Incorrect Order (Auto-fixed)
+
+```typescript
+import { createStore, createEffect } from "effector";
+
+export const $loading = fetchProductsFx.pending;
+export const fetchProductsFx = createEffect();
+export const $products = createStore([]);
+export const $enriched = $products.map((p) => p);
+```
+
+#### ✅ Correct Order (After auto-fix)
+
+```typescript
+import { createStore, createEffect } from "effector";
+
+export const fetchProductsFx = createEffect();
+
+export const $products = createStore([]);
+
+export const $loading = fetchProductsFx.pending;
+export const $enriched = $products.map((p) => p);
+```
+
 ### Custom Factories
 
 You can map custom factory functions to specific groups:
@@ -219,6 +318,59 @@ export default [
 ];
 ```
 
+### Custom Derived Methods
+
+You can configure which methods and properties create derived units:
+
+```javascript
+// eslint.config.js
+export default [
+  {
+    plugins: { "effector-order": effectorOrder },
+    rules: {
+      "effector-order/keep-units-order": [
+        "error",
+        {
+          order: ["domain", "events", "effects", "stores", "computed"],
+          groups: {
+            events: {
+              factories: ["createEvent"],
+              // Configure which methods create derived events
+              derivedMethods: [
+                "events.map",
+                "events.prepend",
+                "effects.done",
+                "stores.updates",
+              ],
+            },
+            effects: {
+              factories: ["createEffect"],
+              derivedMethods: ["effects.map", "effects.prepend"],
+            },
+            computed: {
+              factories: ["combine", "merge", "attach", "forward"],
+              // Configure which methods create derived stores
+              derivedMethods: [
+                "stores.map",
+                "effects.pending",
+                "effects.inFlight",
+              ],
+            },
+          },
+        },
+      ],
+    },
+  },
+];
+```
+
+**Format for `derivedMethods`:**
+
+- `"unitType.methodName"` — for methods like `$store.map()`, `event.prepend()`
+- `"unitType.property"` — for properties like `effect.pending`, `store.updates`
+
+Where `unitType` is the type of the parent unit (`stores`, `events`, `effects`, `computed`), and the result will be categorized into the group that contains this `derivedMethod` in its configuration.
+
 ### No Empty Lines Between Groups
 
 You can disable empty lines between groups by setting `emptyLinesBetweenGroups` to `0`:

package/dist/package.json.js

@@ -1,3 +1,3 @@
 const name = "eslint-plugin-effector-units-order";
-const version = "0.0.1";
+const version = "0.0.2";
 export { name, version };

package/dist/rules/keep-units-order.js

@@ -17,19 +17,62 @@ const keepUnitsOrder = createESLintRule({
     return {
       "Program:exit": () => {
         let units = [];
+        let unitsMap = /* @__PURE__ */ new Map();
+        let processedNames = /* @__PURE__ */ new Set();
+        let isBaseUnitType = (type) =>
+          ["effects", "domain", "events", "stores"].includes(type);
         for (let potentialUnit of potentialUnits) {
+          if (!potentialUnit.name || processedNames.has(potentialUnit.name)) {
+            continue;
+          }
+          if (potentialUnit.node.init?.type !== "CallExpression") {
+            continue;
+          }
+          let unitType = detectUnitType({
+            importMap: importedFromEffector,
+            node: potentialUnit.node.init,
+            unitsMap: /* @__PURE__ */ new Map(),
+            // Empty for base units detection
+            domainMap,
+            config,
+          });
+          if (!unitType || !isBaseUnitType(unitType)) {
+            continue;
+          }
+          unitsMap.set(potentialUnit.name, unitType);
+          processedNames.add(potentialUnit.name);
+          units.push({
+            statement: potentialUnit.statement,
+            node: potentialUnit.node,
+            line: potentialUnit.line,
+            name: potentialUnit.name,
+            type: unitType,
+          });
+        }
+        for (let potentialUnit of potentialUnits) {
+          if (!potentialUnit.name || processedNames.has(potentialUnit.name)) {
+            continue;
+          }
           if (potentialUnit.node.init?.type !== "CallExpression") {
             continue;
           }
+          let { callee } = potentialUnit.node.init;
+          if (callee.type !== "Identifier") {
+            continue;
+          }
           let unitType = detectUnitType({
             importMap: importedFromEffector,
             node: potentialUnit.node.init,
             domainMap,
+            unitsMap,
+            // Now we have base units
             config,
           });
-          if (!unitType) {
+          if (!unitType || unitType !== "computed") {
             continue;
           }
+          unitsMap.set(potentialUnit.name, unitType);
+          processedNames.add(potentialUnit.name);
           units.push({
             statement: potentialUnit.statement,
             node: potentialUnit.node,
@@ -38,6 +81,52 @@ const keepUnitsOrder = createESLintRule({
             type: unitType,
           });
         }
+        for (let potentialUnit of potentialUnits) {
+          if (!potentialUnit.name || processedNames.has(potentialUnit.name)) {
+            continue;
+          }
+          if (potentialUnit.node.init?.type === "CallExpression") {
+            let unitType = detectUnitType({
+              importMap: importedFromEffector,
+              node: potentialUnit.node.init,
+              domainMap,
+              unitsMap,
+              config,
+            });
+            if (unitType) {
+              unitsMap.set(potentialUnit.name, unitType);
+              processedNames.add(potentialUnit.name);
+              units.push({
+                statement: potentialUnit.statement,
+                node: potentialUnit.node,
+                line: potentialUnit.line,
+                name: potentialUnit.name,
+                type: unitType,
+              });
+              continue;
+            }
+          }
+          if (potentialUnit.node.init?.type === "MemberExpression") {
+            let unitType = detectUnitType({
+              importMap: importedFromEffector,
+              node: potentialUnit.node.init,
+              domainMap,
+              unitsMap,
+              config,
+            });
+            if (unitType) {
+              unitsMap.set(potentialUnit.name, unitType);
+              processedNames.add(potentialUnit.name);
+              units.push({
+                statement: potentialUnit.statement,
+                node: potentialUnit.node,
+                line: potentialUnit.line,
+                name: potentialUnit.name,
+                type: unitType,
+              });
+            }
+          }
+        }
         let usedDomains = /* @__PURE__ */ new Set();
         for (let unit of units) {
           if (
@@ -55,6 +144,7 @@ const keepUnitsOrder = createESLintRule({
             unit.isUsedByOthers = usedDomains.has(unit.name);
           }
         }
+        units.sort((a, b) => a.line - b.line);
         let violations = validateOrder({ config, units });
         if (violations.length === 0) {
           return;
@@ -80,10 +170,16 @@ const keepUnitsOrder = createESLintRule({
       },
       VariableDeclaration: (declarationNode) => {
         for (let node of declarationNode.declarations) {
-          if (node.init?.type !== "CallExpression") {
+          if (
+            node.init?.type !== "CallExpression" &&
+            node.init?.type !== "MemberExpression"
+          ) {
             continue;
           }
-          if (node.init.callee.type === "Identifier") {
+          if (
+            node.init.type === "CallExpression" &&
+            node.init.callee.type === "Identifier"
+          ) {
             let functionName = node.init.callee.name;
             if (importedFromEffector.has(functionName)) {
               for (let [groupName, groupOptions] of Object.entries(

package/dist/types/config.d.ts

@@ -17,7 +17,6 @@ export interface EffectorOrderOptions {
   /**
    * Number of empty lines between groups.
    * @default 1
-   * @minimum 0
    */
   emptyLinesBetweenGroups?: number;
   /**
@@ -36,6 +35,12 @@ export interface EffectorOrderOptions {
  * Options for a unit group.
  */
 export interface GroupOptions {
+  /**
+   * Methods and properties that create units of this type.
+   * Format: "unitType.methodOrProperty".
+   * @example ['stores.map', 'effects.pending', 'computed.restore']
+   */
+  derivedMethods?: string[];
   /**
    * List of factories that belong to this group.
    * @example ['authFactory', 'apiFactory']

package/dist/utils/detect-unit-type.d.ts

@@ -12,19 +12,26 @@ interface Parameters {
    * Map of imported names to package names.
    */
   importMap: Map<string, string>;
-  node: TSESTree.CallExpression;
+  node: TSESTree.CallExpression | TSESTree.MemberExpression;
   /**
    * Normalized configuration with groups and factories.
    */
   config: NormalizedConfig;
+  /**
+   * Map of unit names to their types
+   * Key: unit variable name (e.g., '$store', 'event', 'effectFx')
+   * Value: unit type (e.g., 'stores', 'events', 'effects')
+   */
+  unitsMap: Map<string, UnitType>;
 }
 /**
- * Detects the unit type from a CallExpression node.
+ * Detects the unit type from a CallExpression or MemberExpression node.
  *
  * Handles:
  * - Direct calls: `createEvent()`, `createStore()`, etc.
  * - Domain calls: `domain.createEvent()`, `domain.createStore()`, etc.
- * - Computed: `or()`, `combine()`.
+ * - Computed: `or()`, `combine()`, `merge()`, `attach()`, `forward()`, `restore()`.
+ * - Derived units: `$store.map()`, `effect.pending`, `event.map()`, etc.
  *
  * @param params - Parameters for detection.
  * @returns UnitType if detected, null otherwise.
@@ -34,5 +41,6 @@ export declare function detectUnitType({
   domainMap,
   config,
   node,
+  unitsMap,
 }: Parameters): UnitType | null;
 export {};

package/dist/utils/detect-unit-type.js

@@ -1,32 +1,66 @@
-function detectUnitType({ importMap, domainMap, config, node }) {
-  let { callee } = node;
-  if (callee.type === "Identifier") {
-    let functionName = callee.name;
-    if (!importMap.has(functionName)) {
+function detectUnitType({ importMap, domainMap, config, node, unitsMap }) {
+  if (node.type === "CallExpression") {
+    let { callee } = node;
+    if (callee.type === "Identifier") {
+      let functionName = callee.name;
+      if (!importMap.has(functionName)) {
+        return null;
+      }
+      for (let [groupName, groupOptions] of Object.entries(config.groups)) {
+        if (groupOptions.factories.includes(functionName)) {
+          return groupName;
+        }
+      }
       return null;
     }
-    for (let [groupName, groupOptions] of Object.entries(config.groups)) {
-      if (groupOptions.factories.includes(functionName)) {
-        return groupName;
+    if (callee.type === "MemberExpression") {
+      let { property, object } = callee;
+      if (object.type !== "Identifier") {
+        return null;
       }
+      if (property.type !== "Identifier") {
+        return null;
+      }
+      let objectName = object.name;
+      let methodName = property.name;
+      if (domainMap.get(objectName)) {
+        for (let [groupName, groupOptions] of Object.entries(config.groups)) {
+          if (groupOptions.factories.includes(methodName)) {
+            return groupName;
+          }
+        }
+        return null;
+      }
+      let unitType = unitsMap.get(objectName);
+      if (unitType) {
+        let derivedMethodKey = `${unitType}.${methodName}`;
+        for (let [groupName, groupOptions] of Object.entries(config.groups)) {
+          if (groupOptions.derivedMethods?.includes(derivedMethodKey)) {
+            return groupName;
+          }
+        }
+      }
+      return null;
     }
     return null;
   }
-  if (callee.type === "MemberExpression") {
-    let { property, object } = callee;
+  if (node.type === "MemberExpression") {
+    let { property, object } = node;
     if (object.type !== "Identifier") {
       return null;
     }
     if (property.type !== "Identifier") {
       return null;
     }
-    let domainName = object.name;
-    let factoryName = property.name;
-    if (!domainMap.get(domainName)) {
+    let unitName = object.name;
+    let propertyName = property.name;
+    let unitType = unitsMap.get(unitName);
+    if (!unitType) {
       return null;
     }
+    let derivedMethodKey = `${unitType}.${propertyName}`;
     for (let [groupName, groupOptions] of Object.entries(config.groups)) {
-      if (groupOptions.factories.includes(factoryName)) {
+      if (groupOptions.derivedMethods?.includes(derivedMethodKey)) {
         return groupName;
       }
     }

package/dist/utils/normalize-config.js

@@ -1,15 +1,62 @@
 const DEFAULT_GROUPS = {
   computed: {
-    factories: ["or", "combine"],
+    factories: ["or", "combine", "merge", "attach", "forward"],
+    derivedMethods: [
+      // Derived stores (идут после базовых stores)
+      "stores.map",
+      // $store.map() → computed store
+      "effects.pending",
+      // effect.pending → computed store
+      "effects.inFlight",
+      // effect.inFlight → computed store
+      // Derived events на computed тоже идут в computed
+      "computed.map",
+      // merge([...]).map() → computed
+    ],
   },
   effects: {
     factories: ["createEffect"],
+    derivedMethods: [
+      "effects.map",
+      // effect.map() → effect
+      "effects.prepend",
+      // effect.prepend() → effect
+      "effects.filterMap",
+      // effect.filterMap() → effect
+    ],
   },
   domain: {
     factories: ["createDomain"],
   },
   events: {
     factories: ["createEvent"],
+    derivedMethods: [
+      // Event Methods, которые создают derived events
+      "events.prepend",
+      // event.prepend() → event
+      "events.map",
+      // event.map() → event
+      "events.filter",
+      // event.filter() → event
+      "events.filterMap",
+      // event.filterMap() → event
+      // Store Properties, которые возвращают events
+      "stores.updates",
+      // store.updates → event
+      "stores.reinit",
+      // store.reinit → event
+      // Effect Properties, которые возвращают events
+      "effects.done",
+      // effect.done → event
+      "effects.doneData",
+      // effect.doneData → event
+      "effects.fail",
+      // effect.fail → event
+      "effects.failData",
+      // effect.failData → event
+      "effects.finally",
+      // effect.finally → event
+    ],
   },
   stores: {
     factories: ["createStore"],
@@ -33,6 +80,10 @@ function normalizeConfig(options = {}) {
           ...(groups[groupName]?.factories ?? []),
           ...groupOptions.factories,
         ],
+        derivedMethods: [
+          ...(groups[groupName]?.derivedMethods ?? []),
+          ...(groupOptions.derivedMethods ?? []),
+        ],
       };
     }
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eslint-plugin-effector-units-order",
-  "version": "0.0.2",
+  "version": "0.0.3",
   "description": "ESLint plugin for enforcing consistent ordering of Effector units",
   "keywords": [
     "eslint",