@reteps/tree-sitter-htmlmustache 0.8.1 → 0.9.1

package/src/core/formatting/utils.ts

@@ -0,0 +1,193 @@
+/**
+ * Utility functions for formatting.
+ */
+
+import type { Node as SyntaxNode } from 'web-tree-sitter';
+
+// Re-export getTagName from the canonical location
+export { getTagName } from '../nodeHelpers.js';
+
+/**
+ * Normalize text content - collapse horizontal whitespace while preserving line breaks.
+ */
+export function normalizeText(text: string): string {
+  // Split by newlines, normalize each line, then rejoin
+  // This preserves intentional line breaks while collapsing spaces
+  return text
+    .split('\n')
+    .map((line) => line.replace(/[ \t]+/g, ' ').trim())
+    .filter((line, i, arr) => line || (i > 0 && i < arr.length - 1)) // Keep non-empty lines
+    .join('\n');
+}
+
+/**
+ * Get visible children of a node (excluding anonymous nodes starting with _).
+ */
+export function getVisibleChildren(node: SyntaxNode): SyntaxNode[] {
+  const children: SyntaxNode[] = [];
+  for (let i = 0; i < node.childCount; i++) {
+    const child = node.child(i);
+    if (child && !child.type.startsWith('_')) {
+      children.push(child);
+    }
+  }
+  return children;
+}
+
+/**
+ * Calculate the indent level of a node based on its parent chain.
+ */
+export function calculateIndentLevel(
+  node: SyntaxNode,
+  isBlockLevel: (node: SyntaxNode) => boolean,
+  hasImplicitEndTags: (nodes: SyntaxNode[]) => boolean,
+  getContentNodes: (node: SyntaxNode) => SyntaxNode[]
+): number {
+  let level = 0;
+  let current = node.parent;
+  while (current) {
+    if (isBlockLevel(current)) {
+      // Mustache sections only increase indentation if they have complete HTML
+      // (no implicit end tags crossing boundaries)
+      if (
+        current.type === 'mustache_section' ||
+        current.type === 'mustache_inverted_section'
+      ) {
+        const contentNodes = getContentNodes(current);
+        if (!hasImplicitEndTags(contentNodes)) {
+          level++;
+        }
+      } else {
+        level++;
+      }
+    }
+    current = current.parent;
+  }
+  return level;
+}
+
+/**
+ * Normalize whitespace inside a single mustache expression.
+ * Handles triple ({{{...}}}), prefixed ({{#, {{/, {{^, {{!, {{>), and plain ({{...}}).
+ * For multiline comments, preserves internal newlines, only normalizes space adjacent to delimiters.
+ */
+export function normalizeMustacheWhitespace(raw: string, addSpaces: boolean): string {
+  const space = addSpaces ? ' ' : '';
+
+  // Triple mustache: {{{...}}}
+  const tripleMatch = raw.match(/^\{\{\{([\s\S]*)\}\}\}$/);
+  if (tripleMatch) {
+    const inner = tripleMatch[1].trim();
+    return `{{{${space}${inner}${space}}}}`;
+  }
+
+  // Prefixed: {{#, {{/, {{^, {{!, {{>
+  const prefixedMatch = raw.match(/^\{\{([#/^!>])([\s\S]*)\}\}$/);
+  if (prefixedMatch) {
+    const prefix = prefixedMatch[1];
+    const inner = prefixedMatch[2];
+
+    // Multiline comments: preserve internal newlines, always use spaces
+    if (prefix === '!' && inner.includes('\n')) {
+      const lines = inner.split('\n');
+      const first = lines[0].trimStart();
+      const last = lines[lines.length - 1].trimEnd();
+      if (lines.length === 1) {
+        return `{{${prefix} ${first} }}`;
+      }
+      const middle = lines.slice(1, -1);
+      return `{{${prefix} ${first}\n${middle.join('\n')}\n${last} }}`;
+    }
+
+    const trimmed = inner.trim();
+    // Comments always get spaces for readability, regardless of mustacheSpaces setting
+    const s = prefix === '!' ? ' ' : space;
+    return `{{${prefix}${s}${trimmed}${s}}}`;
+  }
+
+  // Plain: {{...}}
+  const plainMatch = raw.match(/^\{\{([\s\S]*)\}\}$/);
+  if (plainMatch) {
+    const inner = plainMatch[1].trim();
+    return `{{${space}${inner}${space}}}`;
+  }
+
+  return raw;
+}
+
+/**
+ * Normalize whitespace in ALL mustache expressions within a string.
+ * Used for force-inlined sections where the full section text (e.g. `{{#plural}}s{{/plural}}`)
+ * is emitted as one string.
+ */
+export function normalizeMustacheWhitespaceAll(raw: string, addSpaces: boolean): string {
+  // Match triple mustache first, then double
+  return raw.replace(/\{\{\{[\s\S]*?\}\}\}|\{\{[\s\S]*?\}\}/g, (match) => {
+    return normalizeMustacheWhitespace(match, addSpaces);
+  });
+}
+
+/**
+ * Check if a node is a format-ignore directive comment.
+ * Returns the directive type or null if not a directive.
+ */
+export function getIgnoreDirective(
+  node: SyntaxNode
+): 'ignore' | 'ignore-start' | 'ignore-end' | null {
+  if (node.type !== 'html_comment' && node.type !== 'mustache_comment') {
+    return null;
+  }
+
+  let inner: string | null = null;
+
+  if (node.type === 'html_comment') {
+    // <!-- ... -->
+    const match = node.text.match(/^<!--([\s\S]*)-->$/);
+    if (match) {
+      inner = match[1].trim();
+    }
+  } else {
+    // {{! ... }}
+    const match = node.text.match(/^\{\{!([\s\S]*)\}\}$/);
+    if (match) {
+      inner = match[1].trim();
+    }
+  }
+
+  if (!inner) return null;
+
+  if (inner === 'htmlmustache-ignore') return 'ignore';
+  if (inner === 'htmlmustache-ignore-start') return 'ignore-start';
+  if (inner === 'htmlmustache-ignore-end') return 'ignore-end';
+
+  return null;
+}
+
+/**
+ * Find the smallest node that contains the entire range.
+ */
+export function findContainingNode(
+  node: SyntaxNode,
+  startOffset: number,
+  endOffset: number
+): SyntaxNode | null {
+  if (node.startIndex > endOffset || node.endIndex < startOffset) {
+    return null;
+  }
+
+  // Check children first for a more specific match
+  for (let i = 0; i < node.childCount; i++) {
+    const child = node.child(i);
+    if (child && child.startIndex <= startOffset && child.endIndex >= endOffset) {
+      const deeper = findContainingNode(child, startOffset, endOffset);
+      if (deeper) return deeper;
+    }
+  }
+
+  // This node contains the range
+  if (node.startIndex <= startOffset && node.endIndex >= endOffset) {
+    return node;
+  }
+
+  return null;
+}

package/src/core/grammar.ts

@@ -0,0 +1,2 @@
+/** Filename of the compiled grammar WASM, as shipped in this package. */
+export const GRAMMAR_WASM_FILENAME = 'tree-sitter-htmlmustache.wasm';

package/src/core/htmlBalanceChecker.ts

@@ -0,0 +1,382 @@
+import {
+  getTagName,
+  getSectionName,
+  getErroneousEndTagName,
+} from './nodeHelpers.js';
+
+// Minimal syntax node interface for balance checking.
+// Compatible with web-tree-sitter's SyntaxNode.
+export interface BalanceNode {
+  type: string;
+  text: string;
+  startPosition: { row: number; column: number };
+  endPosition: { row: number; column: number };
+  startIndex: number;
+  endIndex: number;
+  children: BalanceNode[];
+}
+
+export interface BalanceError {
+  node: BalanceNode;
+  message: string;
+}
+
+// --- Internal types ---
+
+interface TagEvent {
+  type: 'open' | 'close';
+  tagName: string;
+  node: BalanceNode;
+}
+
+interface ConditionalFork {
+  type: 'fork';
+  sectionName: string;
+  truthy: PathItem[];
+  falsy: PathItem[];
+}
+
+type PathItem = TagEvent | ConditionalFork;
+
+// --- Phase 1: Extract tag events from parse tree ---
+
+// Re-export for consumers that import from this module
+export { getSectionName } from './nodeHelpers.js';
+
+function getTagNameLower(element: BalanceNode): string | null {
+  return getTagName(element)?.toLowerCase() ?? null;
+}
+
+function getErroneousEndTagNameLower(node: BalanceNode): string | null {
+  return getErroneousEndTagName(node)?.toLowerCase() ?? null;
+}
+
+function hasForcedEndTag(element: BalanceNode): boolean {
+  return element.children.some(c => c.type === 'html_forced_end_tag');
+}
+
+function extractFromNodes(nodes: BalanceNode[]): PathItem[] {
+  const items: PathItem[] = [];
+  for (const node of nodes) {
+    items.push(...extractFromNode(node));
+  }
+  return items;
+}
+
+function extractFromNode(node: BalanceNode): PathItem[] {
+  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 = getTagNameLower(node);
+      const items: PathItem[] = [];
+      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;
+    }
+
+    // Balanced or implicit close — recurse into content for inner forks
+    return extractFromNodes(contentChildren);
+  }
+
+  if (node.type === 'html_self_closing_tag') {
+    return [];
+  }
+
+  if (node.type === 'html_erroneous_end_tag') {
+    const tagName = getErroneousEndTagNameLower(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 [];
+  }
+
+  // For any other node type, recurse into children
+  return extractFromNodes(node.children);
+}
+
+// --- Phase 2: Merge adjacent same-named forks ---
+
+function mergeAdjacentForks(items: PathItem[]): PathItem[] {
+  if (items.length === 0) return items;
+
+  const result: PathItem[] = [];
+  let i = 0;
+
+  while (i < items.length) {
+    const item = items[i];
+    if (item.type !== 'fork') {
+      result.push(item);
+      i++;
+      continue;
+    }
+
+    // Merge consecutive forks with the same section name
+    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++;
+    }
+
+    // Recursively merge within branches
+    result.push({
+      type: 'fork',
+      sectionName: item.sectionName,
+      truthy: mergeAdjacentForks(truthy),
+      falsy: mergeAdjacentForks(falsy),
+    });
+    i = j;
+  }
+
+  return result;
+}
+
+// --- Phase 3: Enumerate paths and validate balance ---
+
+/**
+ * Check if a branch (list of PathItems) is self-balanced: all opens are matched
+ * by closes in LIFO order, leaving the stack empty. Nested forks are balanced
+ * only if both their branches are independently balanced (making the fork a no-op).
+ */
+function isBranchBalanced(items: PathItem[]): boolean {
+  const stack: string[] = [];
+  for (const item of items) {
+    if (item.type === 'fork') {
+      if (!isBranchBalanced(item.truthy) || !isBranchBalanced(item.falsy)) {
+        return false;
+      }
+    } else if (item.type === 'open') {
+      stack.push(item.tagName);
+    } else {
+      if (stack.length === 0 || stack[stack.length - 1] !== item.tagName) {
+        return false;
+      }
+      stack.pop();
+    }
+  }
+  return stack.length === 0;
+}
+
+/**
+ * Collect only section names that affect HTML tag balance.
+ * A fork only matters if at least one of its branches is unbalanced.
+ * Forks where both branches are independently balanced (e.g. truthy has
+ * matched open/close pairs and falsy is empty) are no-ops and skipped.
+ * This reduces 2^N enumeration to only the relevant variables.
+ */
+function collectSectionNames(items: PathItem[]): Set<string> {
+  const names = new Set<string>();
+  for (const item of items) {
+    if (item.type === 'fork') {
+      if (!isBranchBalanced(item.truthy) || !isBranchBalanced(item.falsy)) {
+        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: PathItem[], assignment: Map<string, boolean>): TagEvent[] {
+  const events: TagEvent[] = [];
+  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: Map<string, boolean>): string {
+  if (assignment.size === 0) return '';
+  const parts: string[] = [];
+  for (const [name, value] of assignment) {
+    parts.push(`${name} is ${value ? 'truthy' : 'falsy'}`);
+  }
+  return ` (when ${parts.join(', ')})`;
+}
+
+function validateBalance(events: TagEvent[], condition: string): BalanceError[] {
+  const errors: BalanceError[] = [];
+  const stack: TagEvent[] = [];
+
+  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;
+}
+
+// --- Unclosed tag detection ---
+
+const VOID_ELEMENTS = 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',
+]);
+
+const OPTIONAL_END_TAG_ELEMENTS = new Set([
+  'li', 'dt', 'dd', 'p', 'colgroup',
+  'rb', 'rt', 'rp', 'rtc',
+  'optgroup', 'option',
+  'tr', 'td', 'th',
+  'thead', 'tbody', 'tfoot',
+  'caption',
+  'html', 'head', 'body',
+]);
+
+export function checkUnclosedTags(rootNode: BalanceNode): BalanceError[] {
+  const errors: BalanceError[] = [];
+
+  function visit(node: BalanceNode) {
+    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 = getTagNameLower(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;
+}
+
+const MAX_SECTION_NAMES = 15;
+
+export function checkHtmlBalance(rootNode: BalanceNode): BalanceError[] {
+  // Phase 1: Extract tag events
+  const rawItems = extractFromNode(rootNode);
+
+  // Phase 2: Merge adjacent same-named forks
+  const items = mergeAdjacentForks(rawItems);
+
+  // Phase 3: Enumerate all boolean paths and validate
+  const sectionNames = [...collectSectionNames(items)];
+  if (sectionNames.length > MAX_SECTION_NAMES) {
+    return []; // Safety valve: too many combinations
+  }
+
+  const allErrors: BalanceError[] = [];
+  const errorNodes = new Set<BalanceNode>();
+  const totalPaths = 1 << sectionNames.length;
+
+  for (let mask = 0; mask < totalPaths; mask++) {
+    const assignment = new Map<string, boolean>();
+    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;
+}