eslint-plugin-mgw-eslint-rules 2.3.17 → 2.3.18

package/dist/index.js

@@ -3261,8 +3261,8 @@ var require_RuleCreator = __commonJS({
     exports2.RuleCreator = RuleCreator;
     var applyDefault_1 = require_applyDefault();
     function RuleCreator(urlCreator) {
-      return function createNamedRule({ meta, name, ...rule9 }) {
-        const ruleWithDocs = createRule9({
+      return function createNamedRule({ meta, name, ...rule10 }) {
+        const ruleWithDocs = createRule10({
           meta: {
             ...meta,
             docs: {
@@ -3271,12 +3271,12 @@ var require_RuleCreator = __commonJS({
             }
           },
           name,
-          ...rule9
+          ...rule10
         });
         return ruleWithDocs;
       };
     }
-    function createRule9({
+    function createRule10({
       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 createRule9(args);
+      return createRule10(args);
     };
   }
 });
@@ -20621,13 +20621,13 @@ ${ctx.toSourceMapGenerator(sourceUrl, headerLines).toJsComment()}`;
       }
       _scopeKeyframesRelatedCss(cssText, scopeSelector) {
         const unscopedKeyframesSet = /* @__PURE__ */ new Set();
-        const scopedKeyframesCssText = processRules(cssText, (rule9) => this._scopeLocalKeyframeDeclarations(rule9, scopeSelector, unscopedKeyframesSet));
-        return processRules(scopedKeyframesCssText, (rule9) => this._scopeAnimationRule(rule9, scopeSelector, unscopedKeyframesSet));
+        const scopedKeyframesCssText = processRules(cssText, (rule10) => this._scopeLocalKeyframeDeclarations(rule10, scopeSelector, unscopedKeyframesSet));
+        return processRules(scopedKeyframesCssText, (rule10) => this._scopeAnimationRule(rule10, scopeSelector, unscopedKeyframesSet));
       }
-      _scopeLocalKeyframeDeclarations(rule9, scopeSelector, unscopedKeyframesSet) {
+      _scopeLocalKeyframeDeclarations(rule10, scopeSelector, unscopedKeyframesSet) {
         return {
-          ...rule9,
-          selector: rule9.selector.replace(/(^@(?:-webkit-)?keyframes(?:\s+))(['"]?)(.+)\2(\s*)$/, (_, start, quote, keyframeName, endSpaces) => {
+          ...rule10,
+          selector: rule10.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(rule9, scopeSelector, unscopedKeyframesSet) {
-        let content = rule9.content.replace(/((?:^|\s+|;)(?:-webkit-)?animation\s*:\s*),*([^;]+)/g, (_, start, animationDeclarations) => start + animationDeclarations.replace(this._animationDeclarationKeyframesRe, (original, leadingSpaces, quote = "", quotedName, nonQuotedName) => {
+      _scopeAnimationRule(rule10, scopeSelector, unscopedKeyframesSet) {
+        let content = rule10.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 {
-          ...rule9,
+          ...rule10,
           content
         };
       }
@@ -20661,8 +20661,8 @@ ${ctx.toSourceMapGenerator(sourceUrl, headerLines).toJsComment()}`;
       }
       _insertPolyfillRulesInCssText(cssText) {
         return cssText.replace(_cssContentRuleRe, (...m) => {
-          const rule9 = m[0].replace(m[1], "").replace(m[2], "");
-          return m[4] + rule9;
+          const rule10 = m[0].replace(m[1], "").replace(m[2], "");
+          return m[4] + rule10;
         });
       }
       _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 rule9 = m[0].replace(m[2], "").replace(m[1], m[4]);
-          r += rule9 + "\n\n";
+          const rule10 = m[0].replace(m[2], "").replace(m[1], m[4]);
+          r += rule10 + "\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, (rule9) => {
-          let selector = rule9.selector;
-          let content = rule9.content;
-          if (rule9.selector[0] !== "@") {
+        return processRules(cssText, (rule10) => {
+          let selector = rule10.selector;
+          let content = rule10.content;
+          if (rule10.selector[0] !== "@") {
             selector = this._scopeSelector({
               selector,
               scopeSelector,
               hostSelector,
               isParentSelector: true
             });
-          } else if (scopedAtRuleIdentifiers.some((atRule) => rule9.selector.startsWith(atRule))) {
-            content = this._scopeSelectors(rule9.content, scopeSelector, hostSelector);
-          } else if (rule9.selector.startsWith("@font-face") || rule9.selector.startsWith("@page")) {
-            content = this._stripScopingSelectors(rule9.content);
+          } else if (scopedAtRuleIdentifiers.some((atRule) => rule10.selector.startsWith(atRule))) {
+            content = this._scopeSelectors(rule10.content, scopeSelector, hostSelector);
+          } else if (rule10.selector.startsWith("@font-face") || rule10.selector.startsWith("@page")) {
+            content = this._stripScopingSelectors(rule10.content);
           }
           return new CssRule(selector, content);
         });
       }
       _stripScopingSelectors(cssText) {
-        return processRules(cssText, (rule9) => {
-          const selector = rule9.selector.replace(_shadowDeepSelectors, " ").replace(_polyfillHostNoCombinatorRe, " ");
-          return new CssRule(selector, rule9.content);
+        return processRules(cssText, (rule10) => {
+          const selector = rule10.selector.replace(_shadowDeepSelectors, " ").replace(_polyfillHostNoCombinatorRe, " ");
+          return new CssRule(selector, rule10.content);
         });
       }
       _safeSelector;
@@ -21051,8 +21051,8 @@ ${ctx.toSourceMapGenerator(sourceUrl, headerLines).toJsComment()}`;
           suffix = suffix.substring(BLOCK_PLACEHOLDER.length + 1);
           contentPrefix = "{";
         }
-        const rule9 = ruleCallback(new CssRule(selector, content));
-        return `${m[1]}${rule9.selector}${m[3]}${contentPrefix}${rule9.content}${suffix}`;
+        const rule10 = ruleCallback(new CssRule(selector, content));
+        return `${m[1]}${rule10.selector}${m[3]}${contentPrefix}${rule10.content}${suffix}`;
       });
       return unescapeInStrings(escapedResult);
     }
@@ -43819,9 +43819,9 @@ var require_parser_services = __commonJS({
   "node_modules/@angular-eslint/utils/dist/eslint-plugin-template/parser-services.js"(exports2) {
     "use strict";
     Object.defineProperty(exports2, "__esModule", { value: true });
-    exports2.getTemplateParserServices = getTemplateParserServices2;
+    exports2.getTemplateParserServices = getTemplateParserServices3;
     exports2.ensureTemplateParser = ensureTemplateParser;
-    function getTemplateParserServices2(context) {
+    function getTemplateParserServices3(context) {
       ensureTemplateParser(context);
       return context.sourceCode.parserServices;
     }
@@ -44308,14 +44308,126 @@ var rule7 = createRule7({
   }
 });
 
-// src/rules/template/prefer-class-style-binding.ts
+// src/rules/template/attributes-naming-convention.ts
 var import_utils9 = __toESM(require_dist6());
 var import_utils10 = __toESM(require_dist4());
-var RULE_NAME8 = "template/prefer-class-style-binding";
+var NAMING_CONVENTIONS = ["camelCase", "strictCamelCase", "PascalCase", "StrictPascalCase", "snake_case", "UPPER_CASE", "kebab-case"];
+var ATTRIBUTE_CONVENTION_POSSIBLE_VALUES = [...NAMING_CONVENTIONS];
+var RULE_NAME8 = "template/attributes-naming-convention";
+var ATTRIBUTE_DEFAULT_VALUES = {
+  id: "kebab-case",
+  class: "kebab-case"
+};
+var conventionPatterns = {
+  camelCase: /^[a-z][a-zA-Z0-9]*$/,
+  strictCamelCase: /^(?!.*[A-Z]{2})[a-z][a-zA-Z0-9]*$/,
+  PascalCase: /^[A-Z][a-zA-Z0-9]*$/,
+  StrictPascalCase: /^(?!.*[A-Z]{2})[A-Z][a-zA-Z0-9]*$/,
+  snake_case: /^[a-z][a-z0-9]*(?:_[a-z0-9]+)*$/,
+  UPPER_CASE: /^[A-Z][A-Z0-9]*(?:_[A-Z0-9]+)*$/,
+  "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 createRule8 = import_utils10.ESLintUtils.RuleCreator((name) => `${DOCS_RULES4}/${name}.md`);
 var rule8 = createRule8({
   name: RULE_NAME8,
+  meta: {
+    type: "suggestion",
+    docs: {
+      description: "Enforce naming convention (kebab-case) for specified attributes (id and class) values in Angular templates.",
+      category: "Best Practices",
+      recommended: true
+    },
+    messages: {
+      invalidNaming: "Attribute '{{ attribute }}' with value '{{ value }}' must match one of the naming conventions : {{ conventions }}."
+    },
+    schema: [
+      {
+        type: "object",
+        properties: {
+          attributes: {
+            type: "object",
+            description: "Map of attribute names to their allowed naming conventions (single or array).",
+            additionalProperties: {
+              anyOf: [
+                {
+                  type: "string",
+                  enum: ATTRIBUTE_CONVENTION_POSSIBLE_VALUES
+                },
+                {
+                  type: "array",
+                  items: {
+                    type: "string",
+                    enum: ATTRIBUTE_CONVENTION_POSSIBLE_VALUES
+                  },
+                  minItems: 1
+                }
+              ]
+            }
+          }
+        },
+        //required: ['conventions'],
+        additionalProperties: false
+      }
+    ],
+    hasSuggestions: true
+  },
+  defaultOptions: [
+    {
+      attributes: ATTRIBUTE_DEFAULT_VALUES
+    }
+  ],
+  create(context, [options]) {
+    const parserServices = (0, import_utils9.getTemplateParserServices)(context);
+    const attributesConfig = options.attributes || ATTRIBUTE_DEFAULT_VALUES;
+    const listeAttributes = new Map(
+      Object.entries(attributesConfig).map(([a, n]) => {
+        const listeNommage = typeof n === "string" ? [n] : n;
+        const nommageReg = listeNommage.map((c) => conventionPatterns[c]);
+        return [a, { noms: listeNommage.join(", "), regs: nommageReg }];
+      })
+    );
+    return {
+      // Détecte les attributs dans les templates (parcours global élément (noeud) par élément)
+      //'Element[attributes]'(node: TmplAstElement) {
+      //// const attributes = node.attributes;
+      //// On va parcourir tous les attributs
+      //// for (const attr of attributes) {
+      // Parcours attribut par attribut
+      "Element$1 > TextAttribute"(node) {
+        if (node.value) {
+          const attrNomme = listeAttributes.get(node.name);
+          if (attrNomme) {
+            const attributeValues = node.value.split(/\s+/);
+            for (const attrValue of attributeValues) {
+              if (!attrNomme.regs.some((pattern) => pattern.test(attrValue))) {
+                const loc = parserServices.convertNodeSourceSpanToLoc(node.sourceSpan);
+                context.report({
+                  loc,
+                  messageId: "invalidNaming",
+                  data: {
+                    attribute: node.name,
+                    value: attrValue,
+                    conventions: attrNomme.noms
+                  }
+                });
+              }
+            }
+          }
+        }
+      }
+    };
+  }
+});
+
+// src/rules/template/prefer-class-style-binding.ts
+var import_utils11 = __toESM(require_dist6());
+var import_utils12 = __toESM(require_dist4());
+var RULE_NAME9 = "template/prefer-class-style-binding";
+var DOCS_RULES5 = "https://github.com/developpement-megao/mgw-eslint-rules/tree/main/docs/rules";
+var createRule9 = import_utils12.ESLintUtils.RuleCreator((name) => `${DOCS_RULES5}/${name}.md`);
+var rule9 = createRule9({
+  name: RULE_NAME9,
   meta: {
     type: "suggestion",
     docs: {
@@ -44330,7 +44442,7 @@ var rule8 = createRule8({
   },
   defaultOptions: [],
   create(context) {
-    const parserServices = (0, import_utils9.getTemplateParserServices)(context);
+    const parserServices = (0, import_utils11.getTemplateParserServices)(context);
     return {
       // Détecte les attributs ngClass et ngStyle et inputs [ngClass] et [ngStyle] dans les templates
       Element(node) {
@@ -44356,9 +44468,10 @@ var rules = {
   [RULE_NAME3]: rule3,
   [RULE_NAME4]: rule4,
   [RULE_NAME]: rule,
-  [RULE_NAME8]: rule8,
+  [RULE_NAME9]: rule9,
   [RULE_NAME7]: rule7,
-  [RULE_NAME2]: rule2
+  [RULE_NAME2]: rule2,
+  [RULE_NAME8]: rule8
 };
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {