eslint-plugin-mgw-eslint-rules 2.3.32 → 2.3.34

package/dist/index.js

@@ -3200,11 +3200,11 @@ var require_getParserServices = __commonJS({
   "node_modules/@typescript-eslint/utils/dist/eslint-utils/getParserServices.js"(exports2) {
     "use strict";
     Object.defineProperty(exports2, "__esModule", { value: true });
-    exports2.getParserServices = getParserServices;
+    exports2.getParserServices = getParserServices3;
     var parserSeemsToBeTSESLint_1 = require_parserSeemsToBeTSESLint();
     var ERROR_MESSAGE_REQUIRES_PARSER_SERVICES = "You have used a rule which requires type information, but don't have parserOptions set to generate type information for this file. See https://tseslint.com/typed-linting for enabling linting with type information.";
     var ERROR_MESSAGE_UNKNOWN_PARSER = 'Note: detected a parser other than @typescript-eslint/parser. Make sure the parser is configured to forward "parserOptions.project" to @typescript-eslint/parser.';
-    function getParserServices(context, allowWithoutFullTypeInformation = false) {
+    function getParserServices3(context, allowWithoutFullTypeInformation = false) {
       const parser = context.parserPath || context.languageOptions.parser?.meta?.name;
       if (context.sourceCode.parserServices?.esTreeNodeToTSNodeMap == null || context.sourceCode.parserServices.tsNodeToESTreeNodeMap == null) {
         throwError(parser);
@@ -44026,6 +44026,7 @@ var rule2 = createRule2({
 
 // src/rules/enforce-angular-signal-call.ts
 var import_utils3 = __toESM(require_dist4());
+var import_eslint_utils = __toESM(require_eslint_utils3());
 var RULE_NAME3 = "enforce-angular-signal-call";
 var createRule3 = import_utils3.ESLintUtils.RuleCreator((name) => `https://github.com/developpement-megao/mgw-eslint-rules/docs/rules/${name}.md`);
 var rule3 = createRule3({
@@ -44043,36 +44044,33 @@ var rule3 = createRule3({
   },
   defaultOptions: [],
   create(context) {
+    const services = (0, import_eslint_utils.getParserServices)(context);
+    const checker = services.program.getTypeChecker();
     function isSignal(type) {
       const withoutGeneric = type.split("<")[0];
-      return !!withoutGeneric && ["Signal", "WritableSignal", "InputSignal"].includes(withoutGeneric);
-    }
-    const { sourceCode } = context;
-    const services = sourceCode.parserServices;
-    if (!services || !services.program || !services.esTreeNodeToTSNodeMap) {
-      return {};
+      if (withoutGeneric) {
+        return ["Signal", "WritableSignal", "InputSignal"].includes(withoutGeneric);
+      }
+      return false;
     }
-    const checker = services.program.getTypeChecker();
     return {
       Identifier(node) {
-        const variableNode = services.esTreeNodeToTSNodeMap?.get(node);
-        if (variableNode) {
-          const type = checker.getTypeAtLocation(variableNode);
-          const typeName = checker.typeToString(type);
-          if (isSignal(typeName)) {
-            const parent = node.parent;
-            if (!parent || parent.type !== import_utils3.AST_NODE_TYPES.CallExpression) {
-              return;
-            }
-            const callee = parent.callee;
-            if (callee.type !== import_utils3.AST_NODE_TYPES.Identifier || callee.name !== node.name) {
-              return;
-            }
-            context.report({
-              node,
-              messageId: "useGetter"
-            });
+        const variableNode = services.esTreeNodeToTSNodeMap.get(node);
+        const type = checker.getTypeAtLocation(variableNode);
+        const typeName = checker.typeToString(type);
+        if (isSignal(typeName)) {
+          const parent = node.parent;
+          if (!parent || parent.type !== import_utils3.AST_NODE_TYPES.CallExpression) {
+            return;
           }
+          const callee = parent.callee;
+          if (callee.type !== import_utils3.AST_NODE_TYPES.Identifier || callee.name !== node.name) {
+            return;
+          }
+          context.report({
+            node,
+            messageId: "useGetter"
+          });
         }
       }
     };
@@ -44248,6 +44246,7 @@ var rule6 = createRule6({
 
 // src/rules/reactive-naming-convention.ts
 var import_utils7 = __toESM(require_dist4());
+var import_eslint_utils2 = __toESM(require_eslint_utils3());
 var RULE_NAME7 = "reactive-naming-convention";
 var createRule7 = import_utils7.ESLintUtils.RuleCreator((name) => `https://github.com/developpement-megao/mgw-eslint-rules/docs/rules/${name}.md`);
 var rule7 = createRule7({
@@ -44269,32 +44268,32 @@ var rule7 = createRule7({
   },
   defaultOptions: [],
   create(context) {
-    const parserServices = context.sourceCode.parserServices;
-    if (!parserServices?.program || !parserServices.esTreeNodeToTSNodeMap) {
-      return {};
-    }
+    const services = (0, import_eslint_utils2.getParserServices)(context);
+    const checker = services.program.getTypeChecker();
     const listeReactiveWritableTypes = ["Subject", "WritableSignal", "InputSignal"];
     const listeReactiveReadonlyTypes = ["Signal", "Observable", "Promise"];
-    const checker = parserServices.program.getTypeChecker();
+    function getTypeWithoutGeneric(type) {
+      return type.split("<")[0];
+    }
     function checkNode(node, messageId) {
       const name = node.name;
-      if (!name || name === "_" || !parserServices?.esTreeNodeToTSNodeMap) {
+      if (!name || name === "_") {
         return;
       }
-      const tsNode = parserServices.esTreeNodeToTSNodeMap.get(node);
+      const tsNode = services.esTreeNodeToTSNodeMap.get(node);
       const type = checker.getTypeAtLocation(tsNode);
       const typeName = checker.typeToString(type);
-      const isReactiveWritableTypes = listeReactiveWritableTypes.some((t) => new RegExp(`${t}<.+>`).test(typeName));
+      const typeNameWithoutGeneric = getTypeWithoutGeneric(typeName);
+      if (!typeNameWithoutGeneric) {
+        return;
+      }
+      const isReactiveWritableTypes = listeReactiveWritableTypes.includes(typeNameWithoutGeneric);
       const suffix = isReactiveWritableTypes ? "$$" : "$";
-      if ((isReactiveWritableTypes || listeReactiveReadonlyTypes.some((t) => new RegExp(`${t}<.+>`).test(typeName))) && (!name.endsWith(suffix) || suffix === "$" && name.endsWith("$$"))) {
+      if ((isReactiveWritableTypes || listeReactiveReadonlyTypes.includes(typeNameWithoutGeneric)) && (!name.endsWith(suffix) || suffix === "$" && name.endsWith("$$"))) {
         context.report({
           node,
           messageId,
-          data: {
-            typeName,
-            name,
-            suffix
-          },
+          data: { name, suffix },
           fix(fixer) {
             const baseName = name.replace(/\$+$/, "");
             const newName = `${baseName}${suffix}`;