@pb33f/cowboy-components 0.7.17 → 0.8.0

package/dist/controllers/rule-controller.js

@@ -1,103 +1,131 @@
-import { AllRulesetBag, CustomRulesetBag, DefaultDocument, DefaultRulesetBag, OWASPRulesetBag, RuleConfigurationBag, SessionRulesetMapBag } from "../components/the-doctor/the-doctor";
-import { ActiveView, ProblemRuleFilterChangedManual } from "../events/doctor";
-import { RulesetService } from "../services/ruleset-service";
-import { ToastType } from "../model/toast";
+import { AllRulesetBag, CustomRulesetBag, DefaultDocument, DefaultRulesetBag, OWASPRulesetBag, RuleConfigurationBag, SessionRulesetMapBag, SessionRulesetYamlBag, } from "../components/the-doctor/the-doctor.js";
+import { ActiveView, ProblemRuleFilterChangedManual } from "../events/doctor.js";
+import { RulesetService } from "../services/ruleset-service.js";
+import { ToastType } from "../model/toast.js";
 import { MarkerSeverity } from "monaco-editor";
 export class RuleController extends EventTarget {
-    constructor(doc) {
+    constructor(deps) {
         super();
-        this.doc = doc;
+        this.bounceId = 0;
+        this.debounceTimeRuleset = 900;
+        this.deps = deps;
+    }
+    createCustomRuleset(rules) {
+        const customRS = {
+            rules: new Map(),
+            id: crypto.randomUUID(),
+            owner: this.deps.getSessionId()
+        };
+        if (rules) {
+            if (rules instanceof Map) {
+                customRS.rules = new Map(rules);
+            }
+            else {
+                customRS.rules = new Map(Object.entries(rules));
+            }
+            customRS.rules.forEach((rule, id) => {
+                if (rule.id !== id) {
+                    rule.id = id;
+                }
+            });
+        }
+        return customRS;
+    }
+    errorToast(title, body) {
+        this.deps.sendToast({
+            id: crypto.randomUUID(),
+            type: ToastType.ERROR,
+            title,
+            body
+        });
+    }
+    infoToast(title, body) {
+        this.deps.sendToast({
+            id: crypto.randomUUID(),
+            type: ToastType.INFO,
+            title,
+            body
+        });
+    }
+    warningToast(title, body) {
+        this.deps.sendToast({
+            id: crypto.randomUUID(),
+            type: ToastType.WARNING,
+            title,
+            body
+        });
     }
     ruleClicked(evt) {
-        // get rule map from bag
-        const map = this.doc.sessionRulesetMapBag?.get(SessionRulesetMapBag);
+        const map = this.deps.sessionRulesetMapBag?.get(SessionRulesetMapBag);
         if (map) {
             const rule = map.rulesMap.find((r) => r.ruleId === evt.detail.ruleId);
             if (rule) {
-                this.doc.selectedEditorTab = "ruleset";
-                this.doc.editorTabGroup.show(ActiveView.Ruleset);
-                this.doc.rulesetEditor.editor?.setPosition({ lineNumber: rule.line, column: rule.start });
-                this.doc.rulesetEditor.editor?.revealLineInCenter(rule.line);
+                this.deps.selectedEditorTab = "ruleset";
+                this.deps.editorPanel?.showTab(ActiveView.Ruleset);
+                this.deps.rulesetEditor.setPosition({ lineNumber: rule.line, column: rule.start });
+                this.deps.rulesetEditor.revealLineInCenter(rule.line);
             }
         }
     }
     rulesetSaved(evt) {
-        // lint spec
-        if (this.doc.docBag) {
-            const doc = this.doc.docBag.get(DefaultDocument);
-            const config = this.doc.ruleConfigBag?.get(RuleConfigurationBag);
+        if (this.deps.docBag) {
+            const doc = this.deps.docBag.get(DefaultDocument);
+            const config = this.deps.ruleConfigBag?.get(RuleConfigurationBag);
             if (evt.detail.rules) {
-                this.doc.customRulesetBag?.set(CustomRulesetBag, evt.detail.rules);
-                // get ruleset config and disable everything,
-                // then enable the custom rules.
+                this.deps.customRulesetBag?.set(CustomRulesetBag, evt.detail.rules);
                 if (config) {
-                    // extract config from the event
                     const newConfig = evt.detail.config;
-                    if (newConfig && this.doc.ruleConfigBag) {
+                    if (newConfig && this.deps.ruleConfigBag) {
                         newConfig.returnedRuleset = evt.detail.returnedRules;
-                        this.doc.ruleConfigBag?.set(RuleConfigurationBag, newConfig);
+                        this.deps.ruleConfigBag?.set(RuleConfigurationBag, newConfig);
                     }
                 }
                 RulesetService.getSessionRulesetAsYAML().then((yaml) => {
-                    if (this.doc.selectedEditorTab == "spec") {
-                        this.doc.rulesetPulse = true;
+                    if (this.deps.selectedEditorTab == "spec") {
+                        this.deps.rulesetPulse = true;
                     }
-                    this.doc.rulesetEditor.setValue(yaml, true);
+                    this.deps.rulesetEditor.setValue(yaml, true);
                     this.fetchRulesetMap();
+                    this.deps.sessionRulesetYamlBag?.set(SessionRulesetYamlBag, yaml);
                 });
-                // lint the spec
-                this.doc.diagnosticController.lintSpec(doc, '');
+                this.deps.lintSpec(doc, '');
             }
         }
     }
     customRulesetEnabled(event) {
-        const customRS = { rules: new Map() };
-        customRS.id = crypto.randomUUID();
-        customRS.owner = this.doc.authController.session.sessionId;
+        const customRS = this.createCustomRuleset();
         event.detail.rules.forEach((rule) => {
-            if (rule.rule.id != rule.ruleId) {
+            if (rule.rule.id !== rule.ruleId) {
                 rule.rule.id = rule.ruleId;
             }
             customRS.rules.set(rule.ruleId, rule.rule);
         });
-        // write state
-        this.doc.customRulesetBag?.set(CustomRulesetBag, customRS);
+        this.deps.customRulesetBag?.set(CustomRulesetBag, customRS);
         if (event.detail.ruleConfig) {
-            this.doc.ruleConfigBag?.set(RuleConfigurationBag, event.detail.ruleConfig);
+            this.deps.ruleConfigBag?.set(RuleConfigurationBag, event.detail.ruleConfig);
         }
         else {
-            this.doc.ruleConfigBag?.reset();
-            // reset session ruleset
+            this.deps.ruleConfigBag?.reset();
             RulesetService.resetSessionRuleset(event.detail.rulesetReset).then(() => {
-                this.doc.sendToast({
-                    id: crypto.randomUUID(),
-                    type: ToastType.INFO,
-                    body: "Ruleset has been reset to the default",
-                    title: "Ruleset reset",
-                });
-                if (this.doc.docBag) {
-                    const doc = this.doc.docBag.get(DefaultDocument);
-                    let path = this.doc.rolodexActivePath;
+                this.infoToast("Ruleset reset", "Ruleset has been reset to the default");
+                if (this.deps.docBag) {
+                    const doc = this.deps.docBag.get(DefaultDocument);
+                    let path = this.deps.rolodexActivePath;
                     if (path == 'root') {
                         path = "";
                     }
-                    this.doc.diagnosticController.lintSpec(doc, this.doc.rolodexActivePath);
+                    this.deps.lintSpec(doc, this.deps.rolodexActivePath);
                 }
-                this.fetchSessionRulesetAsYaml().then((result) => {
-                    this.doc.rulesetEditor?.setValue(result, true);
+                RulesetService.getSessionRulesetAsYAML().then((result) => {
+                    this.deps.rulesetEditor?.setValue(result, true);
+                    this.deps.sessionRulesetYamlBag?.set(SessionRulesetYamlBag, result);
                 });
             }).catch((e) => {
-                this.doc.sendToast({
-                    id: crypto.randomUUID(),
-                    type: ToastType.ERROR,
-                    body: e.detail,
-                    title: "Cannot reset ruleset",
-                });
+                this.errorToast("Cannot reset ruleset", e.detail);
             });
         }
     }
     ruleGroupClicked(event) {
-        this.doc.problemsPanel.focus();
         const simEvent = new CustomEvent(ProblemRuleFilterChangedManual, {
             bubbles: true,
             composed: true,
@@ -105,160 +133,125 @@ export class RuleController extends EventTarget {
                 rule: event.detail.rule
             }
         });
-        this.doc.problemsPanel.focus();
-        this.doc.problemList.dispatchEvent(simEvent);
+        this.deps.problemList.dispatchEvent(simEvent);
         history.pushState({ rule: event.detail.rule }, "", `/${ActiveView.Problems}?rule=${event.detail.rule}`);
-        this.doc.controlTabGroup.show(ActiveView.Problems);
+        this.deps.sidebarPanel?.showTab(ActiveView.Problems);
     }
     rulesetManuallyChanged() {
-        clearTimeout(this.doc.bounceId);
-        this.doc.bounceId = window.setTimeout(() => {
-            const ruleset = this.doc.rulesetEditor.editor?.getValue();
+        clearTimeout(this.bounceId);
+        this.bounceId = window.setTimeout(() => {
+            const ruleset = this.deps.rulesetEditor.getValue();
             RulesetService.validateRuleset(ruleset).then((result) => {
-                // clear any problems
-                this.doc.manageRuleset.clearRuleProblems();
-                // create a new custom ruleset with a map of rules
-                let customRS = { rules: new Map() };
-                customRS.id = crypto.randomUUID();
-                customRS.owner = this.doc.authController.session.sessionId;
-                customRS.rules = new Map(Object.entries(result.rules));
-                customRS.rules.forEach((rule, id) => {
-                    rule.id = id; // set the id to the key
-                });
-                // write state
-                this.doc.customRulesetBag?.set(CustomRulesetBag, customRS);
-                this.doc.customRuleset = customRS;
+                this.deps.manageRuleset.clearRuleProblems();
+                const customRS = this.createCustomRuleset(result.rules);
+                this.deps.customRulesetBag?.set(CustomRulesetBag, customRS);
+                this.deps.customRuleset = customRS;
                 if (customRS.rules.size > 0) {
-                    // rebuild the ruleset management
-                    this.doc.manageRuleset.customRulesetManual = customRS;
+                    this.deps.manageRuleset.setCustomRulesetManual(customRS);
                 }
-                this.doc.selectedEditorTab = ActiveView.Ruleset;
-                this.doc.controlTabGroup.show(ActiveView.Ruleset);
-                this.doc.rulesetEditor.setMarkers([]);
+                this.deps.selectedEditorTab = ActiveView.Ruleset;
+                this.deps.sidebarPanel?.showTab(ActiveView.Ruleset);
+                this.deps.rulesetEditor.setMarkers([]);
                 this.fetchRulesetMap();
             }).catch((e) => {
-                this.doc.sendToast({
-                    id: crypto.randomUUID(),
-                    type: ToastType.ERROR,
-                    body: e.detail,
-                    title: e.title
-                });
+                this.errorToast(e.title, e.detail);
                 console.error('unable to validate ruleset', e);
-                // process bad rules
                 const ruleErrors = e.body;
                 const markers = [];
                 ruleErrors?.forEach((err) => {
-                    markers.push({
-                        severity: MarkerSeverity.Error,
-                        message: err.ruleError,
-                        startLineNumber: err.line,
-                        startColumn: err.startCol,
-                        endLineNumber: err.line,
-                        endColumn: err.endCol
-                    });
+                    if (err.line !== undefined && err.startCol !== undefined && err.endCol !== undefined) {
+                        markers.push({
+                            severity: MarkerSeverity.Error,
+                            message: err.ruleError,
+                            startLineNumber: err.line,
+                            startColumn: err.startCol,
+                            endLineNumber: err.line,
+                            endColumn: err.endCol
+                        });
+                    }
                 });
-                // convert to JSON
                 RulesetService.convertToJSON(ruleset).then((json) => {
-                    // create a new custom ruleset with a map of rules
-                    let customRS = { rules: new Map() };
-                    customRS.id = crypto.randomUUID();
-                    customRS.owner = this.doc.authController.session.sessionId;
-                    customRS.rules = new Map(Object.entries(json.rules));
-                    customRS.rules.forEach((rule, id) => {
-                        if (rule.id != id)
-                            rule.id = id; // set the id to the key
-                    });
-                    this.doc.customRuleset = customRS;
+                    const customRS = this.createCustomRuleset(json.rules);
+                    this.deps.customRuleset = customRS;
                     if (customRS.rules.size > 0) {
-                        // rebuild the ruleset management
-                        this.doc.manageRuleset.customRulesetManual = customRS;
+                        this.deps.manageRuleset.setCustomRulesetManual(customRS);
                     }
-                    this.doc.rulesetEditor.setMarkers([]);
-                    // clear any problems
-                    this.doc.manageRuleset.clearRuleProblems();
-                    // set problems.
-                    this.doc.rulesetEditor.setMarkers(markers);
-                    this.doc.manageRuleset.processBadRules(ruleErrors);
-                    this.doc.controlTabGroup.show(ActiveView.Ruleset);
+                    this.deps.rulesetEditor.setMarkers([]);
+                    this.deps.manageRuleset.clearRuleProblems();
+                    this.deps.rulesetEditor.setMarkers(markers);
+                    this.deps.manageRuleset.processBadRules(ruleErrors);
+                    this.deps.sidebarPanel?.showTab(ActiveView.Ruleset);
                 }).catch((e) => {
                     console.error("unable to convert ruleset to JSON", e);
                 });
             });
-        }, this.doc.debounceTimeRuleset);
+        }, this.debounceTimeRuleset);
     }
     fetchRulesetMap() {
         RulesetService.getSessionRulesetMap().then((result) => {
-            this.doc.sessionRulesetMapBag?.set(SessionRulesetMapBag, result);
+            this.deps.sessionRulesetMapBag?.set(SessionRulesetMapBag, result);
         }).catch(() => {
             console.warn("map is empty, or unavailable, Did you submit an empty ruleset?");
-            this.doc.sendToast({
-                id: crypto.randomUUID(),
-                type: ToastType.WARNING,
-                body: "map is empty, or unavailable, Did you submit an empty ruleset?",
-                title: "Issue fetching ruleset map"
-            });
+            this.warningToast("Issue fetching ruleset map", "map is empty, or unavailable, Did you submit an empty ruleset?");
         });
     }
     exportJSON() {
         let jsonRS;
-        if (this.doc.ruleConfigBag) {
-            const config = this.doc.ruleConfigBag.get(RuleConfigurationBag);
+        if (this.deps.ruleConfigBag) {
+            const config = this.deps.ruleConfigBag.get(RuleConfigurationBag);
             if (config && config.returnedRuleset) {
                 jsonRS = config.returnedRuleset;
             }
         }
         if (jsonRS) {
             let reportData = "data:text/json;charset=utf-8," + encodeURIComponent(JSON.stringify(jsonRS, null, 2));
-            this.doc.downloadRulesetLink.download = "ruleset.json";
-            this.doc.downloadRulesetLink.href = reportData;
-            this.doc.downloadRulesetLink.click();
-            this.doc.exportRulesetDialog.hide();
+            this.deps.downloadRulesetLink.download = "ruleset.json";
+            this.deps.downloadRulesetLink.href = reportData;
+            this.deps.downloadRulesetLink.click();
+            this.deps.exportRulesetDialog.hide();
         }
     }
     exportYAML() {
         RulesetService.getSessionRulesetAsYAML().then((yaml) => {
             let reportData = "data:text/yaml;charset=utf-8," + encodeURIComponent(yaml);
-            this.doc.downloadRulesetLink.download = "ruleset.yaml";
-            this.doc.downloadRulesetLink.href = reportData;
-            this.doc.downloadRulesetLink.click();
-            this.doc.exportRulesetDialog.hide();
+            this.deps.downloadRulesetLink.download = "ruleset.yaml";
+            this.deps.downloadRulesetLink.href = reportData;
+            this.deps.downloadRulesetLink.click();
+            this.deps.exportRulesetDialog.hide();
         });
     }
     async fetchSessionRulesetAsYaml() {
-        return new Promise(async (resolve, reject) => {
-            RulesetService.getSessionRulesetAsYAML().then((result) => {
-                resolve(result);
-            }).catch((e) => {
-                console.error("cannot fetch session ruleset: ", e.title);
-                reject(e);
-            });
-        });
+        try {
+            return await RulesetService.getSessionRulesetAsYAML();
+        }
+        catch (e) {
+            const error = e;
+            console.error("cannot fetch session ruleset: ", error.title);
+            throw error;
+        }
     }
     async fetchAllRuleset() {
-        return new Promise(async (resolve) => {
-            RulesetService.getAllRuleset().then((result) => {
-                this.doc.allRuleset = result;
-                this.doc.allRulesetBag?.set(AllRulesetBag, result);
-                resolve(result);
-            });
-        });
+        const result = await RulesetService.getAllRuleset();
+        this.deps.allRuleset = result;
+        this.deps.allRulesetBag?.set(AllRulesetBag, result);
+        return result;
     }
     async fetchDefaultRuleset() {
-        return new Promise(async (resolve) => {
-            RulesetService.getDefaultRuleset().then((result) => {
-                this.doc.defaultRuleset = result;
-                this.doc.defaultRulesetBag?.set(DefaultRulesetBag, result);
-                resolve(result);
-            });
-        });
+        const result = await RulesetService.getDefaultRuleset();
+        this.deps.defaultRuleset = result;
+        this.deps.defaultRulesetBag?.set(DefaultRulesetBag, result);
+        return result;
     }
     async fetchOWASPRuleset() {
-        return new Promise(async (resolve) => {
-            RulesetService.getOWASPRuleset().then((result) => {
-                this.doc.OWASPRuleset = result;
-                this.doc.OWASPRulesetBag?.set(OWASPRulesetBag, result);
-                resolve(result);
-            });
-        });
+        const result = await RulesetService.getOWASPRuleset();
+        this.deps.OWASPRuleset = result;
+        this.deps.OWASPRulesetBag?.set(OWASPRulesetBag, result);
+        return result;
+    }
+    destroy() {
+        if (this.bounceId) {
+            clearTimeout(this.bounceId);
+            this.bounceId = 0;
+        }
     }
 }

package/dist/controllers/spec-controller.d.ts

@@ -1,8 +1,20 @@
-import { TheDoctor } from "../components/the-doctor/the-doctor";
-import { EditorClickedEvent, EditorUpdatedEvent } from "../events/doctor";
+import { EditorClickedEvent, EditorUpdatedEvent } from "../events/doctor.js";
+import { Problem } from "../model/problem.js";
+import type { SpecControllerDeps } from "../interfaces/doctor-interfaces.js";
 export declare class SpecController extends EventTarget {
-    doc: TheDoctor;
-    constructor(doc: TheDoctor);
+    private readonly deps;
+    private problemsByLine;
+    private bounceId;
+    private readonly debounceTime;
+    constructor(deps: SpecControllerDeps);
+    updateProblems(problems: Problem[]): void;
     specChanged(event: CustomEvent<EditorUpdatedEvent>): void;
     specClicked(event: CustomEvent<EditorClickedEvent>): void;
+    private handleSpecTabClick;
+    private handleRulesetTabClick;
+    private isToolsTabActive;
+    private showProblemView;
+    private showNodeInViewer;
+    private ensureSidebarOpen;
+    destroy(): void;
 }

package/dist/controllers/spec-controller.js

@@ -1,78 +1,107 @@
-import { DefaultDocument, GraphBag, SessionRulesetMapBag } from "../components/the-doctor/the-doctor";
-import { ActiveView } from "../events/doctor";
+import { DefaultDocument, GraphBag, SessionRulesetMapBag } from "../components/the-doctor/the-doctor.js";
+import { ActiveView } from "../events/doctor.js";
 export class SpecController extends EventTarget {
-    constructor(doc) {
+    constructor(deps) {
         super();
-        this.doc = doc;
+        this.problemsByLine = new Map();
+        this.bounceId = 0;
+        this.debounceTime = 1000;
+        this.deps = deps;
+    }
+    updateProblems(problems) {
+        this.problemsByLine.clear();
+        problems.forEach(p => {
+            this.problemsByLine.set(p.startLineNumber, p);
+        });
     }
     specChanged(event) {
-        const editor = this.doc.editorMap.get(event.detail.id);
+        const editor = this.deps.editorMap.get(event.detail.id);
         if (editor && event.detail.id === 'ruleset-editor') {
-            this.doc.ruleController.rulesetManuallyChanged();
+            this.deps.rulesetManuallyChanged();
             return;
         }
-        if (this.doc.docBag) {
-            this.doc.docBag.set(DefaultDocument, event.detail.content);
+        if (this.deps.docBag) {
+            this.deps.docBag.set(DefaultDocument, event.detail.content);
+        }
+        if (!this.deps.autoDiagnose) {
+            this.deps.setEditorDirty(true);
         }
-        if (this.doc.autoDiagnose) {
-            clearTimeout(this.doc.bounceId);
-            this.doc.bounceId = window.setTimeout(() => {
-                this.doc.diagnosticController.lintSpec(event.detail.content);
-            }, this.doc.debounceTime);
+        if (this.deps.autoDiagnose) {
+            clearTimeout(this.bounceId);
+            this.bounceId = window.setTimeout(() => {
+                this.deps.lintSpec(event.detail.content);
+            }, this.debounceTime);
         }
     }
     specClicked(event) {
-        this.doc.detailsDrawer.close();
-        if (this.doc.selectedEditorTab == "spec") {
-            let problemFound = false;
-            for (let i = 0; i < this.doc.problems?.length; i++) {
-                if (this.doc.problems[i].startLineNumber === event.detail.line) {
-                    this.doc.problemList.lineClicked(event.detail.line, true);
-                    this.doc.controlTabGroup.show(ActiveView.Problems);
-                    if (this.doc.sidebarClosed) {
-                        this.doc.toggleSidebar();
-                    }
-                    problemFound = true;
-                    break;
-                }
-            }
-            // use the graph lookup to find the node, use the graphResponse, if available if not, pull from bag
-            const graph = this.doc.graphBag?.get(GraphBag);
-            if (graph) {
-                if (graph.graphMap && event.detail.line) {
-                    const nodeHash = graph.graphMap[event.detail.line];
-                    if (nodeHash) {
-                        this.doc.modelTree.explorerClicked(nodeHash);
-                        const rendered = this.doc.renderedNodeMap.get(nodeHash);
-                        if (rendered) {
-                            this.doc.renderedNode.node = rendered;
-                        }
-                        if (!problemFound) {
-                            this.doc.viewerPanel.click();
-                        }
-                        const n = this.doc.nodeIdHashMap.get(nodeHash);
-                        if (n) {
-                            this.doc.explorer.activeNode = n;
-                            this.doc.explorer.equalizer.activeNode = n;
-                        }
-                    }
-                }
-            }
+        const target = event.target;
+        if (target?.id === 'tools-editor') {
+            return;
+        }
+        this.deps.genericDrawer.close();
+        if (this.deps.selectedEditorTab === "spec") {
+            this.handleSpecTabClick(event);
         }
-        if (this.doc.selectedEditorTab == ActiveView.Ruleset) {
-            // check ruleset map for the line number
-            const rulesetMap = this.doc.sessionRulesetMapBag?.get(SessionRulesetMapBag);
-            if (rulesetMap?.rulesMap) {
-                for (let i = 0; i < rulesetMap.rulesMap.length; i++) {
-                    if (rulesetMap.rulesMap[i].line === event.detail.line) {
-                        this.doc.controlTabGroup.show(ActiveView.Ruleset);
-                        if (this.doc.sidebarClosed) {
-                            this.doc.toggleSidebar();
-                        }
-                        break;
-                    }
-                }
+        else if (this.deps.selectedEditorTab === ActiveView.Ruleset) {
+            this.handleRulesetTabClick(event);
+        }
+    }
+    handleSpecTabClick(event) {
+        if (!event.detail.line)
+            return;
+        const problem = this.problemsByLine.get(event.detail.line);
+        if (problem) {
+            this.showProblemView(event.detail.line);
+            return;
+        }
+        const graph = this.deps.graphBag?.get(GraphBag);
+        if (graph?.graphMap) {
+            const nodeId = graph.graphMap[event.detail.line];
+            if (nodeId) {
+                this.showNodeInViewer(nodeId);
             }
         }
     }
+    handleRulesetTabClick(event) {
+        const rulesetMap = this.deps.sessionRulesetMapBag?.get(SessionRulesetMapBag);
+        if (!rulesetMap?.rulesMap)
+            return;
+        const hasRuleAtLine = rulesetMap.rulesMap.some(rule => rule.line === event.detail.line);
+        if (hasRuleAtLine) {
+            this.deps.sidebarPanel?.showTab(ActiveView.Ruleset);
+            this.ensureSidebarOpen();
+        }
+    }
+    isToolsTabActive() {
+        const activeTab = this.deps.sidebarPanel?.tabGroup?.querySelector('sl-tab[active]');
+        return activeTab?.getAttribute('panel') === 'tools';
+    }
+    showProblemView(line) {
+        this.deps.problemList.lineClicked(line, true);
+        if (!this.isToolsTabActive()) {
+            this.deps.sidebarPanel?.showTab(ActiveView.Problems);
+            this.ensureSidebarOpen();
+        }
+    }
+    showNodeInViewer(nodeId) {
+        this.deps.modelTree.explorerClicked(nodeId);
+        if (!this.isToolsTabActive()) {
+            this.deps.sidebarPanel?.showTab('viewer');
+        }
+        const node = this.deps.modelController.nodeMap.get(nodeId);
+        if (node) {
+            this.deps.setExplorerActiveNode(node);
+        }
+    }
+    ensureSidebarOpen() {
+        if (this.deps.sidebarClosed) {
+            this.deps.openSidebar();
+        }
+    }
+    destroy() {
+        if (this.bounceId) {
+            clearTimeout(this.bounceId);
+            this.bounceId = 0;
+        }
+    }
 }

package/dist/controllers/state-controller.d.ts

@@ -1,9 +1,10 @@
-import { TheDoctor } from "../components/the-doctor/the-doctor.js";
+import type { StateControllerDeps } from "../interfaces/doctor-interfaces.js";
 import { RuleFunctionSchema } from "../model/vacuum_rule.js";
 export declare class StateController extends EventTarget {
-    doc: TheDoctor;
-    constructor(doc: TheDoctor);
+    private readonly deps;
+    constructor(deps: StateControllerDeps);
     loadState(): void;
     fetchFunctions(): Promise<string[]>;
     fetchFunctionSchema(functionId: string): Promise<RuleFunctionSchema>;
+    private expandAncestorsForNode;
 }