@reteps/tree-sitter-htmlmustache 0.0.39 → 0.1.0

package/README.md

@@ -145,14 +145,17 @@ Place a comment immediately before the element to preserve its original formatti
 
 ```html
 <!-- htmlmustache-ignore -->
-<div   class="a"   id="b"  >
-  manually   formatted
-</div>
+<div class="a" id="b">manually formatted</div>
 ```
 
 ```html
 {{! htmlmustache-ignore }}
-<table><tr><td>compact</td><td>table</td></tr></table>
+<table>
+  <tr>
+    <td>compact</td>
+    <td>table</td>
+  </tr>
+</table>
 ```
 
 Only the immediately following sibling node is ignored. Subsequent nodes are formatted normally.
@@ -163,15 +166,15 @@ Wrap a region in start/end comments to preserve everything between them:
 
 ```html
 <!-- htmlmustache-ignore-start -->
-<div   class="a"  >content</div>
-<p>  kept   as-is  </p>
+<div class="a">content</div>
+<p>kept as-is</p>
 <!-- htmlmustache-ignore-end -->
 ```
 
 ```html
-{{! htmlmustache-ignore-start }}
-{{#items}}<li>{{name}}</li>{{/items}}
-{{! htmlmustache-ignore-end }}
+{{! htmlmustache-ignore-start }} {{#items}}
+<li>{{name}}</li>
+{{/items}} {{! htmlmustache-ignore-end }}
 ```
 
 If `ignore-start` has no matching `ignore-end`, all remaining siblings in the current scope are preserved as raw text.

package/cli/out/main.js

@@ -1715,16 +1715,301 @@ function loadConfigFileForPath(filePath) {
   }
 }
 
