@reteps/tree-sitter-htmlmustache 0.2.0 → 0.2.1

package/cli/out/main.js

@@ -2113,6 +2113,95 @@ function checkConsecutiveSameNameSections(rootNode, sourceText) {
   visit(rootNode);
   return errors;
 }
+function areMutuallyExclusive(a, b) {
+  for (const ac of a) {
+    for (const bc of b) {
+      if (ac.name === bc.name && ac.inverted !== bc.inverted) {
+        return true;
+      }
+    }
+  }
+  return false;
+}
+function formatConditionClause(a, b) {
+  const seen = /* @__PURE__ */ new Map();
+  for (const c of [...a, ...b]) {
+    if (!seen.has(c.name)) {
+      seen.set(c.name, c.inverted);
+    }
+  }
+  if (seen.size === 0) return "";
+  const parts = [];
+  for (const [name, inverted] of seen) {
+    parts.push(`${name} is ${inverted ? "falsy" : "truthy"}`);
+  }
+  return ` (when ${parts.join(", ")})`;
+}
+function collectAttributes(node, conditions, out) {
+  for (const child of node.children) {
+    if (child.type === "html_attribute") {
+      const nameNode = child.children.find((c) => c.type === "html_attribute_name");
+      if (nameNode) {
+        out.push({ nameNode, conditions: [...conditions] });
+      }
+    } else if (child.type === "mustache_attribute") {
+      const section = child.children.find(
+        (c) => c.type === "mustache_section" || c.type === "mustache_inverted_section"
+      );
+      if (section) {
+        const name = getSectionName(section);
+        if (name) {
+          const inverted = section.type === "mustache_inverted_section";
+          collectAttributes(section, [...conditions, { name, inverted }], out);
+        }
+      }
+    }
+  }
+}
+function checkDuplicateAttributes(rootNode) {
+  const errors = [];
+  function visit(node) {
+    if (node.type === "html_start_tag" || node.type === "html_self_closing_tag") {
+      const occurrences = [];
+      collectAttributes(node, [], occurrences);
+      const groups = /* @__PURE__ */ new Map();
+      for (const occ of occurrences) {
+        const key = occ.nameNode.text.toLowerCase();
+        let group2 = groups.get(key);
+        if (!group2) {
+          group2 = [];
+          groups.set(key, group2);
+        }
+        group2.push(occ);
+      }
+      for (const [, group2] of groups) {
+        if (group2.length < 2) continue;
+        for (let i = 1; i < group2.length; i++) {
+          let conflictIdx = -1;
+          for (let j = 0; j < i; j++) {
+            if (!areMutuallyExclusive(group2[i].conditions, group2[j].conditions)) {
+              conflictIdx = j;
+              break;
+            }
+          }
+          if (conflictIdx >= 0) {
+            const clause = formatConditionClause(group2[conflictIdx].conditions, group2[i].conditions);
+            errors.push({
+              node: group2[i].nameNode,
+              message: `Duplicate attribute "${group2[i].nameNode.text}"${clause}`
+            });
+          }
+        }
+      }
+      return;
+    }
+    for (const child of node.children) {
+      visit(child);
+    }
+  }
+  visit(rootNode);
+  return errors;
+}
 
 // cli/src/check.ts
 function errorMessageForNode(nodeType, node) {
@@ -2185,7 +2274,8 @@ function collectErrors(tree, file) {
   const mustacheChecks = [
     ...checkNestedSameNameSections(rootNode),
     ...checkUnquotedMustacheAttributes(rootNode),
-    ...checkConsecutiveSameNameSections(rootNode, sourceText)
+    ...checkConsecutiveSameNameSections(rootNode, sourceText),
+    ...checkDuplicateAttributes(rootNode)
   ];
   for (const error of mustacheChecks) {
     errors.push({

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@reteps/tree-sitter-htmlmustache",
-  "version": "0.2.0",
+  "version": "0.2.1",
   "description": "HTML with Mustache/Handlebars template syntax grammar for tree-sitter",
   "repository": {
     "type": "git",