const counts = new Map<string, number>();

const refsByKey = new Map<string, string[]>();

const nodesByRef = new Map<string, RoleTreeNode>();

const refs: Record<string, CdpRoleRef> = {};

for (const node of tree) {

const role = node.role.toLowerCase();

params.nextRef.value += 1;

node.ref = ref;

node.nth = nth;

refsByKey.set(key, [...(refsByKey.get(key) ?? []), ref]);

const refsForKey = refsByKey.get(key);

if (refsForKey) {

refsForKey.push(ref);

} else {

refsByKey.set(key, [ref]);

}

nodesByRef.set(ref, node);

refs[ref] = {

role,

...(node.name ? { name: node.name } : {}),

const ref = refList[0];

if (ref) {

delete refs[ref]?.nth;

const node = tree.find((entry) => entry.ref === ref);

const node = nodesByRef.get(ref);

if (node) {

delete node.nth;

}

expect(res.snapshot).not.toContain("button");

});

it("keeps named branches with refs and drops empty branches when compact", () => {

const aria = ['- list "Menu":', ' - button "Save"', '- list "Empty":', " - generic"].join(

"\n",

);

const res = buildRoleSnapshotFromAriaSnapshot(aria, { compact: true });

expect(res.snapshot).toBe('- list "Menu":\n - button "Save" [ref=e1]');

});

it("computes stats", () => {

const aria = ['- button "OK"', '- button "Cancel"'].join("\n");

const res = buildRoleSnapshotFromAriaSnapshot(aria);

function compactTree(tree: string) {

const lines = tree.split("\n");

const result: string[] = [];

const entries: Array<{ line: string; keep: boolean; hasRef: boolean; indent: number }> = [];

const stack: Array<{ entry: (typeof entries)[number]; indent: number }> = [];

for (let i = 0; i < lines.length; i += 1) {

const line = lines[i];

if (line.includes("[ref=")) {

result.push(line);

continue;

const finishEntry = () => {

const current = stack.pop();

if (!current) {

return;

}

if (line.includes(":") && !line.trimEnd().endsWith(":")) {

result.push(line);

continue;

current.entry.keep ||= current.entry.hasRef;

if (current.entry.hasRef && stack.length > 0) {

stack[stack.length - 1].entry.hasRef = true;

}

};

const currentIndent = getIndentLevel(line);

let hasRelevantChildren = false;

for (let j = i + 1; j < lines.length; j += 1) {

const childIndent = getIndentLevel(lines[j]);

if (childIndent <= currentIndent) {

break;

}

if (lines[j]?.includes("[ref=")) {

hasRelevantChildren = true;

break;

}

}

if (hasRelevantChildren) {

result.push(line);

for (const line of lines) {

const indent = getIndentLevel(line);

while (stack.length > 0 && stack[stack.length - 1].indent >= indent) {

finishEntry();

}

const entry = {

line,

keep: line.includes("[ref=") || (line.includes(":") && !line.trimEnd().endsWith(":")),

hasRef: line.includes("[ref="),

indent,

};

entries.push(entry);

stack.push({ entry, indent });

}

while (stack.length > 0) {

finishEntry();

}

return result.join("\n");

return entries

.filter((entry) => entry.keep)

.map((entry) => entry.line)

.join("\n");

}

function processLine(

const key = `${role}:${name ?? ""}`;

const nth = counts.get(key) ?? 0;

counts.set(key, nth + 1);

refsByKey.set(key, [...(refsByKey.get(key) ?? []), node.ref]);

const refsForKey = refsByKey.get(key);

if (refsForKey) {

refsForKey.push(node.ref);

} else {

refsByKey.set(key, [node.ref]);

}

refs[node.ref] = {

role,

...(name ? { name } : {}),