@pb33f/cowboy-components 0.7.4 → 0.7.6

package/dist/controllers/node-clicker-controller.js

@@ -0,0 +1,362 @@
+import { RolodexFilesBag, RolodexStateBag } from "../components/the-doctor/the-doctor.js";
+import { RolodexTreeNodeClicked } from "../events/doctor.js";
+import { ToastType } from "../model/toast.js";
+import { NodeType } from "../model/node_type.js";
+import { ModelService } from "../services/model-service.js";
+export class NodeClickerController extends EventTarget {
+    constructor(doc) {
+        super();
+        this.doc = doc;
+    }
+    rolodexTreeNodeClicked(evt) {
+        const fileBag = this.doc.rolodexFilesBag?.get(RolodexFilesBag);
+        const handleRolodexResponse = (result) => {
+            this.doc.rolodexActivePath = evt.detail.path;
+            this.doc.rolodexActiveHash = evt.detail.nodeHashId;
+            this.doc.editor.setValue(result.instance, true);
+            this.doc.editor.setCurrentPath(this.doc.rolodexActivePath);
+            this.doc.modelController.fetchRefMap(this.doc.rolodexActivePath);
+            const probs = this.doc.rolodexProblemMap.get(this.doc.rolodexActivePath);
+            if (probs) {
+                this.doc.editor.setMarkers(probs);
+            }
+            // set the editor file type
+            let language = 'yaml';
+            const ext = evt.detail?.path?.split('.').pop();
+            if (ext) {
+                switch (ext) {
+                    case NodeType.JSON:
+                        language = NodeType.JSON;
+                        break;
+                    case NodeType.GO:
+                        language = NodeType.GO;
+                        break;
+                    case NodeType.PY:
+                        language = 'python';
+                        break;
+                    case NodeType.JS:
+                        language = 'javascript';
+                        break;
+                    case NodeType.TS:
+                        language = 'typescript';
+                        break;
+                    case NodeType.PHP:
+                        language = NodeType.PHP;
+                        break;
+                    case NodeType.XML:
+                        language = NodeType.XML;
+                        break;
+                    case NodeType.JAVA:
+                        language = NodeType.JAVA;
+                        break;
+                    case NodeType.RB:
+                        language = 'ruby';
+                        break;
+                    case NodeType.RS:
+                        language = 'rust';
+                        break;
+                    case NodeType.C:
+                        language = NodeType.C;
+                        break;
+                    case NodeType.CPP:
+                        language = NodeType.CPP;
+                        break;
+                    case NodeType.CS:
+                        language = 'csharp';
+                        break;
+                    case NodeType.MD:
+                        language = 'markdown';
+                        break;
+                }
+            }
+            const existingState = this.doc.rolodexStateBag?.get(RolodexStateBag);
+            if (existingState) {
+                existingState.activePath = evt.detail.path;
+                existingState.activeHash = evt.detail.nodeHashId;
+                existingState.activeLanguage = language;
+                existingState.activeNode = result;
+                existingState.rootPath = this.doc.rolodexRootPath;
+                this.doc.rolodexStateBag?.set(RolodexStateBag, existingState);
+            }
+            else {
+                const existingState = {
+                    activePath: evt.detail.path,
+                    activeHash: evt.detail.nodeHashId,
+                    activeLanguage: language,
+                    activeNode: result,
+                    rootHash: this.doc.rolodexRootHash,
+                    rootPath: this.doc.rolodexRootPath
+                };
+                this.doc.rolodexStateBag?.set(RolodexStateBag, existingState);
+            }
+            this.doc.editor.switchLanguage(language);
+            let line = 1;
+            let col = 0;
+            if (evt.detail.line) {
+                line = evt.detail.line;
+            }
+            if (evt.detail.column) {
+                col = evt.detail.column;
+            }
+            this.doc.editor.editor?.setPosition({ lineNumber: line, column: col });
+            this.doc.editor.editor?.revealLineInCenter(line, col);
+            //this.lintSpec(result.instance);
+            if (evt.detail.path) {
+                this.doc.rolodexTree.openNodeByPath(evt.detail.path);
+            }
+            return language;
+        };
+        ModelService.queryRolodex(evt.detail.nodeHashId, evt.detail.path).then((result) => {
+            this.doc.editor.showBreadcrumb = true;
+            // clear all references
+            this.doc.referenceMapBag?.reset();
+            handleRolodexResponse(result.rolodexRoot);
+            if (evt.detail.path) {
+                if (fileBag && !fileBag.files[evt.detail.path]) {
+                    fileBag.files[evt.detail.path] = result.rolodexRoot;
+                    this.doc.rolodexFilesBag?.set(RolodexFilesBag, fileBag);
+                }
+                if (!fileBag) {
+                    const rf = {
+                        files: { [evt.detail.path]: result.rolodexRoot }
+                    };
+                    this.doc.rolodexFilesBag?.set(RolodexFilesBag, rf);
+                }
+            }
+        });
+    }
+    explorerNodeClicked(evt, replaceRenderedNode = true) {
+        let found = false;
+        let foundRenderedNode;
+        this.doc.explorer.nodeComponents.forEach((node) => {
+            if (node.id === evt.detail.nodeId) {
+                let renderedNode;
+                if (replaceRenderedNode) {
+                    renderedNode = this.doc.renderedNodeMap.get(node.id);
+                    if (renderedNode && !this.doc.firstRun) {
+                        this.doc.renderedNode.node = renderedNode;
+                    }
+                }
+                this.doc.selectedNodeHashId = node.body.node.idHash;
+                node.body.active = true;
+                this.doc.activeNode = node.body.node;
+                this.doc.explorer.activeNode = node.body.node;
+                found = true;
+                if (replaceRenderedNode) {
+                    foundRenderedNode = renderedNode;
+                }
+                if (!evt.detail.noState) {
+                    this.doc.addClickTrack(node.body.node);
+                }
+            }
+            else {
+                node.body.active = false;
+            }
+        });
+        if (!found) {
+            // might be filtered, check the filtered nodes
+            const node = this.doc.nodeIdMap.get(evt.detail.nodeId);
+            if (node) {
+                this.doc.selectedNodeHashId = node.idHash;
+                this.doc.activeNode = node;
+                this.doc.explorer.activeNode = node;
+                this.doc.explorer.equalizer.activeNode = node;
+            }
+        }
+        if (foundRenderedNode) {
+            // when jumping back to the spec view, we need to set the line
+            this.doc.pendingLine = foundRenderedNode.keyLine;
+        }
+        this.doc.modelTree.explorerClicked(evt.detail.nodeId);
+        if (!this.doc.firstRun) {
+            this.doc.viewerPanel.click();
+        }
+        this.doc.explorer.requestUpdate();
+    }
+    modelTreeNodeClicked(evt) {
+        let node = this.doc.nodeIdMap.get(evt.detail.nodeId);
+        if (!node) {
+            node = this.doc.nodeIdHashMap.get(evt.detail.nodeId);
+        }
+        if (node) {
+            if (node.origin && node.origin != this.doc.rolodexActivePath && (node.origin != '/root.yaml' && node.origin != 'root.yaml')) {
+                // extract the rolodex id using the path
+                let hashId = '';
+                let path = '';
+                const fb = this.doc.rolodexFilesBag?.get(RolodexFilesBag);
+                if (fb) {
+                    if (node.origin && fb.files[node.origin]) {
+                        hashId = fb.files[node.origin].idHash;
+                        path = node.origin;
+                    }
+                }
+                this.explorerNodeClicked(evt, true);
+                // we need to fire a rolodex tree node change event.
+                this.rolodexTreeNodeClicked(new CustomEvent(RolodexTreeNodeClicked, {
+                    detail: {
+                        nodeHashId: hashId,
+                        path: path
+                    }
+                }));
+                return;
+            }
+            // don't jump to the root in the editor if the root is selected
+            if (node.idHash !== 'root') {
+                this.doc.editor.editor?.setPosition({ lineNumber: node.keyLine, column: 0 });
+                this.doc.editor.editor?.revealLineInCenter(node.keyLine);
+            }
+            if (this.doc.explorerVisible) {
+                this.doc.explorer.moveToNode(node, evt.detail.first);
+            }
+            this.doc.activeNode = node;
+            // add changes to active node.
+            if (evt.detail.changes) {
+                node.timeline = evt.detail.changes;
+            }
+            this.doc.explorer.activeNode = node;
+            this.doc.explorer.equalizer.activeNode = node;
+            const renderedNode = structuredClone(this.doc.renderedNodeMap.get(node.id));
+            if (renderedNode) {
+                if (evt.detail.changes) {
+                    renderedNode.timeline = evt.detail.changes;
+                }
+                this.doc.renderedNode.node = renderedNode;
+            }
+            else {
+                alert('no id found');
+            }
+            if (!evt.detail.noState) {
+                this.doc.addClickTrack(node);
+                evt.detail.noState = true;
+            }
+            this.explorerNodeClicked(evt, true);
+            if (this.doc.firstRun) {
+                this.doc.firstRun = false;
+            }
+            else {
+                this.doc.viewerPanel.click();
+            }
+        }
+        else {
+            this.doc.sendToast({
+                id: crypto.randomUUID(),
+                title: 'Unable to load change model',
+                type: ToastType.WARNING,
+                body: 'There is no-longer a model with the path `' + evt.detail.nodeId + '` in the document',
+            });
+            console.error('cannot navigate to node, path not found', evt.detail.nodeId);
+        }
+    }
+    explorerReferenceClicked(evt) {
+        let nodeId = '';
+        this.doc.explorer.nodeComponents.forEach((node) => {
+            if (node.body.node.nodePath === evt.detail.nodePath) {
+                const renderedNode = this.doc.renderedNodeMap.get(node.body.node.id);
+                if (renderedNode) {
+                    this.doc.editor.editor?.setPosition({ lineNumber: renderedNode.keyLine, column: 0 });
+                    this.doc.editor.editor?.revealLineInCenter(renderedNode.keyLine);
+                    this.doc.renderedNode.node = renderedNode;
+                    nodeId = node.body.node.id;
+                    this.doc.explorer.moveToNode(node.body.node);
+                    this.doc.activeNode = node.body.node;
+                    this.doc.explorer.activeNode = node.body.node;
+                    this.doc.explorer.equalizer.activeNode = node.body.node;
+                }
+                node.body.active = true;
+            }
+            else {
+                node.body.active = false;
+            }
+        });
+        if (nodeId) {
+            this.doc.modelTree.explorerClicked(nodeId);
+            this.doc.explorer.requestUpdate();
+            this.doc.viewerPanel.click();
+        }
+        if (evt.detail.nodePath) {
+            let p = evt.detail.nodePath;
+            if (!p.startsWith('/') && !p.includes('#')) {
+                const dir = this.doc.rolodexRootPath.substring(0, this.doc.rolodexRootPath.lastIndexOf('/') + 1);
+                p = dir + p;
+            }
+            if (!p.startsWith('#/')) {
+                this.rolodexTreeNodeClicked(new CustomEvent(RolodexTreeNodeClicked, {
+                    detail: {
+                        path: p,
+                    }
+                }));
+            }
+        }
+    }
+    documentReferenceClicked(evt) {
+        let location = '';
+        let line, col = 1;
+        let path = evt.detail.jsonPath;
+        let fullPath = '';
+        let file = '';
+        let rolodexId = '';
+        if (evt.detail.jsonPath.includes('||')) {
+            location = evt.detail.jsonPath.split('||')[1];
+            path = evt.detail.jsonPath.split('||')[0];
+            // location is formatted line:col-endCol
+            line = parseInt(location.split(':')[0]);
+            col = parseInt(location.split(':')[1]);
+            fullPath = evt.detail.jsonPath.split('||')[2];
+            if (fullPath != '') {
+                file = fullPath.split('#')[0];
+            }
+            rolodexId = evt.detail.jsonPath.split('||')[3];
+        }
+        this.doc.editor.editor?.setPosition({ lineNumber: line, column: col });
+        this.doc.editor.editor?.revealLineInCenter(line);
+        if (this.doc.nodeIdMap.has(path)) {
+            const node = this.doc.nodeIdMap.get(path);
+            if (node) {
+                if (this.doc.nodeIdHashMap.has(node.idHash)) {
+                    const renderedNode = this.doc.renderedNodeMap.get(node.id);
+                    if (renderedNode) {
+                        this.doc.renderedNode.node = renderedNode;
+                        this.doc.modelTree.explorerClicked(node.id);
+                        // add a ref click
+                        if (!evt.detail.noState) {
+                            this.doc.addRefTrack(evt.detail.jsonPath);
+                        }
+                    }
+                }
+            }
+            else {
+                this.doc.toastManager.addToastManually({
+                    id: crypto.randomUUID(),
+                    type: ToastType.INFO,
+                    title: "Reference not found",
+                    body: `Something went wrong, '${path}' not found`
+                });
+            }
+        }
+        else {
+            if (this.doc.rolodexActivePath != undefined && this.doc.rolodexActivePath != file) {
+                ModelService.queryRolodex(rolodexId, file).then((result) => {
+                    this.doc.editor.showBreadcrumb = true;
+                    this.doc.rolodexActivePath = file;
+                    this.doc.editor.clearDecorations();
+                    this.doc.editor.setValue(result.rolodexRoot.instance, true);
+                    this.doc.editor.editor?.setPosition({ lineNumber: line, column: 1 });
+                    this.doc.editor.editor?.revealLineInCenter(line);
+                    this.doc.rolodexTree.explorerClicked(rolodexId);
+                    this.doc.editor.setCurrentPath(file);
+                    this.doc.modelController.fetchRefMap(file);
+                    //this.lintSpec(result.rolodexRoot.instance);
+                    // apply problems
+                    if (this.doc.rolodexProblemMap.has(this.doc.rolodexActivePath)) {
+                        const probs = this.doc.rolodexProblemMap.get(this.doc.rolodexActivePath);
+                        if (probs) {
+                            this.doc.editor.setMarkers(probs);
+                        }
+                    }
+                }).catch((e) => {
+                    console.error('rolodex query failed', e);
+                });
+            }
+        }
+    }
+}

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

