eslint-plugin-mgw-eslint-rules 2.3.34 → 2.3.35

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 = getParserServices3;
+    exports2.getParserServices = getParserServices4;
     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 getParserServices3(context, allowWithoutFullTypeInformation = false) {
+    function getParserServices4(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);
@@ -3261,8 +3261,8 @@ var require_RuleCreator = __commonJS({
     exports2.RuleCreator = RuleCreator;
     var applyDefault_1 = require_applyDefault();
     function RuleCreator(urlCreator) {
-      return function createNamedRule({ meta, name, ...rule11 }) {
-        const ruleWithDocs = createRule11({
+      return function createNamedRule({ meta, name, ...rule12 }) {
+        const ruleWithDocs = createRule12({
           meta: {
             ...meta,
             docs: {
@@ -3271,12 +3271,12 @@ var require_RuleCreator = __commonJS({
             }
           },
           name,
-          ...rule11
+          ...rule12
         });
         return ruleWithDocs;
       };
     }
-    function createRule11({
+    function createRule12({
       create,
       // Keep accepting deprecated defaultOptions for backward compatibility.
       // eslint-disable-next-line @typescript-eslint/no-deprecated
@@ -3296,7 +3296,7 @@ var require_RuleCreator = __commonJS({
       };
     }
     RuleCreator.withoutDocs = function withoutDocs(args) {
-      return createRule11(args);
+      return createRule12(args);
     };
   }
 });
@@ -20621,13 +20621,13 @@ ${ctx.toSourceMapGenerator(sourceUrl, headerLines).toJsComment()}`;
       }
       _scopeKeyframesRelatedCss(cssText, scopeSelector) {
         const unscopedKeyframesSet = /* @__PURE__ */ new Set();
-        const scopedKeyframesCssText = processRules(cssText, (rule11) => this._scopeLocalKeyframeDeclarations(rule11, scopeSelector, unscopedKeyframesSet));
-        return processRules(scopedKeyframesCssText, (rule11) => this._scopeAnimationRule(rule11, scopeSelector, unscopedKeyframesSet));
+        const scopedKeyframesCssText = processRules(cssText, (rule12) => this._scopeLocalKeyframeDeclarations(rule12, scopeSelector, unscopedKeyframesSet));
+        return processRules(scopedKeyframesCssText, (rule12) => this._scopeAnimationRule(rule12, scopeSelector, unscopedKeyframesSet));
       }
-      _scopeLocalKeyframeDeclarations(rule11, scopeSelector, unscopedKeyframesSet) {
+      _scopeLocalKeyframeDeclarations(rule12, scopeSelector, unscopedKeyframesSet) {
         return {
-          ...rule11,
-          selector: rule11.selector.replace(/(^@(?:-webkit-)?keyframes(?:\s+))(['"]?)(.+)\2(\s*)$/, (_, start, quote, keyframeName, endSpaces) => {
+          ...rule12,
+          selector: rule12.selector.replace(/(^@(?:-webkit-)?keyframes(?:\s+))(['"]?)(.+)\2(\s*)$/, (_, start, quote, keyframeName, endSpaces) => {
             unscopedKeyframesSet.add(unescapeQuotes(keyframeName, quote));
             return `${start}${quote}${scopeSelector}_${keyframeName}${quote}${endSpaces}`;
           })
@@ -20640,8 +20640,8 @@ ${ctx.toSourceMapGenerator(sourceUrl, headerLines).toJsComment()}`;
         });
       }
       _animationDeclarationKeyframesRe = /(^|\s+|,)(?:(?:(['"])((?:\\\\|\\\2|(?!\2).)+)\2)|(-?[A-Za-z][\w\-]*))(?=[,\s]|$)/g;
-      _scopeAnimationRule(rule11, scopeSelector, unscopedKeyframesSet) {
-        let content = rule11.content.replace(/((?:^|\s+|;)(?:-webkit-)?animation\s*:\s*),*([^;]+)/g, (_, start, animationDeclarations) => start + animationDeclarations.replace(this._animationDeclarationKeyframesRe, (original, leadingSpaces, quote = "", quotedName, nonQuotedName) => {
+      _scopeAnimationRule(rule12, scopeSelector, unscopedKeyframesSet) {
+        let content = rule12.content.replace(/((?:^|\s+|;)(?:-webkit-)?animation\s*:\s*),*([^;]+)/g, (_, start, animationDeclarations) => start + animationDeclarations.replace(this._animationDeclarationKeyframesRe, (original, leadingSpaces, quote = "", quotedName, nonQuotedName) => {
           if (quotedName) {
             return `${leadingSpaces}${this._scopeAnimationKeyframe(`${quote}${quotedName}${quote}`, scopeSelector, unscopedKeyframesSet)}`;
           } else {
@@ -20650,7 +20650,7 @@ ${ctx.toSourceMapGenerator(sourceUrl, headerLines).toJsComment()}`;
         }));
         content = content.replace(/((?:^|\s+|;)(?:-webkit-)?animation-name(?:\s*):(?:\s*))([^;]+)/g, (_match, start, commaSeparatedKeyframes) => `${start}${commaSeparatedKeyframes.split(",").map((keyframe) => this._scopeAnimationKeyframe(keyframe, scopeSelector, unscopedKeyframesSet)).join(",")}`);
         return {
-          ...rule11,
+          ...rule12,
           content
         };
       }
@@ -20661,8 +20661,8 @@ ${ctx.toSourceMapGenerator(sourceUrl, headerLines).toJsComment()}`;
       }
       _insertPolyfillRulesInCssText(cssText) {
         return cssText.replace(_cssContentRuleRe, (...m) => {
-          const rule11 = m[0].replace(m[1], "").replace(m[2], "");
-          return m[4] + rule11;
+          const rule12 = m[0].replace(m[1], "").replace(m[2], "");
+          return m[4] + rule12;
         });
       }
       _scopeCssText(cssText, scopeSelector, hostSelector) {
@@ -20683,8 +20683,8 @@ ${ctx.toSourceMapGenerator(sourceUrl, headerLines).toJsComment()}`;
         let m;
         _cssContentUnscopedRuleRe.lastIndex = 0;
         while ((m = _cssContentUnscopedRuleRe.exec(cssText)) !== null) {
-          const rule11 = m[0].replace(m[2], "").replace(m[1], m[4]);
-          r += rule11 + "\n\n";
+          const rule12 = m[0].replace(m[2], "").replace(m[1], m[4]);
+          r += rule12 + "\n\n";
         }
         return r;
       }
@@ -20769,28 +20769,28 @@ ${ctx.toSourceMapGenerator(sourceUrl, headerLines).toJsComment()}`;
         return _shadowDOMSelectorsRe.reduce((result, pattern) => result.replace(pattern, " "), cssText);
       }
       _scopeSelectors(cssText, scopeSelector, hostSelector) {
-        return processRules(cssText, (rule11) => {
-          let selector = rule11.selector;
-          let content = rule11.content;
-          if (rule11.selector[0] !== "@") {
+        return processRules(cssText, (rule12) => {
+          let selector = rule12.selector;
+          let content = rule12.content;
+          if (rule12.selector[0] !== "@") {
             selector = this._scopeSelector({
               selector,
               scopeSelector,
               hostSelector,
               isParentSelector: true
             });
-          } else if (scopedAtRuleIdentifiers.some((atRule) => rule11.selector.startsWith(atRule))) {
-            content = this._scopeSelectors(rule11.content, scopeSelector, hostSelector);
-          } else if (rule11.selector.startsWith("@font-face") || rule11.selector.startsWith("@page")) {
-            content = this._stripScopingSelectors(rule11.content);
+          } else if (scopedAtRuleIdentifiers.some((atRule) => rule12.selector.startsWith(atRule))) {
+            content = this._scopeSelectors(rule12.content, scopeSelector, hostSelector);
+          } else if (rule12.selector.startsWith("@font-face") || rule12.selector.startsWith("@page")) {
+            content = this._stripScopingSelectors(rule12.content);
           }
           return new CssRule(selector, content);
         });
       }
       _stripScopingSelectors(cssText) {
-        return processRules(cssText, (rule11) => {
-          const selector = rule11.selector.replace(_shadowDeepSelectors, " ").replace(_polyfillHostNoCombinatorRe, " ");
-          return new CssRule(selector, rule11.content);
+        return processRules(cssText, (rule12) => {
+          const selector = rule12.selector.replace(_shadowDeepSelectors, " ").replace(_polyfillHostNoCombinatorRe, " ");
+          return new CssRule(selector, rule12.content);
         });
       }
       _safeSelector;
@@ -21051,8 +21051,8 @@ ${ctx.toSourceMapGenerator(sourceUrl, headerLines).toJsComment()}`;
           suffix = suffix.substring(BLOCK_PLACEHOLDER.length + 1);
           contentPrefix = "{";
         }
-        const rule11 = ruleCallback(new CssRule(selector, content));
-        return `${m[1]}${rule11.selector}${m[3]}${contentPrefix}${rule11.content}${suffix}`;
+        const rule12 = ruleCallback(new CssRule(selector, content));
+        return `${m[1]}${rule12.selector}${m[3]}${contentPrefix}${rule12.content}${suffix}`;
       });
       return unescapeInStrings(escapedResult);
     }
@@ -44034,7 +44034,9 @@ var rule3 = createRule3({
   meta: {
     type: "problem",
     docs: {
-      description: "Enforce correct usage of Angular signals"
+      description: "Enforce correct usage of Angular signals",
+      recommended: true,
+      requiresTypeChecking: true
     },
     messages: {
       useGetter: "Use the getter function to access the value of Angular signal"
@@ -44191,13 +44193,120 @@ var rule5 = createRule5({
   }
 });
 
-// src/rules/prefer-const-enum.ts
+// src/rules/no-list-suffix.ts
 var import_utils6 = __toESM(require_dist4());
-var RULE_NAME6 = "prefer-const-enum";
-var DOCS_RULES2 = "https://github.com/developpement-megao/mgw-eslint-rules/tree/main/docs/rules";
-var createRule6 = import_utils6.ESLintUtils.RuleCreator((name) => `${DOCS_RULES2}/${name}.md`);
+var import_eslint_utils2 = __toESM(require_eslint_utils3());
+var RULE_NAME6 = "no-list-suffix";
+var createRule6 = import_utils6.ESLintUtils.RuleCreator((name) => `https://github.com/developpement-megao/mgw-eslint-rules/docs/rules/${name}.md`);
 var rule6 = createRule6({
   name: RULE_NAME6,
+  meta: {
+    type: "suggestion",
+    fixable: "code",
+    docs: {
+      description: "Naming convention for reactive variables and properties (name must end with $ and $$ for WritableSignals and Subjects)",
+      recommended: true,
+      requiresTypeChecking: true
+    },
+    messages: {
+      noListSuffix: "Suffix `list` is not allowed in iterable `{{ name }}`.",
+      mustEndWithS: "Iterable `{{ name }}` must end with an `s`."
+    },
+    schema: []
+    // No options
+  },
+  defaultOptions: [],
+  create(context) {
+    const services = (0, import_eslint_utils2.getParserServices)(context);
+    const checker = services.program.getTypeChecker();
+    const listeArraysTypes = ["Array", "ReadonlyArray", "ArrayLike", "Set", "ReadonlySet", "Map", "ReadonlyMap"];
+    function getTypeWithoutGeneric(type) {
+      return type.split("<")[0];
+    }
+    function fixNodeName(node, name) {
+      const sourceCode = context.sourceCode;
+      const scope = sourceCode.getScope(node);
+      const fixes = [];
+      fixes.push(node);
+      let variable;
+      let current = scope;
+      while (current) {
+        variable = current.variables.find((v) => v.name === name);
+        if (variable) {
+          for (const ref of variable.references) {
+            const refNode = ref.identifier;
+            if (refNode !== node) {
+              fixes.push(refNode);
+            }
+          }
+          break;
+        }
+        if (!current.upper) {
+          break;
+        }
+        current = current.upper;
+      }
+      return fixes;
+    }
+    function checkNode(node) {
+      const name = node.name;
+      if (!name || name === "_") {
+        return;
+      }
+      const tsNode = services.esTreeNodeToTSNodeMap.get(node);
+      const type = checker.getTypeAtLocation(tsNode);
+      const typeName = checker.typeToString(type);
+      const typeNameWithoutGeneric = getTypeWithoutGeneric(typeName);
+      if (!typeNameWithoutGeneric || !listeArraysTypes.includes(typeNameWithoutGeneric)) {
+        return;
+      }
+      const listSuffixRegexp = /liste?$/i;
+      if (listSuffixRegexp.test(name)) {
+        context.report({
+          node,
+          messageId: "noListSuffix",
+          data: { name },
+          fix(fixer) {
+            const newName = name.replace(listSuffixRegexp, "");
+            return fixNodeName(node, name).map((nt) => fixer.replaceText(nt, newName));
+          }
+        });
+      }
+      if (!/s$/.test(name)) {
+        context.report({
+          node,
+          messageId: "mustEndWithS",
+          data: { name },
+          fix(fixer) {
+            return fixNodeName(node, name).map((nt) => fixer.replaceText(nt, `${name}s`));
+          }
+        });
+      }
+    }
+    return {
+      // Déclarations de variables : const x = signal(0)
+      VariableDeclarator(node) {
+        if (node.id.type === "Identifier") {
+          checkNode(node.id);
+        }
+      },
+      // Propriétés de classe : count = signal(0)
+      PropertyDefinition(node) {
+        if (node.key.type === "Identifier") {
+          checkNode(node.key);
+        }
+      }
+    };
+  }
+});
+
+// src/rules/prefer-const-enum.ts
+var import_utils7 = __toESM(require_dist4());
+var RULE_NAME7 = "prefer-const-enum";
+var DOCS_RULES2 = "https://github.com/developpement-megao/mgw-eslint-rules/tree/main/docs/rules";
+var createRule7 = import_utils7.ESLintUtils.RuleCreator((name) => `${DOCS_RULES2}/${name}.md`);
+var rule7 = createRule7({
+  name: RULE_NAME7,
   meta: {
     type: "problem",
     docs: {
@@ -44245,12 +44354,12 @@ 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({
-  name: RULE_NAME7,
+var import_utils8 = __toESM(require_dist4());
+var import_eslint_utils3 = __toESM(require_eslint_utils3());
+var RULE_NAME8 = "reactive-naming-convention";
+var createRule8 = import_utils8.ESLintUtils.RuleCreator((name) => `https://github.com/developpement-megao/mgw-eslint-rules/docs/rules/${name}.md`);
+var rule8 = createRule8({
+  name: RULE_NAME8,
   meta: {
     type: "suggestion",
     fixable: "code",
@@ -44268,9 +44377,9 @@ var rule7 = createRule7({
   },
   defaultOptions: [],
   create(context) {
-    const services = (0, import_eslint_utils2.getParserServices)(context);
+    const services = (0, import_eslint_utils3.getParserServices)(context);
     const checker = services.program.getTypeChecker();
-    const listeReactiveWritableTypes = ["Subject", "WritableSignal", "InputSignal"];
+    const listeReactiveWritableTypes = ["Subject", "BehaviorSubject", "ReplaySubject", "AsyncSubject", "WritableSignal", "InputSignal"];
     const listeReactiveReadonlyTypes = ["Signal", "Observable", "Promise"];
     function getTypeWithoutGeneric(type) {
       return type.split("<")[0];
@@ -44342,14 +44451,14 @@ var rule7 = createRule7({
 });
 
 // src/rules/service-class-suffix.ts
-var import_utils8 = __toESM(require_dist6());
-var import_utils9 = __toESM(require_dist4());
-var RULE_NAME8 = "service-class-suffix";
+var import_utils9 = __toESM(require_dist6());
+var import_utils10 = __toESM(require_dist4());
+var RULE_NAME9 = "service-class-suffix";
 var SUFFIXES_DEFAULT = ["Service"];
 var DOCS_RULES3 = "https://github.com/developpement-megao/mgw-eslint-rules/blob/main/docs/rules";
-var createRule8 = import_utils9.ESLintUtils.RuleCreator((name) => `${DOCS_RULES3}/${name}.md`);
-var rule8 = createRule8({
-  name: RULE_NAME8,
+var createRule9 = import_utils10.ESLintUtils.RuleCreator((name) => `${DOCS_RULES3}/${name}.md`);
+var rule9 = createRule9({
+  name: RULE_NAME9,
   meta: {
     type: "suggestion",
     docs: {
@@ -44381,7 +44490,7 @@ var rule8 = createRule8({
   ],
   create(context, [{ suffixes }]) {
     return {
-      [import_utils8.Selectors.INJECTABLE_CLASS_DECORATOR](node) {
+      [import_utils9.Selectors.INJECTABLE_CLASS_DECORATOR](node) {
         const classDeclaration = node.parent;
         if (!classDeclaration.id) {
           return;
@@ -44404,11 +44513,11 @@ var rule8 = createRule8({
 });
 
 // src/rules/template/attributes-naming-convention.ts
-var import_utils10 = __toESM(require_dist6());
-var import_utils11 = __toESM(require_dist4());
+var import_utils11 = __toESM(require_dist6());
+var import_utils12 = __toESM(require_dist4());
 var NAMING_CONVENTIONS = ["camelCase", "strictCamelCase", "PascalCase", "StrictPascalCase", "snake_case", "UPPER_CASE", "kebab-case"];
 var ATTRIBUTE_CONVENTION_POSSIBLE_VALUES = [...NAMING_CONVENTIONS];
-var RULE_NAME9 = "template/attributes-naming-convention";
+var RULE_NAME10 = "template/attributes-naming-convention";
 var conventionPatterns = {
   camelCase: /^[a-z][a-zA-Z0-9]*$/,
   strictCamelCase: /^(?!.*[A-Z]{2})[a-z][a-zA-Z0-9]*$/,
@@ -44419,9 +44528,9 @@ var conventionPatterns = {
   "kebab-case": /^[a-z][a-z0-9]*(?:-[a-z0-9]+)*$/
 };
 var DOCS_RULES4 = "https://github.com/developpement-megao/mgw-eslint-rules/tree/main/docs/rules";
-var createRule9 = import_utils11.ESLintUtils.RuleCreator((name) => `${DOCS_RULES4}/${name}.md`);
-var rule9 = createRule9({
-  name: RULE_NAME9,
+var createRule10 = import_utils12.ESLintUtils.RuleCreator((name) => `${DOCS_RULES4}/${name}.md`);
+var rule10 = createRule10({
+  name: RULE_NAME10,
   meta: {
     type: "suggestion",
     docs: {
@@ -44480,7 +44589,7 @@ var rule9 = createRule9({
     }
   ],
   create(context, [options]) {
-    const parserServices = (0, import_utils10.getTemplateParserServices)(context);
+    const parserServices = (0, import_utils11.getTemplateParserServices)(context);
     const listeAttributes = new Map(
       Object.entries(options).map(([a, n]) => {
         const listeNommage = typeof n === "string" ? [n] : n;
@@ -44529,13 +44638,13 @@ var rule9 = createRule9({
 });
 
 // src/rules/template/prefer-class-style-binding.ts
-var import_utils12 = __toESM(require_dist6());
-var import_utils13 = __toESM(require_dist4());
-var RULE_NAME10 = "template/prefer-class-style-binding";
+var import_utils13 = __toESM(require_dist6());
+var import_utils14 = __toESM(require_dist4());
+var RULE_NAME11 = "template/prefer-class-style-binding";
 var DOCS_RULES5 = "https://github.com/developpement-megao/mgw-eslint-rules/tree/main/docs/rules";
-var createRule10 = import_utils13.ESLintUtils.RuleCreator((name) => `${DOCS_RULES5}/${name}.md`);
-var rule10 = createRule10({
-  name: RULE_NAME10,
+var createRule11 = import_utils14.ESLintUtils.RuleCreator((name) => `${DOCS_RULES5}/${name}.md`);
+var rule11 = createRule11({
+  name: RULE_NAME11,
   meta: {
     type: "suggestion",
     docs: {
@@ -44550,7 +44659,7 @@ var rule10 = createRule10({
   },
   defaultOptions: [],
   create(context) {
-    const parserServices = (0, import_utils12.getTemplateParserServices)(context);
+    const parserServices = (0, import_utils13.getTemplateParserServices)(context);
     return {
       // Détecte les attributs ngClass et ngStyle et inputs [ngClass] et [ngStyle] dans les templates
       Element(node) {
@@ -44571,16 +44680,17 @@ var rule10 = createRule10({
 
 // src/index.ts
 var rules = {
-  [RULE_NAME6]: rule6,
+  [RULE_NAME7]: rule7,
   [RULE_NAME5]: rule5,
   [RULE_NAME3]: rule3,
   [RULE_NAME4]: rule4,
   [RULE_NAME]: rule,
+  [RULE_NAME11]: rule11,
+  [RULE_NAME9]: rule9,
+  [RULE_NAME2]: rule2,
   [RULE_NAME10]: rule10,
   [RULE_NAME8]: rule8,
-  [RULE_NAME2]: rule2,
-  [RULE_NAME9]: rule9,
-  [RULE_NAME7]: rule7
+  [RULE_NAME6]: rule6
 };
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {