@pb33f/cowboy-components 0.7.18 → 0.8.0

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

@@ -1,7 +1,14 @@
-import { TheDoctor } from "../components/the-doctor/the-doctor";
-import { ProblemClickedEvent } from "../events/doctor";
+import { ProblemClickedEvent } from "../events/doctor.js";
+import type { ProblemControllerDeps } from "../interfaces/doctor-interfaces.js";
 export declare class ProblemController extends EventTarget {
-    doc: TheDoctor;
-    constructor(doc: TheDoctor);
+    private readonly deps;
+    constructor(deps: ProblemControllerDeps);
     problemClicked(event: CustomEvent<ProblemClickedEvent>): void;
+    private ensureSpecTabActive;
+    private normalizeSourceLocation;
+    private navigateToRolodexNode;
+    private isRolodexFilePath;
+    private navigateToRolodexFile;
+    private navigateInEditor;
+    private navigateInHistoricalDiff;
 }

package/dist/controllers/problem-controller.js

@@ -1,46 +1,105 @@
-import { ActiveView, RolodexTreeNodeClicked } from "../events/doctor";
-import { SearchNodeTreeForPath } from "../model/graph";
+import { ActiveView, RolodexTreeNodeClicked } from "../events/doctor.js";
+import { SearchNodeTreeForPath } from "../model/graph.js";
 export class ProblemController extends EventTarget {
-    constructor(doc) {
+    constructor(deps) {
         super();
-        this.doc = doc;
+        this.deps = deps;
     }
     problemClicked(event) {
-        if (this.doc.selectedEditorTab != "spec") {
-            this.doc.editorTabGroup.show("spec");
-            this.doc.selectedEditorTab = "spec";
-        }
-        let sourceLocation = event.detail.problem.problemObject.sourceLocation;
-        // no source? use root
-        if (sourceLocation == '' || sourceLocation == undefined || sourceLocation == 'root') {
-            sourceLocation = this.doc.rolodexRootPath;
-        }
-        // locate the node in rolodex root
-        const node = SearchNodeTreeForPath(this.doc.rolodexRoot, sourceLocation);
-        if (node) {
-            // trigger a rolodex load
-            this.doc.nodeClickerController.rolodexTreeNodeClicked(new CustomEvent(RolodexTreeNodeClicked, {
-                detail: {
-                    nodeHashId: node.idHash,
-                    path: sourceLocation,
-                    line: event.detail.problem.problemObject.startLineNumber,
-                    column: event.detail.problem.problemObject.startColumn
-                }
-            }));
-            this.doc.detailsDrawer.close();
-            // make sure we select the file in the rolodex
-            this.doc.rolodexTree.openNodeByPath(sourceLocation);
-            return;
-        }
-        this.doc.controlTabGroup.show(ActiveView.Problems);
-        this.doc.editor.editor?.revealLineInCenter(event.detail.problem.line);
-        this.doc.editor.editor?.setPosition({
-            lineNumber: event.detail.problem.line,
-            column: event.detail.problem.column
-        });
-        this.doc.detailsDrawer.close();
-        if (!event.detail.launchedFromProblems) {
-            this.doc.problemList.lineClicked(event.detail.problem.problemObject.startLineNumber);
+        if (this.deps.viewingHistoricalViolations) {
+            this.navigateInHistoricalDiff(event.detail.problem, event.detail.launchedFromProblems);
+        }
+        else {
+            this.ensureSpecTabActive();
+            const sourceLocation = this.normalizeSourceLocation(event.detail.problem);
+            let node = null;
+            if (this.deps.rolodexRoot) {
+                node = SearchNodeTreeForPath(this.deps.rolodexRoot, sourceLocation, this.deps.modelController);
+            }
+            if (node) {
+                this.navigateToRolodexNode(node, sourceLocation, event.detail.problem);
+            }
+            else if (this.isRolodexFilePath(sourceLocation)) {
+                this.navigateToRolodexFile(sourceLocation, event.detail.problem);
+            }
+            else {
+                this.navigateInEditor(event.detail.problem, event.detail.launchedFromProblems);
+            }
+        }
+        this.deps.genericDrawer.close();
+    }
+    ensureSpecTabActive() {
+        if (this.deps.selectedEditorTab !== "spec") {
+            this.deps.editorPanel?.showTab("spec");
+            this.deps.selectedEditorTab = "spec";
+        }
+    }
+    normalizeSourceLocation(problem) {
+        const sourceLocation = problem.problemObject.sourceLocation;
+        if (!sourceLocation || sourceLocation === 'root') {
+            return this.deps.rolodexRootPath;
+        }
+        return sourceLocation;
+    }
+    navigateToRolodexNode(node, path, problem) {
+        this.deps.nodeClickerController.rolodexTreeNodeClicked(new CustomEvent(RolodexTreeNodeClicked, {
+            detail: {
+                nodeHashId: node.idHash,
+                path: path,
+                line: problem.problemObject.startLineNumber,
+                column: problem.problemObject.startColumn
+            }
+        }));
+        this.deps.rolodexTree.openNodeByPath(path);
+    }
+    isRolodexFilePath(sourceLocation) {
+        if (sourceLocation === this.deps.rolodexRootPath ||
+            sourceLocation === 'root' ||
+            sourceLocation.length === 0) {
+            return false;
+        }
+        return /\.(ya?ml|json)(#.*)?$/i.test(sourceLocation);
+    }
+    navigateToRolodexFile(path, problem) {
+        this.deps.nodeClickerController.rolodexTreeNodeClicked(new CustomEvent(RolodexTreeNodeClicked, {
+            detail: {
+                path: path,
+                line: problem.problemObject.startLineNumber,
+                column: problem.problemObject.startColumn
+            }
+        }));
+        this.deps.rolodexTree.openNodeByPath(path);
+    }
+    navigateInEditor(problem, launchedFromProblems) {
+        this.deps.sidebarPanel?.showTab(ActiveView.Problems);
+        const editor = this.deps.editor.editor;
+        if (editor && problem.line !== undefined && problem.column !== undefined) {
+            editor.revealLineInCenter(problem.line);
+            editor.setPosition({
+                lineNumber: problem.line,
+                column: problem.column
+            });
+        }
+        if (!launchedFromProblems) {
+            this.deps.problemList.lineClicked(problem.problemObject.startLineNumber);
+        }
+    }
+    navigateInHistoricalDiff(problem, launchedFromProblems) {
+        this.deps.selectTardis();
+        const tardisControl = this.deps.timeVortex?.tardisControl;
+        if (tardisControl) {
+            tardisControl.showDiffTab();
+            const diffEditor = tardisControl.diffEditor;
+            if (diffEditor && problem.line !== undefined && problem.column !== undefined) {
+                diffEditor.revealLineInCenterOriginal(problem.line);
+                diffEditor.setPositionOriginal({
+                    lineNumber: problem.line,
+                    column: problem.column
+                });
+            }
+        }
+        if (!launchedFromProblems) {
+            this.deps.problemList.lineClicked(problem.problemObject.startLineNumber);
         }
     }
 }

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

@@ -1,10 +1,15 @@
-import { TheDoctor } from "../components/the-doctor/the-doctor.js";
 import { NodeClickedEvent } from "../events/doctor.js";
 import { Problem } from "../model/problem.js";
+import { Node } from "../model/graph.js";
+import type { RolodexControllerDeps } from "../interfaces/doctor-interfaces.js";
 export declare class RolodexController extends EventTarget {
-    doc: TheDoctor;
-    constructor(doc: TheDoctor);
+    private readonly deps;
+    constructor(deps: RolodexControllerDeps);
     rolodexRootFileSelected(evt: CustomEvent<NodeClickedEvent>): void;
     buildRolodexResultMap(results: Problem[]): Map<string, Problem[]>;
+    private resolveProblemKey;
+    private addProblemToMap;
     queryRolodex(currentPath?: string): void;
+    findRootFile(nodeMap: Map<string, Node>): Node | null;
+    expandAncestors(node: Node, nodeMap: Map<string, Node>): void;
 }

package/dist/controllers/rolodex-controller.js

@@ -1,126 +1,160 @@
 import { RolodexResponseBag, RolodexStateBag } from "../components/the-doctor/the-doctor.js";
 import { ModelService } from "../services/model-service.js";
+import { buildNodeMap, buildHashToNodeMap, collectAncestors, resolveNodeIdFromHash } from "../utils/node-helpers.js";
+import { NodeType } from "../model/node_type.js";
 export class RolodexController extends EventTarget {
-    constructor(doc) {
+    constructor(deps) {
         super();
-        this.doc = doc;
+        this.deps = deps;
     }
     rolodexRootFileSelected(evt) {
-        this.doc.rolodexActivePath = evt.detail.path;
-        this.doc.rolodexActiveHash = evt.detail.nodeHashId;
-        this.doc.rolodexRootPath = evt.detail.path;
-        this.doc.importDisabled = true;
-        const existingState = this.doc.rolodexStateBag?.get(RolodexStateBag);
+        this.deps.rolodexActivePath = evt.detail.path;
+        this.deps.rolodexActiveHash = evt.detail.nodeHashId;
+        this.deps.rolodexRootPath = evt.detail.path;
+        this.deps.importDisabled = true;
+        const existingState = this.deps.rolodexStateBag?.get(RolodexStateBag);
         if (existingState) {
             existingState.activePath = evt.detail.path;
+            existingState.activeId = evt.detail.nodeId;
             existingState.activeHash = evt.detail.nodeHashId;
             existingState.rootPath = evt.detail.path;
+            existingState.rootId = evt.detail.nodeId;
             existingState.rootHash = evt.detail.nodeHashId;
-            this.doc.rolodexStateBag?.set(RolodexStateBag, existingState);
+            this.deps.rolodexStateBag?.set(RolodexStateBag, existingState);
         }
         else {
-            const existingState = {
+            const newState = {
                 activePath: evt.detail.path,
+                activeId: evt.detail.nodeId,
                 activeHash: evt.detail.nodeHashId,
                 rootPath: evt.detail.path,
+                rootId: evt.detail.nodeId,
                 rootHash: evt.detail.nodeHashId
             };
-            this.doc.rolodexStateBag?.set(RolodexStateBag, existingState);
+            this.deps.rolodexStateBag?.set(RolodexStateBag, newState);
         }
         if (evt.detail.nodeHashId) {
-            this.doc.rolodexRootHash = evt.detail.nodeHashId;
+            this.deps.rolodexRootHash = evt.detail.nodeHashId;
         }
         if (evt.detail.content) {
-            this.doc.rolodexNeedsReset = true;
-            this.doc.editor.setValue(evt.detail.content, true);
-            this.doc.diagnosticController.lintSpec(evt.detail.content);
+            this.deps.rolodexNeedsReset = true;
+            this.deps.editor.setValue(evt.detail.content, true);
+            this.deps.lintSpec(evt.detail.content);
         }
     }
     buildRolodexResultMap(results) {
-        // TODO: optimize this, it's a bit slow.
-        this.doc.rolodexProblemMap.clear();
+        this.deps.rolodexProblemMap.clear();
         results.forEach((problem) => {
-            // check if the source location is '/root.yaml'
-            if (problem.sourceLocation === '/root.yaml' || problem.sourceLocation === 'root.yaml') {
-                problem.sourceLocation = "root";
-            }
-            if (this.doc.rolodexProblemMap.has(problem.sourceLocation)) {
-                const problems = this.doc.rolodexProblemMap.get(problem.sourceLocation);
-                if (problems) {
-                    problems.push(problem);
-                    if (problem.sourceLocation) {
-                        this.doc.rolodexProblemMap.set(problem.sourceLocation, problems);
-                    }
-                    else {
-                        if (!this.doc.rolodexRootPath) {
-                            this.doc.rolodexProblemMap.set("root", problems);
-                        }
-                        else {
-                            this.doc.rolodexProblemMap.set(this.doc.rolodexRootPath, problems);
-                        }
-                    }
-                }
-            }
-            else {
-                if (problem.sourceLocation) {
-                    this.doc.rolodexProblemMap.set(problem.sourceLocation, [problem]);
-                }
-                else {
-                    if (!this.doc.rolodexRootPath) {
-                        const currProblems = this.doc.rolodexProblemMap.get("root");
-                        if (currProblems) {
-                            currProblems.push(problem);
-                            this.doc.rolodexProblemMap.set("root", currProblems);
-                        }
-                        else {
-                            this.doc.rolodexProblemMap.set("root", [problem]);
-                        }
-                    }
-                    else {
-                        const currProblems = this.doc.rolodexProblemMap.get(this.doc.rolodexRootPath);
-                        if (currProblems) {
-                            currProblems.push(problem);
-                            this.doc.rolodexProblemMap.set(this.doc.rolodexRootPath, currProblems);
-                        }
-                        else {
-                            this.doc.rolodexProblemMap.set(this.doc.rolodexRootPath, [problem]);
-                        }
-                    }
-                }
-            }
+            const key = this.resolveProblemKey(problem);
+            this.addProblemToMap(key, problem);
         });
-        return this.doc.rolodexProblemMap;
+        return this.deps.rolodexProblemMap;
+    }
+    resolveProblemKey(problem) {
+        let sourceLocation = problem.sourceLocation;
+        if (sourceLocation === '/root.yaml' || sourceLocation === 'root.yaml') {
+            sourceLocation = 'root';
+            problem.sourceLocation = 'root';
+        }
+        if (!sourceLocation) {
+            return 'root';
+        }
+        return sourceLocation;
+    }
+    addProblemToMap(key, problem) {
+        const existing = this.deps.rolodexProblemMap.get(key);
+        if (existing) {
+            existing.push(problem);
+        }
+        else {
+            this.deps.rolodexProblemMap.set(key, [problem]);
+        }
     }
     queryRolodex(currentPath) {
         ModelService.queryRolodex().then((result) => {
-            this.doc.modelController.fetchRefMap(currentPath);
-            this.doc.editor.showBreadcrumb = true;
-            this.doc.rolodexNeedsReset = false;
+            this.deps.modelController.fetchRefMap(currentPath);
+            this.deps.editor.showBreadcrumb = true;
+            this.deps.rolodexNeedsReset = false;
             result.rolodexRoot.treeExpanded = true;
-            this.doc.rolodexTree.isRolodex = true;
-            this.doc.rolodexTree.node = result.rolodexRoot;
-            this.doc.rolodexRoot = result.rolodexRoot;
-            if (this.doc.rolodexActiveHash) {
-                this.doc.rolodexTree.pendingNavigationHash = this.doc.rolodexActiveHash;
+            this.deps.rolodexTree.isRolodex = true;
+            const nodeMap = buildNodeMap(result.nodes);
+            this.deps.rolodexTree.nodeMap = nodeMap;
+            this.deps.rolodexTree.childrenRendered.add(result.rolodexRoot.id);
+            this.deps.rolodexTree.expandedNodes.set(result.rolodexRoot.id, result.rolodexRoot);
+            this.deps.rolodexTree.node = result.rolodexRoot;
+            this.deps.rolodexRoot = result.rolodexRoot;
+            let activeNodeId;
+            if (this.deps.rolodexActiveHash) {
+                const resolvedId = resolveNodeIdFromHash(this.deps.rolodexActiveHash, nodeMap);
+                if (resolvedId) {
+                    this.deps.rolodexTree.pendingNavigationId = resolvedId;
+                    activeNodeId = resolvedId;
+                }
+            }
+            else if (result.rolodexRoot.nodes?.length > 0) {
+                const rootFile = this.findRootFile(nodeMap);
+                if (rootFile) {
+                    this.expandAncestors(rootFile, nodeMap);
+                    this.deps.rolodexTree.pendingNavigationPath = rootFile.path || rootFile.nodePath;
+                    this.deps.rolodexActivePath = rootFile.path || rootFile.nodePath;
+                    this.deps.rolodexActiveHash = rootFile.idHash;
+                    this.deps.rolodexRootPath = rootFile.path || rootFile.nodePath;
+                    this.deps.rolodexRootHash = rootFile.idHash;
+                    activeNodeId = rootFile.id;
+                }
             }
-            if (this.doc.rolodexActivePath) {
-                this.doc.rolodexTree.pendingNavigationPath = this.doc.rolodexActivePath;
+            if (this.deps.rolodexActivePath) {
+                this.deps.rolodexTree.pendingNavigationPath = this.deps.rolodexActivePath;
             }
             if (result.rolodexRoot.nodes?.length > 0) {
-                this.doc.importDisabled = true;
+                this.deps.importDisabled = true;
             }
-            this.doc.rolodexResponseBag?.set(RolodexResponseBag, result);
-            const existingState = this.doc.rolodexStateBag?.get(RolodexStateBag);
+            this.deps.rolodexResponseBag?.set(RolodexResponseBag, result);
+            const existingState = this.deps.rolodexStateBag?.get(RolodexStateBag);
             if (!existingState) {
-                const existingState = {
-                    activePath: this.doc.rolodexActivePath,
-                    rootPath: this.doc.rolodexRootPath,
+                const newState = {
+                    activePath: this.deps.rolodexActivePath,
+                    activeId: activeNodeId,
+                    activeHash: this.deps.rolodexActiveHash,
+                    rootPath: this.deps.rolodexRootPath,
+                    rootId: activeNodeId,
+                    rootHash: this.deps.rolodexRootHash
                 };
-                this.doc.rolodexStateBag?.set(RolodexStateBag, existingState);
+                this.deps.rolodexStateBag?.set(RolodexStateBag, newState);
             }
-            this.doc.requestUpdate();
+            else {
+                if (this.deps.rolodexRootPath) {
+                    existingState.rootPath = this.deps.rolodexRootPath;
+                    existingState.rootId = activeNodeId;
+                    existingState.rootHash = this.deps.rolodexRootHash;
+                    this.deps.rolodexStateBag?.set(RolodexStateBag, existingState);
+                }
+            }
+            this.deps.requestUpdate();
         }).catch((e) => {
             console.info("rolodex returned and error:", e.detail);
         });
     }
+    findRootFile(nodeMap) {
+        for (const node of nodeMap.values()) {
+            if (node.openapi) {
+                return node;
+            }
+        }
+        for (const node of nodeMap.values()) {
+            if (node.type === NodeType.ROLODEX_FILE) {
+                return node;
+            }
+        }
+        return null;
+    }
+    expandAncestors(node, nodeMap) {
+        const hashToNode = buildHashToNodeMap(nodeMap);
+        const ancestors = collectAncestors(node, nodeMap, hashToNode);
+        for (const ancestor of ancestors) {
+            ancestor.treeExpanded = true;
+            this.deps.rolodexTree.childrenRendered.add(ancestor.id);
+            this.deps.rolodexTree.expandedNodes.set(ancestor.id, ancestor);
+        }
+    }
 }

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

@@ -1,9 +1,15 @@
-import { TheDoctor } from "../components/the-doctor/the-doctor";
-import { CustomRulesetEnabledEvent, ProblemRuleFilterChangedEvent, RuleClickedEvent, RulesetSavedEvent } from "../events/doctor";
-import { RuleSet } from "../model/vacuum_rule";
+import { CustomRulesetEnabledEvent, ProblemRuleFilterChangedEvent, RuleClickedEvent, RulesetSavedEvent } from "../events/doctor.js";
+import { RuleSet } from "../model/vacuum_rule.js";
+import type { RuleControllerDeps } from "../interfaces/doctor-interfaces.js";
 export declare class RuleController extends EventTarget {
-    doc: TheDoctor;
-    constructor(doc: TheDoctor);
+    private readonly deps;
+    private bounceId;
+    private readonly debounceTimeRuleset;
+    constructor(deps: RuleControllerDeps);
+    private createCustomRuleset;
+    private errorToast;
+    private infoToast;
+    private warningToast;
     ruleClicked(evt: CustomEvent<RuleClickedEvent>): void;
     rulesetSaved(evt: CustomEvent<RulesetSavedEvent>): void;
     customRulesetEnabled(event: CustomEvent<CustomRulesetEnabledEvent>): void;
@@ -16,4 +22,5 @@ export declare class RuleController extends EventTarget {
     fetchAllRuleset(): Promise<RuleSet>;
     fetchDefaultRuleset(): Promise<RuleSet>;
     fetchOWASPRuleset(): Promise<RuleSet>;
+    destroy(): void;
 }