@@ -0,0 +1,7 @@
+import { TheDoctor } from "../components/the-doctor/the-doctor";
+import { ProblemClickedEvent } from "../events/doctor";
+export declare class ProblemController extends EventTarget {
+    doc: TheDoctor;
+    constructor(doc: TheDoctor);
+    problemClicked(event: CustomEvent<ProblemClickedEvent>): void;
+}

package/dist/controllers/problem-controller.js

@@ -0,0 +1,46 @@
+import { ActiveView, RolodexTreeNodeClicked } from "../events/doctor";
+import { SearchNodeTreeForPath } from "../model/graph";
+export class ProblemController extends EventTarget {
+    constructor(doc) {
+        super();
+        this.doc = doc;
+    }
+    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);
+        }
+    }
+}

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

@@ -0,0 +1,10 @@
+import { TheDoctor } from "../components/the-doctor/the-doctor.js";
+import { NodeClickedEvent } from "../events/doctor.js";
+import { Problem } from "../model/problem";
+export declare class RolodexController extends EventTarget {
+    doc: TheDoctor;
+    constructor(doc: TheDoctor);
+    rolodexRootFileSelected(evt: CustomEvent<NodeClickedEvent>): void;
+    buildRolodexResultMap(results: Problem[]): Map<string, Problem[]>;
+    queryRolodex(currentPath?: string): void;
+}

