fix(visual-edits): limita contribuintes ao escopo do elemento clicado

Ao clicar num elemento no preview, o dropdown listava todos os contribuintes
da cadeia de concatenação inteira (ex.: o VAR completo onde a expressão
estava), incluindo divs/spans irmãos que não fazem parte do trecho clicado.

Agora, ao indexar contribuintes, balanceamos abre/fecha da tag no source a
partir do literal de abertura para delimitar o range exato do elemento.
Apenas literais e refs de VAR cujo refLoc/loc cai dentro desse range são
mantidos. O `rootLoc` (usado por "Trecho HTML final") também passa a apontar
para o range do elemento, não para a cadeia inteira.

Author: claude

src/lib/daxParser/varDependencies.ts

@@ -11,6 +11,52 @@ import type { Contributor, ContributorIndex, ContributorsEntry, Node, SourceLoc
 const OPEN_TAG_RE = /<([a-zA-Z][a-zA-Z0-9-]*)(\s|\/|>)/;
 const TAG_SPLIT_RE = /<\/?[a-zA-Z][^>]*>|<!--[\s\S]*?-->/g;
 
+// Elementos void/auto-fechados: não possuem conteúdo nem tag de fechamento.
+const VOID_ELEMENTS = new Set([
+  'area', 'base', 'br', 'col', 'embed', 'hr', 'img', 'input',
+  'keygen', 'link', 'meta', 'param', 'source', 'track', 'wbr',
+]);
+
+function locOfContributor(c: Contributor): SourceLoc {
+  if (c.kind === 'var') return c.refLoc;
+  return c.loc;
+}
+
+// Dado o literal que abre uma tag HTML, varre o source à frente balanceando
+// abre/fecha da mesma tag para localizar o ponto onde o elemento termina.
+// Retorna a posição no source logo após o ">" do fechamento (ou o final do
+// source se não houver correspondência).
+function findElementEnd(src: string, openLoc: SourceLoc, tagName: string): number {
+  if (VOID_ELEMENTS.has(tagName)) return openLoc.end;
+  const re = new RegExp(`<(/?)${tagName}\\b[^>]*?(/?)>`, 'gi');
+  re.lastIndex = openLoc.end;
+  let depth = 1;
+  let m: RegExpExecArray | null;
+  while ((m = re.exec(src)) !== null) {
+    const isClose = m[1] === '/';
+    const selfClose = m[2] === '/';
+    if (isClose) {
+      depth--;
+      if (depth === 0) {
+        let end = m.index + m[0].length;
+        // Inclui a aspas de fechamento do literal, se presente, para que o
+        // range cubra `"</tag>"` inteiro no source.
+        if (src[end] === '"' || src[end] === "'") end++;
+        return end;
+      }
+    } else if (!selfClose) {
+      depth++;
+    }
+  }
+  return src.length;
+}
+
+function extractOpenTagName(src: string, openLoc: SourceLoc): string | null {
+  const content = src.slice(openLoc.start + 1, openLoc.end - 1);
+  const m = OPEN_TAG_RE.exec(content);
+  return m ? m[1].toLowerCase() : null;
+}
+
 interface VarRecord {
   declLoc: SourceLoc;
 }
@@ -156,29 +202,6 @@ function collectContributors(
   }
 }
 
-function rangeOf(node: Node): SourceLoc | undefined {
-  if (node.loc) return node.loc;
-  switch (node.kind) {
-    case 'binop': {
-      const l = rangeOf(node.left);
-      const r = rangeOf(node.right);
-      if (l && r) return { start: l.start, end: r.end };
-      return l ?? r;
-    }
-    case 'unop':
-      return rangeOf(node.arg);
-    case 'call':
-      if (node.args.length > 0) {
-        const first = rangeOf(node.args[0]);
-        const last = rangeOf(node.args[node.args.length - 1]);
-        if (first && last) return { start: first.start, end: last.end };
-      }
-      return undefined;
-    default:
-      return undefined;
-  }
-}
-
 export function buildContributorIndex(ast: Node, src: string): ContributorIndex {
   const index: ContributorIndex = {};
 
@@ -189,12 +212,26 @@ export function buildContributorIndex(ast: Node, src: string): ContributorIndex
         if (!OPEN_TAG_RE.test(n.value)) return;
         const key = `${n.loc.start}-${n.loc.end}`;
         if (index[key]) return; // already indexed (same literal seen via outer walk)
-        const items: Contributor[] = [];
-        collectContributors(concatRoot, scopes, src, items);
-        const root = rangeOf(concatRoot) ?? n.loc;
+
+        // Coleta candidatos a partir da cadeia de concatenação inteira, mas
+        // mantém apenas os que estão DENTRO do range de source do elemento
+        // clicado — i.e., entre seu literal de abertura e o `</tag>` que o
+        // fecha, balanceando aninhamento da mesma tag.
+        const all: Contributor[] = [];
+        collectContributors(concatRoot, scopes, src, all);
+
+        const tagName = extractOpenTagName(src, n.loc);
+        const elemEnd = tagName ? findElementEnd(src, n.loc, tagName) : n.loc.end;
+        const elemLoc: SourceLoc = { start: n.loc.start, end: elemEnd };
+
+        const items = all.filter((c) => {
+          const l = locOfContributor(c);
+          return l.start >= elemLoc.start && l.end <= elemLoc.end;
+        });
+
         const entry: ContributorsEntry = {
-          rootLoc: root,
-          rootLine: lineOf(src, root.start),
+          rootLoc: elemLoc,
+          rootLine: lineOf(src, elemLoc.start),
           items,
         };
         index[key] = entry;