+// lsp/server/src/htmlBalanceChecker.ts
+function getTagName(element) {
+  const startTag = element.children.find((c) => c.type === "html_start_tag");
+  if (!startTag) return null;
+  const tagNameNode = startTag.children.find((c) => c.type === "html_tag_name");
+  return tagNameNode?.text?.toLowerCase() ?? null;
+}
+function getErroneousEndTagName(node) {
+  const nameNode = node.children.find((c) => c.type === "html_erroneous_end_tag_name");
+  return nameNode?.text?.toLowerCase() ?? null;
+}
+function getSectionName(node) {
+  const beginNode = node.children.find(
+    (c) => c.type === "mustache_section_begin" || c.type === "mustache_inverted_section_begin"
+  );
+  if (!beginNode) return null;
+  const tagNameNode = beginNode.children.find((c) => c.type === "mustache_tag_name");
+  return tagNameNode?.text ?? null;
+}
+function hasForcedEndTag(element) {
+  return element.children.some((c) => c.type === "html_forced_end_tag");
+}
+function extractFromNodes(nodes) {
+  const items = [];
+  for (const node of nodes) {
+    items.push(...extractFromNode(node));
+  }
+  return items;
+}
+function extractFromNode(node) {
+  if (node.type === "html_element") {
+    const contentChildren = node.children.filter(
+      (c) => c.type !== "html_start_tag" && c.type !== "html_end_tag" && c.type !== "html_forced_end_tag"
+    );
+    if (hasForcedEndTag(node)) {
+      const tagName = getTagName(node);
+      const items = [];
+      if (tagName) {
+        const startTag = node.children.find((c) => c.type === "html_start_tag");
+        items.push({ type: "open", tagName, node: startTag ?? node });
+      }
+      items.push(...extractFromNodes(contentChildren));
+      return items;
+    }
+    return extractFromNodes(contentChildren);
+  }
+  if (node.type === "html_self_closing_tag") {
+    return [];
+  }
+  if (node.type === "html_erroneous_end_tag") {
+    const tagName = getErroneousEndTagName(node);
+    if (tagName) {
+      return [{ type: "close", tagName, node }];
+    }
+    return [];
+  }
+  if (node.type === "mustache_section") {
+    const sectionName = getSectionName(node);
+    if (sectionName) {
+      const contentChildren = node.children.filter(
+        (c) => c.type !== "mustache_section_begin" && c.type !== "mustache_section_end" && c.type !== "mustache_erroneous_section_end"
+      );
+      return [
+        {
+          type: "fork",
+          sectionName,
+          truthy: extractFromNodes(contentChildren),
+          falsy: []
+        }
+      ];
+    }
+    return [];
+  }
+  if (node.type === "mustache_inverted_section") {
+    const sectionName = getSectionName(node);
+    if (sectionName) {
+      const contentChildren = node.children.filter(
+        (c) => c.type !== "mustache_inverted_section_begin" && c.type !== "mustache_inverted_section_end" && c.type !== "mustache_erroneous_inverted_section_end"
+      );
+      return [
+        {
+          type: "fork",
+          sectionName,
+          truthy: [],
+          falsy: extractFromNodes(contentChildren)
+        }
+      ];
+    }
+    return [];
+  }
+  return extractFromNodes(node.children);
+}
+function mergeAdjacentForks(items) {
+  if (items.length === 0) return items;
+  const result = [];
+  let i = 0;
+  while (i < items.length) {
+    const item = items[i];
+    if (item.type !== "fork") {
+      result.push(item);
+      i++;
+      continue;
+    }
+    const truthy = [...item.truthy];
+    const falsy = [...item.falsy];
+    let j = i + 1;
+    while (j < items.length) {
+      const next = items[j];
+      if (next.type !== "fork" || next.sectionName !== item.sectionName) break;
+      truthy.push(...next.truthy);
+      falsy.push(...next.falsy);
+      j++;
+    }
+    result.push({
+      type: "fork",
+      sectionName: item.sectionName,
+      truthy: mergeAdjacentForks(truthy),
+      falsy: mergeAdjacentForks(falsy)
+    });
+    i = j;
+  }
+  return result;
+}
+function collectSectionNames(items) {
+  const names = /* @__PURE__ */ new Set();
+  for (const item of items) {
+    if (item.type === "fork") {
+      names.add(item.sectionName);
+      for (const name of collectSectionNames(item.truthy)) names.add(name);
+      for (const name of collectSectionNames(item.falsy)) names.add(name);
+    }
+  }
+  return names;
+}
+function flattenPath(items, assignment) {
+  const events = [];
+  for (const item of items) {
+    if (item.type === "fork") {
+      const value = assignment.get(item.sectionName) ?? true;
+      const branch = value ? item.truthy : item.falsy;
+      events.push(...flattenPath(branch, assignment));
+    } else {
+      events.push(item);
+    }
+  }
+  return events;
+}
+function formatCondition(assignment) {
+  if (assignment.size === 0) return "";
+  const parts = [];
+  for (const [name, value] of assignment) {
+    parts.push(`${name} is ${value ? "truthy" : "falsy"}`);
+  }
+  return ` (when ${parts.join(", ")})`;
+}
+function validateBalance(events, condition) {
+  const errors = [];
+  const stack = [];
+  for (const event of events) {
+    if (event.type === "open") {
+      stack.push(event);
+    } else {
+      if (stack.length === 0) {
+        errors.push({
+          node: event.node,
+          message: `Mismatched HTML end tag: </${event.tagName}>${condition}`
+        });
+      } else {
+        const top = stack[stack.length - 1];
+        if (top.tagName !== event.tagName) {
+          errors.push({
+            node: event.node,
+            message: `Mismatched HTML end tag: </${event.tagName}>${condition}`
+          });
+        } else {
+          stack.pop();
+        }
+      }
+    }
+  }
+  for (const event of stack) {
+    errors.push({
+      node: event.node,
+      message: `Unclosed HTML tag: <${event.tagName}>${condition}`
+    });
+  }
+  return errors;
+}
+var VOID_ELEMENTS = /* @__PURE__ */ new Set([
+  "area",
+  "base",
+  "basefont",
+  "bgsound",
+  "br",
+  "col",
+  "command",
+  "embed",
+  "frame",
+  "hr",
+  "image",
+  "img",
+  "input",
+  "isindex",
+  "keygen",
+  "link",
+  "menuitem",
+  "meta",
+  "nextid",
+  "param",
+  "source",
+  "track",
+  "wbr"
+]);
+var OPTIONAL_END_TAG_ELEMENTS = /* @__PURE__ */ new Set([
+  "li",
+  "dt",
+  "dd",
+  "p",
+  "colgroup",
+  "rb",
+  "rt",
+  "rp",
+  "rtc",
+  "optgroup",
+  "option",
+  "tr",
+  "td",
+  "th",
+  "thead",
+  "tbody",
+  "tfoot",
+  "caption",
+  "html",
+  "head",
+  "body"
+]);
+function checkUnclosedTags(rootNode) {
+  const errors = [];
+  function visit(node) {
+    if (node.type === "html_element") {
+      const hasEndTag = node.children.some((c) => c.type === "html_end_tag");
+      const hasForcedEnd = node.children.some((c) => c.type === "html_forced_end_tag");
+      if (!hasEndTag && !hasForcedEnd) {
+        const tagName = getTagName(node);
+        if (tagName && !VOID_ELEMENTS.has(tagName) && !OPTIONAL_END_TAG_ELEMENTS.has(tagName)) {
+          const startTag = node.children.find((c) => c.type === "html_start_tag");
+          errors.push({
+            node: startTag ?? node,
+            message: `Unclosed HTML tag: <${tagName}>`
+          });
+        }
+      }
+    }
+    for (const child of node.children) {
+      visit(child);
+    }
+  }
+  visit(rootNode);
+  return errors;
+}
+var MAX_SECTION_NAMES = 15;
+function checkHtmlBalance(rootNode) {
+  const rawItems = extractFromNode(rootNode);
+  const items = mergeAdjacentForks(rawItems);
+  const sectionNames = [...collectSectionNames(items)];
+  if (sectionNames.length > MAX_SECTION_NAMES) {
+    return [];
+  }
+  const allErrors = [];
+  const errorNodes = /* @__PURE__ */ new Set();
+  const totalPaths = 1 << sectionNames.length;
+  for (let mask = 0; mask < totalPaths; mask++) {
+    const assignment = /* @__PURE__ */ new Map();
+    for (let i = 0; i < sectionNames.length; i++) {
+      assignment.set(sectionNames[i], (mask & 1 << i) !== 0);
+    }
+    const events = flattenPath(items, assignment);
+    const condition = formatCondition(assignment);
+    const pathErrors = validateBalance(events, condition);
+    for (const error of pathErrors) {
+      if (!errorNodes.has(error.node)) {
+        errorNodes.add(error.node);
+        allErrors.push(error);
+      }
+    }
+  }
+  return allErrors;
+}
+
 // cli/src/check.ts
 function errorMessageForNode(nodeType, node) {
   if (nodeType === "mustache_erroneous_section_end" || nodeType === "mustache_erroneous_inverted_section_end") {
     const tagNameNode = node.children.find((c) => c.type === "mustache_erroneous_tag_name");
     return `Mismatched mustache section: {{/${tagNameNode?.text || "?"}}}`;
   }
-  if (nodeType === "html_erroneous_end_tag") {
-    const tagNameNode = node.children.find((c) => c.type === "html_erroneous_end_tag_name");
-    return `Mismatched HTML end tag: </${tagNameNode?.text || "?"}>`;
-  }
   if (nodeType === "ERROR") {
     return "Syntax error";
   }
@@ -1733,39 +2018,59 @@ function errorMessageForNode(nodeType, node) {
 var ERROR_NODE_TYPES = /* @__PURE__ */ new Set([
   "ERROR",
   "mustache_erroneous_section_end",
-  "mustache_erroneous_inverted_section_end",
-  "html_erroneous_end_tag"
+  "mustache_erroneous_inverted_section_end"
 ]);
 function collectErrors(tree, file) {
   const errors = [];
   const cursor = tree.walk();
-  function visit(insideMustacheSection) {
+  function visit() {
     const node = cursor.currentNode;
     const nodeType = cursor.nodeType;
     if (ERROR_NODE_TYPES.has(nodeType) || cursor.nodeIsMissing) {
-      const skip = insideMustacheSection && nodeType === "html_erroneous_end_tag";
-      if (!skip) {
-        errors.push({
-          file,
-          line: node.startPosition.row + 1,
-          column: node.startPosition.column + 1,
-          endLine: node.endPosition.row + 1,
-          endColumn: node.endPosition.column + 1,
-          message: errorMessageForNode(nodeType, node),
-          nodeText: node.text
-        });
-      }
+      errors.push({
+        file,
+        line: node.startPosition.row + 1,
+        column: node.startPosition.column + 1,
+        endLine: node.endPosition.row + 1,
+        endColumn: node.endPosition.column + 1,
+        message: errorMessageForNode(nodeType, node),
+        nodeText: node.text
+      });
       if (nodeType === "ERROR") return;
     }
-    const enteringMustacheSection = nodeType === "mustache_section" || nodeType === "mustache_inverted_section";
     if (cursor.gotoFirstChild()) {
       do {
-        visit(insideMustacheSection || enteringMustacheSection);
+        visit();
       } while (cursor.gotoNextSibling());
       cursor.gotoParent();
     }
   }
-  visit(false);
+  visit();
+  const rootNode = tree.rootNode;
+  const balanceErrors = checkHtmlBalance(rootNode);
+  for (const error of balanceErrors) {
+    errors.push({
+      file,
+      line: error.node.startPosition.row + 1,
+      column: error.node.startPosition.column + 1,
+      endLine: error.node.endPosition.row + 1,
+      endColumn: error.node.endPosition.column + 1,
+      message: error.message,
+      nodeText: error.node.text
+    });
+  }
+  const unclosedErrors = checkUnclosedTags(rootNode);
+  for (const error of unclosedErrors) {
+    errors.push({
+      file,
+      line: error.node.startPosition.row + 1,
+      column: error.node.startPosition.column + 1,
+      endLine: error.node.endPosition.row + 1,
+      endColumn: error.node.endPosition.column + 1,
+      message: error.message,
+      nodeText: error.node.text
+    });
+  }
   return errors;
 }
 function formatError(error, source) {
@@ -2347,7 +2652,7 @@ function isLine(doc) {
 }
 
 // lsp/server/src/formatting/utils.ts
-function getTagName(node) {
+function getTagName2(node) {
   for (let i = 0; i < node.childCount; i++) {
     const child = node.child(i);
     if (!child) continue;
@@ -2535,7 +2840,7 @@ var PRESERVE_CONTENT_ELEMENTS = /* @__PURE__ */ new Set([
 function getCSSDisplay(node) {
   const type = node.type;
   if (type === "html_element") {
-    const tagName = getTagName(node);
+    const tagName = getTagName2(node);
     if (tagName) {
       if (customCodeTags.has(tagName.toLowerCase())) {
         return "block";
@@ -2591,7 +2896,7 @@ function shouldPreserveContent(node) {
     return true;
   }
   if (type === "html_element") {
-    const tagName = getTagName(node);
+    const tagName = getTagName2(node);
     if (!tagName) return false;
     const lower = tagName.toLowerCase();
     return PRESERVE_CONTENT_ELEMENTS.has(lower) || customCodeTags.has(lower);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@reteps/tree-sitter-htmlmustache",
-  "version": "0.0.39",
+  "version": "0.1.0",
   "description": "HTML with Mustache/Handlebars template syntax grammar for tree-sitter",
   "repository": {
     "type": "git",
@@ -46,9 +46,15 @@
     "tree-sitter": "^0.25.0"
   },
   "peerDependenciesMeta": {
-    "node-addon-api": { "optional": true },
-    "node-gyp-build": { "optional": true },
-    "tree-sitter": { "optional": true }
+    "node-addon-api": {
+      "optional": true
+    },
+    "node-gyp-build": {
+      "optional": true
+    },
+    "tree-sitter": {
+      "optional": true
+    }
   },
   "devDependencies": {
     "@eslint/js": "^9.39.2",