package/dist/controllers/rolodex-controller.js

@@ -0,0 +1,126 @@
+import { RolodexResponseBag, RolodexStateBag } from "../components/the-doctor/the-doctor.js";
+import { ModelService } from "../services/model-service";
+export class RolodexController extends EventTarget {
+    constructor(doc) {
+        super();
+        this.doc = doc;
+    }
+    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);
+        if (existingState) {
+            existingState.activePath = evt.detail.path;
+            existingState.activeHash = evt.detail.nodeHashId;
+            existingState.rootPath = evt.detail.path;
+            existingState.rootHash = evt.detail.nodeHashId;
+            this.doc.rolodexStateBag?.set(RolodexStateBag, existingState);
+        }
+        else {
+            const existingState = {
+                activePath: evt.detail.path,
+                activeHash: evt.detail.nodeHashId,
+                rootPath: evt.detail.path,
+                rootHash: evt.detail.nodeHashId
+            };
+            this.doc.rolodexStateBag?.set(RolodexStateBag, existingState);
+        }
+        if (evt.detail.nodeHashId) {
+            this.doc.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);
+        }
+    }
+    buildRolodexResultMap(results) {
+        // TODO: optimize this, it's a bit slow.
+        this.doc.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]);
+                        }
+                    }
+                }
+            }
+        });
+        return this.doc.rolodexProblemMap;
+    }
+    queryRolodex(currentPath) {
+        ModelService.queryRolodex().then((result) => {
+            this.doc.modelController.fetchRefMap(currentPath);
+            this.doc.editor.showBreadcrumb = true;
+            this.doc.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;
+            }
+            if (this.doc.rolodexActivePath) {
+                this.doc.rolodexTree.pendingNavigationPath = this.doc.rolodexActivePath;
+            }
+            if (result.rolodexRoot.nodes?.length > 0) {
+                this.doc.importDisabled = true;
+            }
+            this.doc.rolodexResponseBag?.set(RolodexResponseBag, result);
+            const existingState = this.doc.rolodexStateBag?.get(RolodexStateBag);
+            if (!existingState) {
+                const existingState = {
+                    activePath: this.doc.rolodexActivePath,
+                    rootPath: this.doc.rolodexRootPath,
+                };
+                this.doc.rolodexStateBag?.set(RolodexStateBag, existingState);
+            }
+            this.doc.requestUpdate();
+        }).catch((e) => {
+            console.info("rolodex returned and error:", e.detail);
+        });
+    }
+}

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

@@ -0,0 +1,19 @@
+import { TheDoctor } from "../components/the-doctor/the-doctor";
+import { CustomRulesetEnabledEvent, ProblemRuleFilterChangedEvent, RuleClickedEvent, RulesetSavedEvent } from "../events/doctor";
+import { RuleSet } from "../model/vacuum_rule";
+export declare class RuleController extends EventTarget {
+    doc: TheDoctor;
+    constructor(doc: TheDoctor);
+    ruleClicked(evt: CustomEvent<RuleClickedEvent>): void;
+    rulesetSaved(evt: CustomEvent<RulesetSavedEvent>): void;
+    customRulesetEnabled(event: CustomEvent<CustomRulesetEnabledEvent>): void;
+    ruleGroupClicked(event: CustomEvent<ProblemRuleFilterChangedEvent>): void;
+    rulesetManuallyChanged(): void;
+    fetchRulesetMap(): void;
+    exportJSON(): void;
+    exportYAML(): void;
+    fetchSessionRulesetAsYaml(): Promise<string>;
+    fetchAllRuleset(): Promise<RuleSet>;
+    fetchDefaultRuleset(): Promise<RuleSet>;
+    fetchOWASPRuleset(): Promise<RuleSet>;
+}