@pb33f/cowboy-components 0.7.17 → 0.8.0

package/dist/controllers/diagnostic-controller.js

@@ -1,267 +1,255 @@
 import { DiagnosticBag, DocumentProblems, SettingsBag } from "../components/the-doctor/the-doctor.js";
 import { LintingService } from "../services/linting-service.js";
 import { ModelService } from "../services/model-service.js";
+import { DefaultMaxNodes } from "../components/visualizer/equalizer.js";
 import { ToastType } from "../model/toast.js";
+import { normalizeRolodexPath } from "../utils/path-utils.js";
+const ROOT_PATH_ALIAS = 'root';
+const PARSE_ERROR_PREFIX = 'unable to parse';
+const SINGLE_PROBLEM_COUNT = 1;
+const EMPTY_PROBLEMS_COUNT = 0;
+const UNPARSEABLE_SCORE = 0;
+const UNPARSEABLE_EVALUATION = 'Useless';
+const LOW_CREDIT_THRESHOLD = 10;
+const MIN_CREDIT_BOUNDARY = 0;
+const INVALID_CREDITS = -1;
+const NO_CREDIT_ERROR_URL = 'https://pb33f.io/errors/no-credit-remaining';
 export class DiagnosticController extends EventTarget {
-    constructor(doc) {
+    constructor(deps) {
         super();
-        this.doc = doc;
+        this.deps = deps;
         this.oldScore = 0;
     }
-    lintSpec(value, url) {
-        // capture old score before any operations
-        if (this.doc.problemsOverview.statistics?.statistics.overallScore > 0) {
-            this.oldScore = this.doc.problemsOverview.statistics.statistics.overallScore;
+    createToast(type, title, body) {
+        this.deps.sendToast({
+            id: crypto.randomUUID(),
+            type,
+            title,
+            body
+        });
+    }
+    getMaxNodes() {
+        return this.deps.explorer?.equalizer?.maxNodes ?? DefaultMaxNodes;
+    }
+    prepareLintContext(url) {
+        if (this.deps.problemsOverview.statistics?.statistics?.overallScore && this.deps.problemsOverview.statistics.statistics.overallScore > 0) {
+            this.oldScore = this.deps.problemsOverview.statistics.statistics.overallScore;
         }
-        this.doc.activitySpinner.show();
-        this.doc.editor.breadcumb.isInvalid = false;
+        this.deps.activity.show();
+        this.deps.editor.breadcumb.isInvalid = false;
         if (url) {
-            if (url === 'root') {
+            if (url === ROOT_PATH_ALIAS) {
                 url = '';
             }
             else {
-                this.doc.urlProblem.style.display = 'none';
-                this.doc.urlOverlay.style.display = "block";
-                this.doc.urlSpinner.style.display = "block";
-                this.doc.referenceMapBag?.reset(); // wipe out refs.
+                this.deps.showUrlLoading();
+                this.deps.referenceMapBag?.reset();
             }
         }
         else {
-            this.doc.urlProblem.style.display = 'none';
-            this.doc.urlOverlay.style.display = "none";
-            this.doc.urlSpinner.style.display = "none";
+            this.deps.hideUrlError();
         }
         let replaceResults = false;
-        let currentPath = this.doc.rolodexActivePath;
-        if (this.doc.rolodexActivePath === this.doc.rolodexRootPath || this.doc.rolodexActivePath === 'root') {
+        let currentPath = this.deps.rolodexActivePath;
+        if (this.deps.rolodexActivePath === this.deps.rolodexRootPath || this.deps.rolodexActivePath === ROOT_PATH_ALIAS) {
             replaceResults = true;
             currentPath = '';
-            this.doc.editor.showBreadcrumb = false;
+            this.deps.editor.showBreadcrumb = false;
         }
-        if (url && url != '') {
+        let normalizedUrl = url;
+        if (url && url !== '') {
             try {
                 const parsedUrl = new URL(url);
                 if (parsedUrl) {
                     currentPath = parsedUrl.pathname;
-                    this.doc.rolodexActivePath = currentPath;
-                    this.doc.rolodexRootPath = currentPath;
+                    this.deps.rolodexActivePath = currentPath;
+                    this.deps.rolodexRootPath = currentPath;
                     replaceResults = true;
                 }
             }
             catch (e) {
-                // do nothing for now.
             }
         }
-        let revive = true;
-        LintingService.lintFile(value, this.doc.brokerController.brokerConnectionId, url, currentPath, this.doc.skipTimeline).then((result) => {
-            //if (replaceResults) {
-            this.doc.activitySpinner.hide();
-            const map = this.doc.rolodexController.buildRolodexResultMap(result);
-            if (url) {
-                this.doc.urlOverlay.style.display = "none";
-                this.doc.urlSpinner.style.display = "none";
-                this.doc.urlProblem.style.display = 'none';
-            }
-            // extract empty location problems as we are replacing the root results
-            let rootProblems = this.doc.rolodexProblemMap.get("root");
-            if (!this.doc.rolodexRoot) {
-                rootProblems = [];
-            }
-            if (result && !Array.isArray(result)) {
-                const r = [result];
-                if (this.doc.rolodexProblemMap.size > 0 && this.doc.rolodexProblemMap.has(this.doc.rolodexActivePath)) {
-                    const probs = this.doc.rolodexProblemMap.get(this.doc.rolodexActivePath);
-                    if (probs) {
-                        if (rootProblems) {
-                            probs.push(...rootProblems);
-                        }
-                        this.doc.editor.setMarkers(probs);
-                    }
-                    else {
-                        if (rootProblems) {
-                            r.push(...rootProblems);
-                        }
-                        this.doc.editor.setMarkers(r);
+        return { replaceResults, currentPath, normalizedUrl };
+    }
+    mergeProblemsWithRoot(base, root) {
+        return (root && root.length > 0) ? [...base, ...root] : base;
+    }
+    setMarkersWithRootProblems(problems, lookupPath, rootProblems) {
+        const baseProblems = this.deps.rolodexProblemMap.size > 0 && this.deps.rolodexProblemMap.has(lookupPath)
+            ? this.deps.rolodexProblemMap.get(lookupPath) ?? problems
+            : problems;
+        this.deps.editor.setMarkers(this.mergeProblemsWithRoot(baseProblems, rootProblems));
+    }
+    handleSingleProblemResult(result, rootProblems) {
+        const r = [result];
+        const lookupPath = normalizeRolodexPath(this.deps.rolodexActivePath);
+        this.setMarkersWithRootProblems(r, lookupPath, rootProblems);
+        this.deps.problemBag?.set(DocumentProblems, r);
+        this.deps.problemList.problems = r;
+        this.deps.problems = r;
+        this.deps.updateSpecProblems(r);
+        this.deps.problemsOverview.problems = this.deps.problemList.problemItems;
+    }
+    handleParseError(result) {
+        if (result.length === SINGLE_PROBLEM_COUNT && result[0].message.startsWith(PARSE_ERROR_PREFIX)) {
+            this.deps.editor.clearDecorations();
+            this.deps.editor.clearAllMarkers();
+            this.deps.editor.setMarkers(result);
+            this.deps.editor.breadcumb.isInvalid = true;
+            this.deps.editor.showBreadcrumb = true;
+            this.deps.editor.dead();
+            this.deps.problemList.isInvalid = true;
+            return true;
+        }
+        return false;
+    }
+    async fetchGraphAndHistory() {
+        const result = await ModelService.fetchLatestGraph(this.getMaxNodes());
+        this.deps.extractGraph(result);
+        await this.deps.timeVortex?.getHistorySummary();
+    }
+    async handlePostLintOperations(context) {
+        this.deps.editor.revive();
+        await this.fetchGraphAndHistory();
+        if (this.deps.rolodexNeedsReset) {
+            this.deps.queryRolodex(context.currentPath);
+        }
+        else {
+            this.deps.fetchRefMap(context.currentPath);
+        }
+    }
+    async updateStatisticsAndNotify() {
+        try {
+            const result = await LintingService.fetchStatistics();
+            this.deps.diagnosticBag?.set(DiagnosticBag, result);
+            this.deps.activity.hide();
+            const currentCredits = this.deps.creditTicker?.credits ?? INVALID_CREDITS;
+            if (currentCredits >= MIN_CREDIT_BOUNDARY && currentCredits <= LOW_CREDIT_THRESHOLD) {
+                this.deps.statusBar.visible = true;
+                console.warn(`You are running low on credit, you will need to authenticate soon. ${currentCredits} credits remaining.`);
+            }
+            this.deps.problemsOverview.statistics = result;
+            const settings = this.deps.settingsBag?.get(SettingsBag);
+            if (!settings?.autoDiagnose) {
+                if (this.deps.problemsOverview.statistics) {
+                    const newScore = result.statistics.overallScore;
+                    if (this.oldScore > newScore) {
+                        this.createToast(ToastType.SCOREDOWN, `Score went down by ${this.oldScore - newScore}%`, `Your score has decreased. It is now ${newScore}%`);
                     }
-                }
-                else {
-                    if (rootProblems) {
-                        r.push(...rootProblems);
+                    if (this.oldScore < newScore) {
+                        this.createToast(ToastType.SCOREUP, `Score went up by ${newScore - this.oldScore}%`, `Your score has increased to ${newScore}%`);
                     }
-                    this.doc.editor.setMarkers(r);
                 }
-                this.doc.problemBag?.set(DocumentProblems, r);
-                this.doc.problemList.problems = r;
-                this.doc.problems = r;
-                this.doc.problemsOverview.problems = this.doc.problemList.problemItems;
             }
-            if (result && Array.isArray(result)) {
-                if (result.length == 0) {
-                    this.doc.editor.clearAllMarkers();
-                    this.doc.editor.breadcumb.isInvalid = false;
-                    this.doc.editor.showBreadcrumb = false;
-                    revive = true;
-                    this.doc.problemList.isInvalid = false;
-                }
-                // check if this problem is 'unable to parse'
-                if (result.length == 1 && result[0].message.startsWith('unable to parse')) {
-                    // short circuit, we are dead.
-                    this.doc.editor.clearDecorations();
-                    this.doc.editor.clearAllMarkers();
-                    this.doc.editor.setMarkers(result);
-                    this.doc.editor.breadcumb.isInvalid = true;
-                    this.doc.editor.showBreadcrumb = true;
-                    this.doc.editor.dead();
-                    this.doc.problemList.isInvalid = true;
-                    revive = false;
-                }
-                // extract empty location problems as we are replacing the root results
-                if (revive && this.doc.rolodexProblemMap.size > 0 && this.doc.rolodexProblemMap.has(this.doc.rolodexActivePath)) {
-                    const probs = this.doc.rolodexProblemMap.get(this.doc.rolodexActivePath);
-                    if (probs) {
-                        if (rootProblems) {
-                            probs.push(...rootProblems);
-                        }
-                        this.doc.editor.setMarkers(probs);
-                    }
-                    else {
-                        if (rootProblems) {
-                            result.push(...rootProblems);
-                        }
-                        this.doc.editor.setMarkers(result);
-                    }
+        }
+        catch (e) {
+            console.error("statistics service is down", e);
+            const error = e;
+            this.createToast(ToastType.ERROR, "Statistics request failed", error.detail);
+        }
+    }
+    initializeExplorerIfNeeded() {
+        if (!this.deps.explorerBooted && this.deps.explorer) {
+            this.deps.explorer.equalizer.initializeEqualizer();
+            this.deps.explorerBooted = true;
+        }
+    }
+    handleLintError(e, url) {
+        this.deps.activity.hide();
+        if (!url) {
+            console.error("so sorry, the doctor cannot see you right now, the clinic is closed.");
+            if (e) {
+                console.error(e.detail);
+                if (e.instance === NO_CREDIT_ERROR_URL) {
+                    this.deps.statusBar.visible = true;
+                    const text = this.deps.isAuthenticated
+                        ? "Run out of credit, please purchase more, or come back tomorrow for more free credits."
+                        : "Run out of credit, please authenticate for more or wait 24 hours.";
+                    this.createToast(ToastType.ERROR, "💰 Credit Exhausted!", text);
                 }
                 else {
-                    if (replaceResults) {
-                        this.doc.editor.setMarkers(result);
-                    }
-                    else {
-                        this.doc.modelController.fetchRefMap(currentPath);
-                        if ((this.doc.rolodexRootPath == this.doc.rolodexActivePath || this.doc.rolodexActivePath == 'root') || url || currentPath != '') {
-                            ModelService.fetchLatestGraph().then((result) => {
-                                this.doc.modelController.extractGraph(result);
-                                this.doc.timeVortex.checkHistory();
-                            });
-                        }
-                        return;
-                    }
-                }
-                this.doc.problemBag?.set(DocumentProblems, result);
-                this.doc.problemList.problems = result;
-                this.doc.problems = result;
-                this.doc.problemsOverview.problems = this.doc.problemList.problemItems;
-                if (this.doc.problemsOverview.statistics) {
-                    if (result.length == 1) {
-                        this.doc.problemsOverview.statistics.statistics.totalErrors = 1;
-                        this.doc.problemsOverview.statistics.statistics.overallScore = 0;
-                        this.doc.problemsOverview.statistics.evaluation = 'Useless';
-                        this.doc.problemsOverview.statistics.diagnosis = '<strong>Specification cannot be used</strong>: <br/><br/>' + result[0].message;
-                    }
+                    this.createToast(ToastType.ERROR, "Platform Error", e.detail);
                 }
             }
-            // enable pb33f theme.
-            if (revive) {
-                this.doc.editor.revive();
+        }
+        else {
+            this.deps.showUrlError(e);
+        }
+    }
+    handleArrayProblemResult(result, rootProblems, context) {
+        let revive = true;
+        if (result.length === EMPTY_PROBLEMS_COUNT) {
+            this.deps.editor.clearAllMarkers();
+            this.deps.editor.breadcumb.isInvalid = false;
+            this.deps.editor.showBreadcrumb = false;
+            revive = true;
+            this.deps.problemList.isInvalid = false;
+        }
+        const isParseError = this.handleParseError(result);
+        if (isParseError) {
+            return { revive: false, shouldContinue: false };
+        }
+        const normalizedPath = normalizeRolodexPath(this.deps.rolodexActivePath);
+        if (revive && this.deps.rolodexProblemMap.size > 0 && this.deps.rolodexProblemMap.has(normalizedPath)) {
+            this.setMarkersWithRootProblems(result, normalizedPath, rootProblems);
+        }
+        else {
+            if (context.replaceResults) {
+                const markersToSet = rootProblems && rootProblems.length > 0
+                    ? rootProblems
+                    : [];
+                this.deps.editor.setMarkers(markersToSet);
             }
             else {
-                return;
-            }
-            // fetch graph
-            if ((this.doc.rolodexRootPath == this.doc.rolodexActivePath || this.doc.rolodexActivePath == 'root') || url || currentPath != '') {
-                ModelService.fetchLatestGraph().then((result) => {
-                    this.doc.modelController.extractGraph(result);
-                    this.doc.timeVortex.checkHistory();
-                });
+                this.deps.fetchRefMap(context.currentPath);
+                return { revive: true, shouldContinue: false };
             }
-            if (this.doc.rolodexNeedsReset) {
-                this.doc.rolodexController.queryRolodex(currentPath);
+        }
+        this.deps.problemBag?.set(DocumentProblems, result);
+        this.deps.problemList.problems = result;
+        this.deps.problems = result;
+        this.deps.updateSpecProblems(result);
+        this.deps.problemsOverview.problems = this.deps.problemList.problemItems;
+        if (this.deps.problemsOverview.statistics && result.length === SINGLE_PROBLEM_COUNT) {
+            this.deps.problemsOverview.statistics.statistics.totalErrors = SINGLE_PROBLEM_COUNT;
+            this.deps.problemsOverview.statistics.statistics.overallScore = UNPARSEABLE_SCORE;
+            this.deps.problemsOverview.statistics.evaluation = UNPARSEABLE_EVALUATION;
+            this.deps.problemsOverview.statistics.diagnosis = '<strong>Specification cannot be used</strong>: <br/><br/>' + result[0].message;
+        }
+        return { revive: true, shouldContinue: true };
+    }
+    async lintSpec(value, url) {
+        const context = this.prepareLintContext(url);
+        try {
+            const result = await LintingService.lintFile(value, this.deps.brokerConnectionId, context.normalizedUrl, context.currentPath, this.deps.skipTimeline);
+            this.deps.activity.hide();
+            this.deps.buildRolodexResultMap(result);
+            if (context.normalizedUrl) {
+                this.deps.hideUrlError();
+            }
+            let rootProblems = this.deps.rolodexProblemMap.get(ROOT_PATH_ALIAS);
+            if (!this.deps.rolodexRoot) {
+                rootProblems = [];
             }
-            else {
-                this.doc.modelController.fetchRefMap(currentPath);
-                //this.timeVortex.tardisControl.fetchHistory()
+            if (result && !Array.isArray(result)) {
+                this.handleSingleProblemResult(result, rootProblems);
             }
-            // update the overview statistics
-            LintingService.fetchStatistics().then((result) => {
-                this.doc.diagnosticBag?.set(DiagnosticBag, result);
-                this.doc.activitySpinner.hide();
-                if (result?.remainingCredit <= 10) {
-                    this.doc.statusBar.callsRemaining = result.remainingCredit;
-                    this.doc.statusBar.visible = true;
-                    console.warn("You are running low on credit, you will need to authenticate soon. " +
-                        "" + result.remainingCredit + " credits remaining.");
+            if (result && Array.isArray(result)) {
+                const arrayResult = this.handleArrayProblemResult(result, rootProblems, context);
+                if (!arrayResult.shouldContinue) {
+                    return;
                 }
-                // determine if the score went up or down and toast it!
-                this.doc.problemsOverview.statistics = result;
-                const settings = this.doc.settingsBag?.get(SettingsBag);
-                // only toast if we're NOT using auto diagnose, otherwise they are a pain in the ass.
-                if (!settings?.autoDiagnose) {
-                    if (this.doc.problemsOverview.statistics) {
-                        const newScore = result.statistics.overallScore;
-                        if (this.oldScore > newScore) {
-                            this.doc.sendToast({
-                                id: crypto.randomUUID(),
-                                type: ToastType.SCOREDOWN,
-                                body: "Your score has decreased. It is now " + newScore + "%",
-                                title: "Score went down by " + (this.oldScore - newScore) + "%"
-                            });
-                        }
-                        if (this.oldScore < newScore) {
-                            this.doc.sendToast({
-                                id: crypto.randomUUID(),
-                                type: ToastType.SCOREUP,
-                                body: "Your score has increased to " + newScore + "%",
-                                title: "Score went up by " + (newScore - this.oldScore) + "%"
-                            });
-                        }
-                    }
+                if (!arrayResult.revive) {
+                    return;
                 }
-            }).catch((e) => {
-                console.error("statistics service is down", e);
-                this.doc.sendToast({
-                    id: crypto.randomUUID(),
-                    type: ToastType.ERROR,
-                    body: e.detail,
-                    title: "Statistics request failed"
-                });
-            });
-            if (!this.doc.explorerBooted) {
-                this.doc.explorer.equalizer.initializeEqualizer();
-                this.doc.explorerBooted = true;
             }
-        }).catch((e) => {
-            this.doc.activitySpinner.hide();
-            if (!url) {
-                //this.platformUnavailable(e);
-                console.error("so sorry, the doctor cannot see you right now, the clinic is closed.");
-                if (e) {
-                    console.error(e.detail);
-                    if (e.instance === 'https://pb33f.io/errors/no-credit-remaining') {
-                        this.doc.statusBar.callsRemaining = 0;
-                        this.doc.statusBar.visible = true;
-                        let text = "Run out of credit, please authenticate for more or wait 24 hours.";
-                        if (this.doc.authController.authenticated) {
-                            text = "Run out of credit, please purchase more, or come back tomorrow for more free credits.";
-                        }
-                        this.doc.sendToast({
-                            id: crypto.randomUUID(),
-                            type: ToastType.ERROR,
-                            body: text,
-                            title: "💰 Credit Exhausted!",
-                        });
-                    }
-                    else {
-                        this.doc.sendToast({
-                            id: crypto.randomUUID(),
-                            type: ToastType.ERROR,
-                            body: e.detail,
-                            title: "Platform Error",
-                        });
-                    }
-                }
-            }
-            else {
-                this.doc.showUrlError(e);
-            }
-        });
+            await this.handlePostLintOperations(context);
+            this.initializeExplorerIfNeeded();
+            await this.updateStatisticsAndNotify();
+        }
+        catch (e) {
+            this.handleLintError(e, url);
+        }
     }
 }

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

@@ -0,0 +1,33 @@
+import { GenericDetailsDrawer } from '../components/details-drawer/generic-details-drawer.js';
+import { Node } from '../model/graph.js';
+import type { DiagramatronControllerDeps } from '../interfaces/doctor-interfaces.js';
+export interface DiagramRequestedEvent {
+    nodeId: string;
+    jsonPath: string;
+    nodeType?: string;
+    title?: string;
+}
+export declare class DiagramatronController extends EventTarget {
+    private readonly deps;
+    private diagramService;
+    private drawer;
+    private isGenerating;
+    constructor(deps: DiagramatronControllerDeps);
+    /**
+     * Set the drawer instance
+     */
+    setDrawer(drawer: GenericDetailsDrawer): void;
+    handleDiagramRequest(event: CustomEvent<DiagramRequestedEvent>): Promise<void>;
+    /**
+     * Generate diagram for a specific node
+     */
+    generateDiagramForNode(node: Node): Promise<void>;
+    /**
+     * Get node title from ID
+     */
+    private getNodeTitle;
+    /**
+     * Check if currently generating a diagram
+     */
+    isGeneratingDiagram(): boolean;
+}

package/dist/controllers/diagramatron-controller.js

@@ -0,0 +1,128 @@
+// Copyright 2023-2025 Princess Beef Heavy Industries, LLC / Dave Shanley
+// https://pb33f.io
+import { DiagramatronService } from '../services/diagramatron-service.js';
+import { DrawerContentType } from '../model/drawer-content.js';
+import { ToastType } from '../model/toast.js';
+export class DiagramatronController extends EventTarget {
+    constructor(deps) {
+        super();
+        this.drawer = null;
+        this.isGenerating = false;
+        this.deps = deps;
+        this.diagramService = DiagramatronService.getInstance();
+        if (deps.doctorEndpoint) {
+            this.diagramService.setEndpoint(deps.doctorEndpoint);
+        }
+    }
+    /**
+     * Set the drawer instance
+     */
+    setDrawer(drawer) {
+        this.drawer = drawer;
+    }
+    async handleDiagramRequest(event) {
+        const { nodeId, jsonPath, title } = event.detail;
+        if (this.isGenerating) {
+            this.deps.sendToast({
+                id: crypto.randomUUID(),
+                type: ToastType.WARNING,
+                title: 'Diagram Generation In Progress',
+                body: 'Please wait for the current diagram to complete'
+            });
+            return;
+        }
+        if (!jsonPath) {
+            this.deps.sendToast({
+                id: crypto.randomUUID(),
+                type: ToastType.ERROR,
+                title: 'Invalid Request',
+                body: 'No JSON path provided for diagram generation'
+            });
+            return;
+        }
+        this.isGenerating = true;
+        try {
+            this.deps.activity.show();
+            const brokerId = this.deps.getBrokerId();
+            const response = await this.diagramService.generateClassDiagram(jsonPath, brokerId);
+            const drawerEvent = {
+                type: DrawerContentType.DIAGRAM,
+                nodeId,
+                jsonPath,
+                diagram: response.diagram,
+                title: title || this.getNodeTitle(nodeId),
+                metadata: response.metadata
+            };
+            if (this.drawer) {
+                this.drawer.useAllSpace = true;
+                await this.drawer.open(drawerEvent);
+            }
+            else {
+                console.error('Drawer not initialized');
+                this.deps.sendToast({
+                    id: crypto.randomUUID(),
+                    type: ToastType.ERROR,
+                    title: 'Display Error',
+                    body: 'Unable to display diagram - drawer not initialized'
+                });
+            }
+        }
+        catch (error) {
+            console.error('Error generating diagram:', error);
+            if (error?.instance === 'https://pb33f.io/errors/no-credit-remaining') {
+                let text = "Run out of credit, please authenticate for more or wait 24 hours.";
+                if (this.deps.isAuthenticated) {
+                    text = "Run out of credit, please purchase more, or come back tomorrow for more free credits.";
+                }
+                this.deps.sendToast({
+                    id: crypto.randomUUID(),
+                    type: ToastType.ERROR,
+                    body: text,
+                    title: "💰 Credit Exhausted!",
+                });
+            }
+            else {
+                this.deps.sendToast({
+                    id: crypto.randomUUID(),
+                    type: ToastType.ERROR,
+                    title: 'Diagram Generation Failed',
+                    body: error instanceof Error ? error.message : error?.detail || 'An unexpected error occurred'
+                });
+            }
+        }
+        finally {
+            this.isGenerating = false;
+            this.deps.activity.hide();
+        }
+    }
+    /**
+     * Generate diagram for a specific node
+     */
+    async generateDiagramForNode(node) {
+        if (!node.id) {
+            console.error('Node has no ID');
+            return;
+        }
+        // Create a synthetic event
+        const event = new CustomEvent('diagram-requested', {
+            detail: {
+                nodeId: node.id,
+                jsonPath: node.id, // Using node ID as JSON path
+                title: node.label || undefined
+            }
+        });
+        await this.handleDiagramRequest(event);
+    }
+    /**
+     * Get node title from ID
+     */
+    getNodeTitle(_nodeId) {
+        return undefined;
+    }
+    /**
+     * Check if currently generating a diagram
+     */
+    isGeneratingDiagram() {
+        return this.isGenerating;
+    }
+}

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

@@ -1,8 +1,14 @@
-import { TheDoctor } from "../components/the-doctor/the-doctor";
-import { ProblemDrawerEvent } from "../components/problem-list/details-drawer";
+import { AnyDrawerEvent } from "../model/drawer-content.js";
+import type { DocsControllerDeps } from "../interfaces/doctor-interfaces.js";
 export declare class DocsController extends EventTarget {
-    doc: TheDoctor;
-    constructor(doc: TheDoctor);
+    private readonly deps;
+    constructor(deps: DocsControllerDeps);
+    private initializeDocsBags;
+    private fetchHowToFixDocs;
+    private setupRuleDocsWorker;
+    private loadDocumentationFromWorker;
     fetchDocs(): void;
-    ruleDocsClicked(event: CustomEvent<ProblemDrawerEvent>): void;
+    private sendDocumentationUnavailableToast;
+    private handleDocumentationDrawer;
+    handleDrawerRequest(event: CustomEvent<AnyDrawerEvent>): Promise<void>;
 }