eslint-plugin-effector 0.16.0 → 0.17.0

package/package.json

@@ -1,32 +1,86 @@
 {
   "name": "eslint-plugin-effector",
-  "version": "0.16.0",
+  "version": "0.17.0",
   "description": "Enforcing best practices for Effector",
   "keywords": [
     "eslint",
-    "eslint-plugin",
     "eslintplugin",
+    "eslint-plugin",
     "effector"
   ],
-  "repository": "effector/eslint-plugin",
-  "main": "index.js",
-  "author": "Igor Kamyshev <igor@kamyshev.me>",
+  "homepage": "https://eslint.effector.dev",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/effector/eslint-plugin"
+  },
   "license": "MIT",
-  "packageManager": "pnpm@8.10.5",
-  "publishConfig": {
-    "access": "public"
+  "author": "Igor Kamyshev <igor@kamyshev.me>",
+  "contributors": [
+    {
+      "name": "Mikhail Kireev",
+      "url": "https://github.com/kireevmp"
+    }
+  ],
+  "type": "module",
+  "exports": {
+    ".": {
+      "import": {
+        "types": "./dist/index.d.mts",
+        "default": "./dist/index.mjs"
+      },
+      "require": {
+        "types": "./dist/index.d.cts",
+        "default": "./dist/index.cjs"
+      }
+    },
+    "./package.json": "./package.json"
   },
-  "engines": {
-    "node": "^16 || ^17 || ^18 || ^19 || ^20 || ^21 || ^22"
+  "main": "dist/index.cjs",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.cts",
+  "files": [
+    "dist"
+  ],
+  "dependencies": {
+    "@typescript-eslint/type-utils": "^8.52.0",
+    "@typescript-eslint/utils": "^8.52.0",
+    "esquery": "^1.7.0"
+  },
+  "devDependencies": {
+    "@eslint/js": "^9.39.2",
+    "@types/esquery": "^1.5.4",
+    "@types/estree": "^1.0.8",
+    "@types/node": "^25.0.6",
+    "@types/react": "^19.2.8",
+    "@typescript-eslint/rule-tester": "^8.52.0",
+    "@vitest/coverage-v8": "^4.0.16",
+    "effector": "^23.4.4",
+    "effector-react": "^23.3.0",
+    "eslint": "^9.39.2",
+    "eslint-config-prettier": "^10.1.8",
+    "eslint-import-resolver-typescript": "^4.4.4",
+    "eslint-plugin-import-x": "^4.16.1",
+    "eslint-plugin-prettier": "^5.5.4",
+    "prettier": "^3.7.4",
+    "prettier-plugin-embed": "^0.5.1",
+    "tsdown": "0.19.0",
+    "typescript": "^5.9.3",
+    "typescript-eslint": "^8.52.0",
+    "vitepress": "2.0.0-alpha.15",
+    "vitest": "^4.0.16"
   },
   "peerDependencies": {
-    "effector": "^23",
-    "eslint": "^8.57.0 || ^9.0.0"
+    "eslint": "^8.57.0 || ^9.0.0",
+    "typescript": ">=5.0.0"
   },
-  "dependencies": {
-    "prettier": "^2.3.2"
+  "engines": {
+    "node": "^20.9.0 || >=21.1.0"
   },
-  "nano-staged": {
-    "*.{js,ts,md}": "prettier --write"
+  "scripts": {
+    "build": "tsdown",
+    "docs:build": "vitepress build docs",
+    "docs:dev": "vitepress dev docs",
+    "lint": "eslint",
+    "test": "vitest run"
   }
-}
+}

package/.nvmrc

@@ -1 +0,0 @@
-18.12

package/config/future.js

@@ -1,7 +0,0 @@
-module.exports = {
-  rules: {
-    "effector/prefer-sample-over-forward-with-mapping": "off",
-    "effector/no-forward": "warn",
-    "effector/no-guard": "warn",
-  },
-};

package/config/patronum.js

@@ -1,5 +0,0 @@
-module.exports = {
-  rules: {
-    "effector/no-patronum-debug": "error",
-  },
-};

package/config/react.js

@@ -1,7 +0,0 @@
-module.exports = {
-  rules: {
-    "effector/enforce-gate-naming-convention": "error",
-    "effector/mandatory-scope-binding": "error",
-    "effector/prefer-useUnit": "warn",
-  },
-};

package/config/recommended.js

@@ -1,15 +0,0 @@
-module.exports = {
-  rules: {
-    "effector/enforce-store-naming-convention": "error",
-    "effector/enforce-effect-naming-convention": "error",
-    "effector/no-getState": "error",
-    "effector/no-useless-methods": "error",
-    "effector/no-unnecessary-duplication": "warn",
-    "effector/prefer-sample-over-forward-with-mapping": "warn",
-    "effector/no-ambiguity-target": "warn",
-    "effector/no-watch": "warn",
-    "effector/no-unnecessary-combination": "warn",
-    "effector/no-duplicate-on": "error",
-    "effector/keep-options-order": "warn",
-  },
-};

package/config/scope.js

@@ -1,6 +0,0 @@
-module.exports = {
-  rules: {
-    "effector/strict-effect-handlers": "error",
-    "effector/require-pickup-in-persist": "error",
-  },
-};

package/index.js

@@ -1,31 +0,0 @@
-module.exports = {
-  rules: {
-    "enforce-store-naming-convention": require("./rules/enforce-store-naming-convention/enforce-store-naming-convention"),
-    "enforce-effect-naming-convention": require("./rules/enforce-effect-naming-convention/enforce-effect-naming-convention"),
-    "no-getState": require("./rules/no-getState/no-getState"),
-    "no-unnecessary-duplication": require("./rules/no-unnecessary-duplication/no-unnecessary-duplication"),
-    "prefer-sample-over-forward-with-mapping": require("./rules/prefer-sample-over-forward-with-mapping/prefer-sample-over-forward-with-mapping"),
-    "no-duplicate-clock-or-source-array-values": require("./rules/no-duplicate-clock-or-source-array-values/no-duplicate-clock-or-source-array-values"),
-    "no-useless-methods": require("./rules/no-useless-methods/no-useless-methods"),
-    "no-ambiguity-target": require("./rules/no-ambiguity-target/no-ambiguity-target"),
-    "no-watch": require("./rules/no-watch/no-watch"),
-    "no-unnecessary-combination": require("./rules/no-unnecessary-combination/no-unnecessary-combination"),
-    "no-duplicate-on": require("./rules/no-duplicate-on/no-duplicate-on"),
-    "strict-effect-handlers": require("./rules/strict-effect-handlers/strict-effect-handlers"),
-    "enforce-gate-naming-convention": require("./rules/enforce-gate-naming-convention/enforce-gate-naming-convention"),
-    "keep-options-order": require("./rules/keep-options-order/keep-options-order"),
-    "no-forward": require("./rules/no-forward/no-forward"),
-    "no-guard": require("./rules/no-guard/no-guard"),
-    "mandatory-scope-binding": require("./rules/mandatory-scope-binding/mandatory-scope-binding"),
-    "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"),
-  },
-  configs: {
-    recommended: require("./config/recommended"),
-    scope: require("./config/scope"),
-    react: require("./config/react"),
-    future: require("./config/future"),
-    patronum: require("./config/patronum"),
-  },
-};

package/rules/enforce-effect-naming-convention/enforce-effect-naming-convention.js

@@ -1,143 +0,0 @@
-const { ESLintUtils } = require("@typescript-eslint/utils");
-
-const { extractImportedFrom } = require("../../utils/extract-imported-from");
-const { createLinkToRule } = require("../../utils/create-link-to-rule");
-const { nodeTypeIs } = require("../../utils/node-type-is");
-const { namingOf } = require("../../utils/naming");
-
-module.exports = {
-  meta: {
-    type: "problem",
-    docs: {
-      description:
-        "Enforce Fx as a suffix for any effect created by Effector methods",
-      category: "Naming",
-      recommended: true,
-      url: createLinkToRule("enforce-effect-naming-convention"),
-    },
-    messages: {
-      invalidName:
-        'Effect "{{ effectName }}" should be named with suffix, rename it to "{{ effectName }}Fx"',
-      renameEffect: 'Rename "{{ effectName }}" to "{{ effectName }}Fx"',
-    },
-    schema: [],
-    hasSuggestions: true,
-  },
-  create(context) {
-    let parserServices;
-    try {
-      parserServices = ESLintUtils.getParserServices(context);
-    } catch (err) {
-      // no types information
-    }
-    // TypeScript-way
-    if (parserServices?.program) {
-      return {
-        VariableDeclarator(node) {
-          const isEffectorEffect = nodeTypeIs.effect({
-            node,
-            context,
-          });
-
-          if (!isEffectorEffect) {
-            return;
-          }
-
-          const effectName = node.id.name;
-
-          if (namingOf.effect.isInvalid({ name: effectName })) {
-            reportEffectNameConventionViolation({ context, node, effectName });
-          }
-        },
-      };
-    }
-
-    // JavaScript-way
-    const importedFromEffector = new Map();
-    return {
-      ImportDeclaration(node) {
-        extractImportedFrom({
-          importMap: importedFromEffector,
-          node,
-          packageName: "effector",
-        });
-      },
-      CallExpression(node) {
-        // Effect creation with method
-        const EFFECT_CREATION_METHODS = ["createEffect", "attach"];
-        for (const method of EFFECT_CREATION_METHODS) {
-          const localMethod = importedFromEffector.get(method);
-          if (!localMethod) {
-            continue;
-          }
-
-          const isEffectorEffectCreation = node.callee.name === localMethod;
-          if (!isEffectorEffectCreation) {
-            continue;
-          }
-
-          const resultSavedInVariable =
-            node.parent.type === "VariableDeclarator";
-          if (!resultSavedInVariable) {
-            continue;
-          }
-
-          const effectName = node.parent.id.name;
-          if (namingOf.effect.isValid({ name: effectName })) {
-            continue;
-          }
-
-          reportEffectNameConventionViolation({
-            context,
-            node: node.parent,
-            effectName,
-          });
-          return;
-        }
-
-        // Effect creation in domain
-        const STORE_IN_DOMAIN_CREATION_METHODS = ["createEffect", "effect"];
-        if (
-          STORE_IN_DOMAIN_CREATION_METHODS.includes(node.callee?.property?.name)
-        ) {
-          const resultSavedInVariable =
-            node.parent.type === "VariableDeclarator";
-          if (!resultSavedInVariable) {
-            return;
-          }
-
-          const effectName = node.parent.id.name;
-          if (namingOf.effect.isValid({ name: effectName })) {
-            return;
-          }
-
-          reportEffectNameConventionViolation({
-            context,
-            node: node.parent,
-            effectName,
-          });
-          return;
-        }
-      },
-    };
-  },
-};
-
-function reportEffectNameConventionViolation({ context, node, effectName }) {
-  context.report({
-    node,
-    messageId: "invalidName",
-    data: {
-      effectName,
-    },
-    suggest: [
-      {
-        messageId: "renameEffect",
-        data: { effectName },
-        fix(fixer) {
-          return fixer.insertTextAfterRange(node.id.range, "Fx");
-        },
-      },
-    ],
-  });
-}

package/rules/enforce-gate-naming-convention/enforce-gate-naming-convention.js

@@ -1,122 +0,0 @@
-const { ESLintUtils } = require("@typescript-eslint/utils");
-
-const { extractImportedFrom } = require("../../utils/extract-imported-from");
-const { nodeTypeIs } = require("../../utils/node-type-is");
-const { createLinkToRule } = require("../../utils/create-link-to-rule");
-const { namingOf } = require("../../utils/naming");
-
-module.exports = {
-  meta: {
-    type: "problem",
-    docs: {
-      description: "Enforce first capital letter for gate naming",
-      category: "Naming",
-      recommended: true,
-      url: createLinkToRule("enforce-gate-naming-convention"),
-    },
-    messages: {
-      invalidName:
-        'Gate "{{ gateName }}" should be named with first capital letter, rename it to "{{ correctedGateName }}"',
-      renameGate: 'Rename "{{ gateName }}" to "{{ correctedGateName }}"',
-    },
-    schema: [],
-    hasSuggestions: true,
-  },
-  create(context) {
-    let parserServices;
-    try {
-      parserServices = ESLintUtils.getParserServices(context);
-    } catch (err) {
-      // no types information
-    }
-
-    // TypeScript-way
-    if (parserServices?.program) {
-      return {
-        VariableDeclarator(node) {
-          const isEffectorGate = nodeTypeIs.gate({
-            node,
-            context,
-          });
-
-          if (!isEffectorGate) {
-            return;
-          }
-
-          const gateName = node.id.name;
-
-          if (namingOf.gate.isInvalid({ name: gateName })) {
-            reportGateNameConventionViolation({ context, node, gateName });
-          }
-        },
-      };
-    }
-
-    // JavaScript-way
-    const importedFromEffectorReact = new Map();
-    return {
-      ImportDeclaration(node) {
-        extractImportedFrom({
-          importMap: importedFromEffectorReact,
-          node,
-          packageName: "effector-react",
-        });
-      },
-      CallExpression(node) {
-        // Effect creation with method
-        const GATE_CREATION_METHODS = ["createGate"];
-        for (const method of GATE_CREATION_METHODS) {
-          const localMethod = importedFromEffectorReact.get(method);
-          if (!localMethod) {
-            continue;
-          }
-
-          const isEffectorGateCreation = node.callee.name === localMethod;
-          if (!isEffectorGateCreation) {
-            continue;
-          }
-
-          const resultSavedInVariable =
-            node.parent.type === "VariableDeclarator";
-          if (!resultSavedInVariable) {
-            continue;
-          }
-
-          const gateName = node.parent.id.name;
-          if (namingOf.gate.isValid({ name: gateName })) {
-            continue;
-          }
-
-          reportGateNameConventionViolation({
-            context,
-            node: node.parent,
-            gateName,
-          });
-        }
-      },
-    };
-  },
-};
-
-function reportGateNameConventionViolation({ context, node, gateName }) {
-  const [firstChar, ...restChars] = gateName.split("");
-  const correctedGateName = [firstChar.toUpperCase(), ...restChars].join("");
-
-  context.report({
-    node,
-    messageId: "invalidName",
-    data: {
-      gateName,
-      correctedGateName,
-    },
-    suggest: [
-      {
-        messageId: "renameGate",
-        data: { gateName, correctedGateName },
-        fix(fixer) {
-          return fixer.replaceTextRange(node.id.range, correctedGateName);
-        },
-      },
-    ],
-  });
-}

package/rules/enforce-store-naming-convention/enforce-store-naming-convention.js

@@ -1,205 +0,0 @@
-const { ESLintUtils } = require("@typescript-eslint/utils");
-
-const { extractImportedFrom } = require("../../utils/extract-imported-from");
-const { namingOf } = require("../../utils/naming");
-const {
-  validateStoreNameConvention,
-} = require("../../utils/validate-store-name-convention");
-const {
-  getStoreNameConvention,
-} = require("../../utils/get-store-name-convention");
-const {
-  getCorrectedStoreName,
-} = require("../../utils/get-corrected-store-name");
-const { createLinkToRule } = require("../../utils/create-link-to-rule");
-const { nodeTypeIs } = require("../../utils/node-type-is");
-const { traverseParentByType } = require("../../utils/traverse-parent-by-type");
-
-module.exports = {
-  meta: {
-    type: "problem",
-    docs: {
-      description:
-        "Enforce $ as a prefix or postfix for any store created by Effector methods",
-      category: "Naming",
-      recommended: true,
-      url: createLinkToRule("enforce-store-naming-convention"),
-    },
-    messages: {
-      invalidName:
-        'Store "{{ storeName }}" should be named with {{ storeNameConvention }}, rename it to "{{ correctedStoreName }}"',
-      renameStore: 'Rename "{{ storeName }}" to "{{ correctedStoreName }}"',
-    },
-    schema: [],
-    hasSuggestions: true,
-  },
-  create(context) {
-    let parserServices;
-    try {
-      parserServices = ESLintUtils.getParserServices(context);
-    } catch (err) {
-      // no types information
-    }
-
-    validateStoreNameConvention(context);
-
-    // TypeScript-way
-    if (parserServices?.program) {
-      return {
-        VariableDeclarator(node) {
-          const isEffectorStore = nodeTypeIs.store({
-            node,
-            context,
-          });
-
-          if (!isEffectorStore) {
-            return;
-          }
-
-          const storeName = node.id.name;
-
-          if (namingOf.store.isInvalid({ name: storeName, context })) {
-            reportStoreNameConventionViolation({
-              context,
-              node,
-              storeName,
-            });
-          }
-        },
-      };
-    }
-
-    // JavaScript-way
-    const importedFromEffector = new Map();
-    return {
-      ImportDeclaration(node) {
-        extractImportedFrom({
-          importMap: importedFromEffector,
-          node,
-          packageName: "effector",
-        });
-      },
-      CallExpression(node) {
-        // Store creation with method
-        const STORE_CREATION_METHODS = ["createStore", "restore", "combine"];
-        for (const method of STORE_CREATION_METHODS) {
-          const localMethod = importedFromEffector.get(method);
-          if (!localMethod) {
-            continue;
-          }
-
-          const isEffectorStoreCreation = node.callee.name === localMethod;
-          if (!isEffectorStoreCreation) {
-            continue;
-          }
-
-          const parentNode = traverseParentByType(node, "VariableDeclarator", {
-            stopOnTypes: ["Program", "BlockStatement", "Property"],
-          });
-
-          const resultSavedInVariable =
-            parentNode?.type === "VariableDeclarator";
-          if (!resultSavedInVariable) {
-            continue;
-          }
-
-          const storeName = parentNode.id.name;
-          if (namingOf.store.isValid({ name: storeName, context })) {
-            continue;
-          }
-
-          reportStoreNameConventionViolation({
-            context,
-            node: parentNode,
-            storeName,
-          });
-          return;
-        }
-
-        // Store creation with .map
-        if (node.callee?.property?.name === "map") {
-          const storeNameCreatedFromMap = node.callee?.object?.name;
-
-          if (
-            namingOf.store.isInvalid({ name: storeNameCreatedFromMap, context })
-          ) {
-            return;
-          }
-
-          const resultSavedInVariable =
-            node.parent.type === "VariableDeclarator";
-
-          if (!resultSavedInVariable) {
-            return;
-          }
-
-          const storeName = node.parent.id.name;
-
-          if (namingOf.store.isValid({ name: storeName, context })) {
-            return;
-          }
-
-          reportStoreNameConventionViolation({
-            context,
-            node: node.parent,
-            storeName,
-          });
-          return;
-        }
-
-        // Store creation in domain
-        const STORE_IN_DOMAIN_CREATION_METHODS = ["createStore", "store"];
-        if (
-          STORE_IN_DOMAIN_CREATION_METHODS.includes(node.callee?.property?.name)
-        ) {
-          const parentNode = traverseParentByType(node, "VariableDeclarator", {
-            stopOnTypes: ["Program", "BlockStatement", "Property"],
-          });
-
-          const resultSavedInVariable =
-            parentNode?.type === "VariableDeclarator";
-          if (!resultSavedInVariable) {
-            return;
-          }
-
-          const storeName = parentNode.id.name;
-
-          if (namingOf.store.isValid({ name: storeName, context })) {
-            return;
-          }
-
-          reportStoreNameConventionViolation({
-            context,
-            node: parentNode,
-            storeName,
-          });
-          return;
-        }
-      },
-    };
-  },
-};
-
-function reportStoreNameConventionViolation({ context, node, storeName }) {
-  const storeNameConvention = getStoreNameConvention(context);
-  const correctedStoreName = getCorrectedStoreName(storeName, context);
-
-  context.report({
-    node,
-    messageId: "invalidName",
-    data: {
-      storeName,
-      correctedStoreName,
-      storeNameConvention,
-    },
-    suggest: [
-      {
-        messageId: "renameStore",
-        data: { storeName, correctedStoreName },
-        fix(fixer) {
-          return fixer.replaceTextRange(node.id.range, correctedStoreName);
-        },
-      },
-    ],
-  });
-}

package/rules/keep-options-order/config.js

@@ -1,3 +0,0 @@
-const correctOrder = ["clock", "source", "filter", "fn", "target", "greedy"];
-
-module.exports = { correctOrder };