@szc-ft/mcp-szcd-client 0.27.3 → 0.27.4

package/lib/browser-engine.js

@@ -269,12 +269,28 @@ export class BrowserEngine {
                     .filter(isCandidate);
             }
 
+            function isVisibleEnabled(el) {
+                const rect = el.getBoundingClientRect();
+                const style = window.getComputedStyle(el);
+                if (rect.width <= 0 || rect.height <= 0) return false;
+                if (style.display === "none" || style.visibility === "hidden" || Number(style.opacity) === 0) return false;
+                if (el.disabled || el.getAttribute("aria-disabled") === "true") return false;
+                return true;
+            }
+
             function findBySelector(selector) {
                 if (!selector) return null;
                 if (selector.startsWith("text=")) {
                     const expected = selector.slice(5).trim();
-                    return interactiveElements().find((el) => getText(el).includes(expected) || getName(el, getText(el)).includes(expected)) ||
-                        Array.from(document.querySelectorAll("*")).find((el) => getText(el).includes(expected));
+                    // 默认仅匹配 visible+enabled 元素，避免命中 ant-select 的隐藏 input、收起菜单里的 li
+                    // 需要包含隐藏元素时显式 includeHidden=true
+                    const includeHidden = actOptions.includeHidden === true;
+                    const filter = (el) => includeHidden || isVisibleEnabled(el);
+                    const interactive = interactiveElements().filter(filter);
+                    let hit = interactive.find((el) => getText(el).includes(expected) || getName(el, getText(el)).includes(expected));
+                    if (hit) return hit;
+                    const all = Array.from(document.querySelectorAll("*")).filter(filter);
+                    return all.find((el) => getText(el).includes(expected)) || null;
                 }
                 if (selector.startsWith("role=")) {
                     const match = selector.match(/^role=([^\[]+)(?:\[name="([^"]+)"\])?/);
@@ -357,6 +373,7 @@ export class BrowserEngine {
             action,
             typeText,
             clear: Boolean(options.clear),
+            includeHidden: Boolean(options.includeHidden),
         });
 
         if (!result.found) {
@@ -385,140 +402,207 @@ export class BrowserEngine {
             ? options.menuPath
             : String(options.menuPath).split("/").map((item) => item.trim()).filter(Boolean);
         const waitAfterEach = Number.parseInt(options.waitAfterEach ?? 300, 10);
+        const drawerTriggerSelector = options.drawerTriggerSelector || null;
+        const drawerOpenSelector = options.drawerOpenSelector || ".ant-drawer-open, .ant-drawer.ant-drawer-open";
+        const scrollContainerSelector = options.menuScrollContainer || null;
+        const useNativeHover = options.useNativeHover !== false; // 默认开
+        const maxRetryPerStep = Number.parseInt(options.maxRetryPerStep ?? 2, 10);
 
         if (menuPath.length === 0) {
             throw new Error("menuPath is empty");
         }
 
-        const result = await targetFrame.frame.evaluate(async (pathItems, waitMs) => {
-            function sleep(ms) {
-                return new Promise((resolve) => setTimeout(resolve, ms));
-            }
-
-            function textOf(el) {
-                return (el.innerText || el.textContent || "").replace(/\s+/g, " ").trim();
-            }
-
-            function classText(el) {
-                return typeof el.className === "string" ? el.className : "";
-            }
-
-            function isVisible(el) {
-                const rect = el.getBoundingClientRect();
-                const style = window.getComputedStyle(el);
-                return rect.width > 0 && rect.height > 0 && style.display !== "none" && style.visibility !== "hidden";
-            }
-
-            function menuCandidates() {
-                return Array.from(document.querySelectorAll([
-                    "[role='menuitem']",
-                    ".ant-menu-item",
-                    ".ant-menu-submenu-title",
-                    "li[class*='menu']",
-                    "a",
-                    "button",
-                    "[class*='menu-item']",
-                    "[class*='submenu']",
-                ].join(","))).filter(isVisible);
-            }
+        const frame = targetFrame.frame;
 
-            function scoreCandidate(el, text, level) {
-                const actual = textOf(el);
-                if (!actual) return -1;
-                let score = -1;
-                if (actual === text) score = 100;
-                else if (actual.includes(text)) score = 70;
-                else if (text.includes(actual)) score = 50;
-                if (score < 0) return -1;
-                const cls = classText(el);
-                const role = el.getAttribute("role") || "";
-                if (role === "menuitem") score += 10;
-                if (cls.includes("ant-menu-submenu-title")) score += level < pathItems.length - 1 ? 20 : -5;
-                if (cls.includes("ant-menu-item")) score += level === pathItems.length - 1 ? 20 : 0;
-                if (cls.includes("ant-menu-item-selected")) score += 5;
-                return score;
-            }
+        const ensureDrawerOpen = async () => {
+            if (!drawerTriggerSelector) return { ensured: false, reason: "no drawer" };
+            const isOpen = await frame.evaluate((sel) => !!document.querySelector(sel), drawerOpenSelector).catch(() => false);
+            if (isOpen) return { ensured: true, reason: "already open" };
+            const triggered = await frame.evaluate((sel) => {
+                const el = document.querySelector(sel);
+                if (!el) return false;
+                el.scrollIntoView({ block: "center", inline: "center" });
+                el.click();
+                return true;
+            }, drawerTriggerSelector).catch(() => false);
+            if (!triggered) return { ensured: false, reason: "trigger not found" };
+            await new Promise((r) => setTimeout(r, waitAfterEach));
+            return { ensured: true, reason: "clicked trigger" };
+        };
 
-            function findMenuItem(text, level) {
-                return menuCandidates()
-                    .map((el) => ({ el, score: scoreCandidate(el, text, level), text: textOf(el) }))
-                    .filter((item) => item.score >= 0)
-                    .sort((a, b) => b.score - a.score)[0] || null;
-            }
+        const scrollContainerOnce = async () => {
+            if (!scrollContainerSelector) return false;
+            return frame.evaluate((sel) => {
+                const c = document.querySelector(sel);
+                if (!c) return false;
+                c.scrollTop = Math.min(c.scrollTop + Math.max(c.clientHeight - 40, 200), c.scrollHeight);
+                return true;
+            }, scrollContainerSelector).catch(() => false);
+        };
 
-            function elementSnapshot(el) {
-                const rect = el.getBoundingClientRect();
+        const findStep = async (text, level) => {
+            return frame.evaluate((expectedText, lvl, totalLevels) => {
+                function textOf(el) {
+                    return (el.innerText || el.textContent || "").replace(/\s+/g, " ").trim();
+                }
+                function classText(el) {
+                    return typeof el.className === "string" ? el.className : "";
+                }
+                function isVisible(el) {
+                    const rect = el.getBoundingClientRect();
+                    const style = window.getComputedStyle(el);
+                    return rect.width > 0 && rect.height > 0 && style.display !== "none" && style.visibility !== "hidden";
+                }
+                function menuCandidates() {
+                    return Array.from(document.querySelectorAll([
+                        "[role='menuitem']",
+                        ".ant-menu-item",
+                        ".ant-menu-submenu-title",
+                        "li[class*='menu']",
+                        "a",
+                        "button",
+                        "[class*='menu-item']",
+                        "[class*='submenu']",
+                    ].join(","))).filter(isVisible);
+                }
+                function score(el) {
+                    const actual = textOf(el);
+                    if (!actual) return -1;
+                    let s = -1;
+                    if (actual === expectedText) s = 100;
+                    else if (actual.includes(expectedText)) s = 70;
+                    else if (expectedText.includes(actual)) s = 50;
+                    if (s < 0) return -1;
+                    const cls = classText(el);
+                    const role = el.getAttribute("role") || "";
+                    if (role === "menuitem") s += 10;
+                    if (cls.includes("ant-menu-submenu-title")) s += lvl < totalLevels - 1 ? 20 : -5;
+                    if (cls.includes("ant-menu-item")) s += lvl === totalLevels - 1 ? 20 : 0;
+                    if (cls.includes("ant-menu-item-selected")) s += 5;
+                    return s;
+                }
+                const ranked = menuCandidates()
+                    .map((el) => ({ el, s: score(el), text: textOf(el) }))
+                    .filter((x) => x.s >= 0)
+                    .sort((a, b) => b.s - a.s);
+                const top = ranked[0];
+                if (!top) {
+                    return {
+                        found: false,
+                        candidates: menuCandidates().slice(0, 8).map((el) => ({
+                            text: textOf(el).slice(0, 80),
+                            className: classText(el).slice(0, 120),
+                        })),
+                    };
+                }
+                // 用稳定 attr 标记，避免后续 click 时 ranking 漂移
+                top.el.setAttribute("data-szcd-menu-target", "1");
+                const rect = top.el.getBoundingClientRect();
                 return {
-                    tagName: el.tagName,
-                    text: textOf(el).slice(0, 120),
-                    role: el.getAttribute("role") || null,
-                    className: classText(el),
-                    ariaExpanded: el.getAttribute("aria-expanded"),
+                    found: true,
+                    matchedText: top.text,
                     bbox: {
-                        x: Math.round(rect.x),
-                        y: Math.round(rect.y),
-                        width: Math.round(rect.width),
-                        height: Math.round(rect.height),
+                        x: Math.round(rect.x), y: Math.round(rect.y),
+                        width: Math.round(rect.width), height: Math.round(rect.height),
+                    },
+                    snapshot: {
+                        tagName: top.el.tagName,
+                        text: textOf(top.el).slice(0, 120),
+                        role: top.el.getAttribute("role") || null,
+                        className: classText(top.el),
+                        ariaExpanded: top.el.getAttribute("aria-expanded"),
                     },
                 };
-            }
-
-            const steps = [];
-
-            for (let i = 0; i < pathItems.length; i++) {
-                const text = pathItems[i];
-                let match = findMenuItem(text, i);
-                if (!match && i > 0) {
-                    await sleep(waitMs * 2);
-                    match = findMenuItem(text, i);
-                }
-                if (!match) {
-                    return { found: false, failedAt: text, steps };
-                }
+            }, text, level, menuPath.length).catch(() => ({ found: false, candidates: [] }));
+        };
 
-                const el = match.el;
+        const clickStep = async (isLast) => {
+            return frame.evaluate(async (waitMs, last) => {
+                const el = document.querySelector("[data-szcd-menu-target='1']");
+                if (!el) return { performed: false, error: "marker lost" };
                 el.scrollIntoView({ block: "center", inline: "center" });
                 const beforeUrl = location.href;
                 const beforeText = document.body?.innerText || "";
-                const isLast = i === pathItems.length - 1;
-                const before = elementSnapshot(el);
-
-                el.dispatchEvent(new MouseEvent("mouseover", { bubbles: true }));
-                el.dispatchEvent(new MouseEvent("mouseenter", { bubbles: true }));
                 el.click();
-                await sleep(waitMs);
-
-                const afterClass = classText(el);
-                const afterExpanded = el.getAttribute("aria-expanded");
-                steps.push({
-                    text,
-                    action: isLast ? "click" : "expand",
-                    status: "PASS",
-                    matchedText: match.text,
-                    before,
+                el.removeAttribute("data-szcd-menu-target");
+                await new Promise((r) => setTimeout(r, waitMs));
+                const cls = typeof el.className === "string" ? el.className : "";
+                return {
+                    performed: true,
+                    action: last ? "click" : "expand",
                     after: {
-                        className: afterClass,
-                        ariaExpanded: afterExpanded,
+                        className: cls,
+                        ariaExpanded: el.getAttribute("aria-expanded"),
                         urlChanged: location.href !== beforeUrl,
                         textChanged: (document.body?.innerText || "") !== beforeText,
-                        selected: afterClass.includes("selected") || afterClass.includes("active"),
+                        selected: cls.includes("selected") || cls.includes("active"),
                     },
-                });
+                };
+            }, waitAfterEach, isLast);
+        };
+
+        const steps = [];
+
+        for (let i = 0; i < menuPath.length; i++) {
+            const text = menuPath[i];
+            const isLast = i === menuPath.length - 1;
+
+            // 抽屉式菜单：每级前都先确认抽屉是开的
+            const drawerState = await ensureDrawerOpen();
+
+            let match = await findStep(text, i);
+            let attempts = 0;
+            while (!match.found && attempts < maxRetryPerStep) {
+                attempts += 1;
+                // 滚动一次再找
+                const scrolled = await scrollContainerOnce();
+                if (!scrolled) await new Promise((r) => setTimeout(r, waitAfterEach));
+                match = await findStep(text, i);
             }
 
-            return {
-                found: true,
-                performed: true,
-                steps,
-                currentUrl: location.href,
-                title: document.title,
-            };
-        }, menuPath, waitAfterEach);
+            if (!match.found) {
+                return {
+                    acted: false,
+                    action: "menuPath",
+                    menuPath,
+                    target: {
+                        frameId: targetFrame.frameId,
+                        frameUrl: targetFrame.frame.url(),
+                        matchedBy: targetFrame.matchedBy,
+                    },
+                    failedAt: text,
+                    failedAtIndex: i,
+                    candidates: match.candidates || [],
+                    drawerState,
+                    steps,
+                };
+            }
 
-        if (!result.found) {
-            throw new Error(`Menu path item not found: ${result.failedAt}`);
+            // native hover（puppeteer frame.hover），优于 dispatchEvent
+            if (useNativeHover && typeof frame.hover === "function") {
+                try {
+                    await frame.hover("[data-szcd-menu-target='1']");
+                } catch {
+                    // hover 失败不致命，继续 click
+                }
+            }
+
+            const clickRes = await clickStep(isLast);
+            steps.push({
+                text,
+                action: clickRes.action || (isLast ? "click" : "expand"),
+                status: clickRes.performed ? "PASS" : "FAIL",
+                matchedText: match.matchedText,
+                before: match.snapshot,
+                after: clickRes.after || null,
+                drawerEnsured: drawerState.ensured,
+                retries: attempts,
+            });
         }
 
+        const currentUrl = this.page.url();
+        const title = await this.page.title().catch(() => "");
+
         return {
             acted: true,
             action: "menuPath",
@@ -528,9 +612,9 @@ export class BrowserEngine {
                 frameUrl: targetFrame.frame.url(),
                 matchedBy: targetFrame.matchedBy,
             },
-            steps: result.steps,
-            currentUrl: result.currentUrl,
-            title: result.title,
+            steps,
+            currentUrl,
+            title,
         };
     }
 
@@ -670,7 +754,7 @@ export class BrowserEngine {
         });
 
         const pageTarget = this.page.target();
-        const attachCandidates = this.browser.targets().filter((target) => {
+        const pickCandidates = () => this.browser.targets().filter((target) => {
             if (target === pageTarget) return false;
             if (!["iframe", "page"].includes(target.type())) return false;
             const targetUrl = target.url() || "";
@@ -681,15 +765,33 @@ export class BrowserEngine {
             return true;
         });
 
-        for (const target of attachCandidates) {
-            const session = await target.createCDPSession().catch(() => null);
-            if (!session) continue;
-            await addSession(session, {
-                id: target.url() || `${target.type()}-${targets.length}`,
-                type: target.type(),
-                url: target.url() || "",
-                matchedBy: "browser.targets",
-            });
+        const attachOnce = async (candidates) => {
+            for (const target of candidates) {
+                const session = await target.createCDPSession().catch(() => null);
+                if (!session) continue;
+                await addSession(session, {
+                    id: target.url() || `${target.type()}-${targets.length}`,
+                    type: target.type(),
+                    url: target.url() || "",
+                    matchedBy: "browser.targets",
+                });
+            }
+        };
+
+        // 微前端 wujie/qiankun 时序：iframe target 可能在主页面 ready 后才注册
+        // attach=0 时延迟重试，最多 3 次（含首次）
+        const maxAttachTries = Number.parseInt(options.attachRetries ?? 3, 10);
+        const attachRetryDelay = Number.parseInt(options.attachRetryDelay ?? 1500, 10);
+        let attachCandidates = pickCandidates();
+        let tries = 1;
+        await attachOnce(attachCandidates);
+        const attachLog = [{ try: 1, count: attachCandidates.length }];
+        while (attachCandidates.length === 0 && tries < maxAttachTries) {
+            tries += 1;
+            await new Promise((r) => setTimeout(r, attachRetryDelay));
+            attachCandidates = pickCandidates();
+            attachLog.push({ try: tries, count: attachCandidates.length });
+            await attachOnce(attachCandidates);
         }
 
         if (options.reload) {
@@ -723,6 +825,7 @@ export class BrowserEngine {
                 success: requestList.length - failed.length,
                 failed: failed.length,
                 targets: targets.length,
+                attachLog,
                 duration: Date.now() - startedAt,
             },
         };
@@ -1021,6 +1124,8 @@ export class BrowserEngine {
             case "findFrame":    return this._findFrame(step);
             case "loginWait":    return this._loginWait(step);
             case "aiAssert":     return this._aiAssert(step, context);
+            case "runTask":      return this.runTask(step, context);
+            case "run-task":     return this.runTask(step, context);
             default:
                 throw new Error(`Unknown step type: ${step.type}`);
         }
@@ -1435,6 +1540,205 @@ export class BrowserEngine {
         };
     }
 
+    /**
+     * 高层 runner：把"批量探索动态菜单 + 抓接口 + 出报告"打包成一个 step。
+     * 当前仅支持 task='menu-api-scan'，对应反馈中"129 路由全覆盖"场景。
+     *
+     * options:
+     *   task: "menu-api-scan"
+     *   menuApiPattern (string|RegExp 默认 /listUserViewMenus/) — 用作 _discoverMenus 的 lastApiCapture 过滤
+     *   menuLimit (number 默认 0=不限) — 仅探索前 N 条
+     *   menuPathPrefix (Array<string>) — 仅探索 path 开头匹配的菜单
+     *   menuFilter (Array<string>) — 仅探索 name/path 包含任一关键字的菜单
+     *   drawerTriggerSelector / drawerOpenSelector / menuScrollContainer / useNativeHover / maxRetryPerStep — 透传 _actMenuPath
+     *   apiCaptureOptions (object) — 透传 captureApi
+     *   continueOnFail (bool 默认 true)
+     *   snapshotEach (bool 默认 false) — 每条菜单后做轻量 observe
+     *   screenshotEach (bool 默认 false) — 失败时截图（依赖 context.outputDir）
+     */
+    async runTask(step, context = {}) {
+        const taskName = step.task || step.name || "menu-api-scan";
+        if (taskName !== "menu-api-scan") {
+            return { task: taskName, supported: false, error: `Unsupported task: ${taskName}` };
+        }
+
+        const menus = await this._discoverMenus(step, context);
+        if (!menus.length) {
+            return {
+                task: taskName,
+                discovered: 0,
+                error: "No menus discovered. Run apiCapture targeting menuApiPattern first, or provide step.menus directly.",
+            };
+        }
+
+        const limit = Number.parseInt(step.menuLimit ?? 0, 10);
+        const candidates = limit > 0 ? menus.slice(0, limit) : menus;
+        const continueOnFail = step.continueOnFail !== false;
+        const startedAt = Date.now();
+        const results = [];
+        const byOutcome = { clickFailed: 0, noApi: 0, apiOk: 0, apiFailed: 0 };
+
+        for (let i = 0; i < candidates.length; i += 1) {
+            const menu = candidates[i];
+            const itemStartedAt = Date.now();
+            const item = {
+                index: i,
+                menu: { path: menu.path, name: menu.name, names: menu.names },
+                outcome: null,
+            };
+
+            // 1. 点菜单链路（走 act 顶层入口，让它先 _resolveObserveFrame 再分发到 _actMenuPath）
+            const menuStep = {
+                menuPath: menu.names,
+                drawerTriggerSelector: step.drawerTriggerSelector,
+                drawerOpenSelector: step.drawerOpenSelector,
+                menuScrollContainer: step.menuScrollContainer,
+                useNativeHover: step.useNativeHover,
+                maxRetryPerStep: step.maxRetryPerStep,
+                stepDelay: step.stepDelay,
+                frameContentContains: step.frameContentContains,
+                frameUrlContains: step.frameUrlContains,
+                frameIndex: step.frameIndex,
+            };
+            let menuResult;
+            try {
+                menuResult = await this.act(menuStep);
+            } catch (err) {
+                menuResult = { acted: false, error: err.message };
+            }
+            item.menuResult = menuResult;
+
+            if (!menuResult || menuResult.acted === false) {
+                item.outcome = "clickFailed";
+                byOutcome.clickFailed += 1;
+                if (step.screenshotEach) {
+                    try {
+                        const shot = await this._screenshot({ filename: `runTask-fail-${i}.png`, fullPage: true }, context);
+                        item.screenshot = shot;
+                    } catch {
+                        // ignore
+                    }
+                }
+                results.push({ ...item, durationMs: Date.now() - itemStartedAt });
+                if (!continueOnFail) break;
+                continue;
+            }
+
+            // 2. 抓接口
+            const apiStep = {
+                type: "apiCapture",
+                ...(step.apiCaptureOptions || {}),
+                wait: step.apiCaptureOptions?.wait ?? 4000,
+            };
+            let apiResult;
+            try {
+                apiResult = await this.captureApi(apiStep);
+            } catch (err) {
+                apiResult = { error: err.message, summary: { total: 0, failed: 0 } };
+            }
+            item.api = apiResult;
+
+            const total = apiResult?.summary?.total ?? 0;
+            const failed = apiResult?.summary?.failed ?? 0;
+            if (total === 0) {
+                item.outcome = "noApi";
+                byOutcome.noApi += 1;
+            } else if (failed > 0) {
+                item.outcome = "apiFailed";
+                byOutcome.apiFailed += 1;
+            } else {
+                item.outcome = "apiOk";
+                byOutcome.apiOk += 1;
+            }
+
+            if (step.snapshotEach) {
+                try {
+                    item.snapshot = await this.observe({ headingsOnly: true });
+                } catch {
+                    // ignore
+                }
+            }
+
+            results.push({ ...item, durationMs: Date.now() - itemStartedAt });
+        }
+
+        return {
+            task: taskName,
+            discovered: menus.length,
+            attempted: results.length,
+            durationMs: Date.now() - startedAt,
+            byOutcome,
+            results,
+        };
+    }
+
+    /**
+     * 从 lastApiCapture 中找菜单接口响应（默认 /listUserViewMenus/），
+     * 用 CDP getResponseBody 拿到 body 后递归拍平。
+     * 兜底：如果 step.menus 已显式传入，直接用之。
+     */
+    async _discoverMenus(step = {}, context = {}) {
+        if (Array.isArray(step.menus) && step.menus.length) {
+            return this._flattenMenuTree(step.menus, step.menuPathPrefix, step.menuFilter);
+        }
+
+        const lastCapture = step.captureResult || context.lastApiCapture;
+        if (!lastCapture?.requests?.length) return [];
+
+        const patternRaw = step.menuApiPattern ?? "listUserViewMenus";
+        const pattern = patternRaw instanceof RegExp ? patternRaw : new RegExp(patternRaw);
+        const candidate = lastCapture.requests.find((r) => pattern.test(r.url || ""));
+        if (!candidate) return [];
+
+        let tree = candidate.responseBody;
+        if (typeof tree === "string") {
+            try { tree = JSON.parse(tree); } catch { return []; }
+        }
+        // 常见包装：{ data: [...] } / { result: { data: [...] } }
+        const list =
+            (Array.isArray(tree) && tree) ||
+            tree?.data ||
+            tree?.result?.data ||
+            tree?.result ||
+            [];
+        return this._flattenMenuTree(list, step.menuPathPrefix, step.menuFilter);
+    }
+
+    /**
+     * 把菜单树拍平成可点击的链路：
+     *   { path, name, names: [一级名, 二级名, ...], depth }
+     * children 字段名兼容 children/subMenus/sub。
+     */
+    _flattenMenuTree(tree, pathPrefix, keywords) {
+        const out = [];
+        const prefixes = Array.isArray(pathPrefix) ? pathPrefix : pathPrefix ? [pathPrefix] : null;
+        const kws = Array.isArray(keywords) ? keywords : keywords ? [keywords] : null;
+
+        const visit = (nodes, parentNames) => {
+            if (!Array.isArray(nodes)) return;
+            for (const node of nodes) {
+                if (!node) continue;
+                const name = node.name || node.title || node.label || node.menuName;
+                const path = node.path || node.url || node.route;
+                const names = name ? [...parentNames, name] : parentNames.slice();
+                const children = node.children || node.subMenus || node.sub || node.childs;
+
+                // 叶子节点（无 children 或 children 空）才有意义点击触发请求
+                const isLeaf = !Array.isArray(children) || children.length === 0;
+                if (isLeaf && name && path) {
+                    let keep = true;
+                    if (prefixes && !prefixes.some((p) => path.startsWith(p))) keep = false;
+                    if (keep && kws && !kws.some((k) => name.includes(k) || path.includes(k))) keep = false;
+                    if (keep) out.push({ path, name, names, depth: names.length });
+                } else if (Array.isArray(children) && children.length) {
+                    visit(children, names);
+                }
+            }
+        };
+        visit(tree, []);
+        return out;
+    }
+
     _resolveSelector(selector) {
         if (!selector) return selector;
         // ~.editKnowledge → [class*="editKnowledge"]