eslint-plugin-mgw-eslint-rules 2.3.19 → 2.3.21

package/dist/index.js

@@ -44314,10 +44314,6 @@ var import_utils10 = __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_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]*$/,
@@ -44361,12 +44357,26 @@ var rule8 = createRule8({
                     enum: ATTRIBUTE_CONVENTION_POSSIBLE_VALUES
                   },
                   minItems: 1
+                },
+                {
+                  type: "object",
+                  properties: {
+                    pattern: {
+                      type: "array",
+                      items: {
+                        type: "string"
+                      },
+                      minItems: 1,
+                      //default: [],
+                      description: "Patterns regex to test"
+                    }
+                  },
+                  required: ["pattern"]
                 }
               ]
             }
           }
         },
-        //required: ['conventions'],
         additionalProperties: false
       }
     ],
@@ -44374,44 +44384,50 @@ var rule8 = createRule8({
   },
   defaultOptions: [
     {
-      attributes: ATTRIBUTE_DEFAULT_VALUES
+      id: "kebab-case",
+      class: "kebab-case"
     }
   ],
   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]) => {
+      Object.entries(options).map(([a, n]) => {
         const listeNommage = typeof n === "string" ? [n] : n;
-        const nommageReg = listeNommage.map((c) => conventionPatterns[c]);
-        return [a, { noms: listeNommage.join(", "), regs: nommageReg }];
+        if (Array.isArray(listeNommage)) {
+          const nommageReg = listeNommage.map((c) => conventionPatterns[c]);
+          return [a, { noms: listeNommage.join(", "), regs: nommageReg }];
+        }
+        return [
+          a,
+          {
+            noms: listeNommage.pattern.join(", "),
+            regs: listeNommage.pattern.map((p) => new RegExp(p))
+          }
+        ];
       })
     );
     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) {
-        console.log(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
-                  }
-                });
+      "Element[attributes]"(node) {
+        const attributes = node.attributes;
+        for (const attr of attributes) {
+          if (attr.value) {
+            const attrNomme = listeAttributes.get(attr.name);
+            if (attrNomme) {
+              const attributeValues = attr.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: attr.name,
+                      value: attrValue,
+                      conventions: attrNomme.noms
+                    }
+                  });
+                }
               }
             }
           }