@pb33f/cowboy-components 0.13.1 → 0.14.1

package/dist/components/yaml-viewer/yaml-viewer.js

@@ -0,0 +1,86 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+import { LitElement, html, nothing } from 'lit';
+import { customElement, property } from 'lit/decorators.js';
+import { repeat } from 'lit/directives/repeat.js';
+import { unsafeHTML } from 'lit/directives/unsafe-html.js';
+import yamlViewerCss from './yaml-viewer.css.js';
+let Pb33fYamlViewer = class Pb33fYamlViewer extends LitElement {
+    constructor() {
+        super(...arguments);
+        this.spec = '';
+        this.highlighted = {};
+        this.firstLine = 1;
+        this.focusStart = 0;
+        this.focusEnd = 0;
+        this.language = 'yaml';
+        this.cachedSpec = '';
+        this.cachedLines = [];
+    }
+    scrollToLine(line) {
+        const row = this.renderRoot.querySelector(`[data-line="${line}"]`);
+        row?.scrollIntoView({ block: 'center', behavior: 'auto' });
+    }
+    emphasis(line) {
+        if (this.focusStart > 0 && line >= this.focusStart && line <= (this.focusEnd || this.focusStart)) {
+            return 'focus';
+        }
+        return '';
+    }
+    lines() {
+        if (this.spec !== this.cachedSpec) {
+            this.cachedSpec = this.spec;
+            this.cachedLines = this.spec.split('\n');
+        }
+        return this.cachedLines;
+    }
+    renderLine(line, idx) {
+        const lineNumber = this.firstLine + idx;
+        const highlightedContent = this.highlighted?.[lineNumber];
+        const emphasis = this.emphasis(lineNumber);
+        return html `
+            <div class="diff-line equal"
+                 data-emphasis=${emphasis || nothing}
+                 data-line=${lineNumber}
+                 data-original-line=${lineNumber}>
+                <span class="line-gutter"></span>
+                <span class="line-number">${lineNumber}</span>
+                <span class="line-content">${highlightedContent ? unsafeHTML(highlightedContent) : line}</span>
+            </div>
+        `;
+    }
+    render() {
+        return html `
+            <div class="yaml-viewer" data-language=${this.language}>
+                ${repeat(this.lines(), (_, idx) => this.firstLine + idx, (line, idx) => this.renderLine(line, idx))}
+            </div>
+        `;
+    }
+};
+Pb33fYamlViewer.styles = yamlViewerCss;
+__decorate([
+    property()
+], Pb33fYamlViewer.prototype, "spec", void 0);
+__decorate([
+    property({ type: Object })
+], Pb33fYamlViewer.prototype, "highlighted", void 0);
+__decorate([
+    property({ type: Number })
+], Pb33fYamlViewer.prototype, "firstLine", void 0);
+__decorate([
+    property({ type: Number })
+], Pb33fYamlViewer.prototype, "focusStart", void 0);
+__decorate([
+    property({ type: Number })
+], Pb33fYamlViewer.prototype, "focusEnd", void 0);
+__decorate([
+    property()
+], Pb33fYamlViewer.prototype, "language", void 0);
+Pb33fYamlViewer = __decorate([
+    customElement('pb33f-yaml-viewer')
+], Pb33fYamlViewer);
+export { Pb33fYamlViewer };

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

@@ -1,12 +1,8 @@
 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;
-}
+import type { DiagramRequestedEvent } from '../events/doctor.js';
+export type { DiagramRequestedEvent } from '../events/doctor.js';
 export declare class DiagramatronController extends EventTarget {
     private readonly deps;
     private diagramService;

package/dist/controllers/diagramatron-controller.js

@@ -21,7 +21,7 @@ export class DiagramatronController extends EventTarget {
         this.drawer = drawer;
     }
     async handleDiagramRequest(event) {
-        const { nodeId, jsonPath, title } = event.detail;
+        const { nodeId, jsonPath, title, onComplete } = event.detail;
         if (this.isGenerating) {
             this.deps.sendToast({
                 id: crypto.randomUUID(),
@@ -29,6 +29,7 @@ export class DiagramatronController extends EventTarget {
                 title: 'Diagram Generation In Progress',
                 body: 'Please wait for the current diagram to complete'
             });
+            onComplete?.();
             return;
         }
         if (!jsonPath) {
@@ -38,6 +39,7 @@ export class DiagramatronController extends EventTarget {
                 title: 'Invalid Request',
                 body: 'No JSON path provided for diagram generation'
             });
+            onComplete?.();
             return;
         }
         this.isGenerating = true;
@@ -93,6 +95,7 @@ export class DiagramatronController extends EventTarget {
         finally {
             this.isGenerating = false;
             this.deps.activity.hide();
+            onComplete?.();
         }
     }
     /**

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

@@ -4,6 +4,7 @@ export declare class ProblemController extends EventTarget {
     private readonly deps;
     constructor(deps: ProblemControllerDeps);
     problemClicked(event: CustomEvent<ProblemClickedEvent>): void;
+    private resolveProblemClickTarget;
     private ensureSpecTabActive;
     private normalizeSourceLocation;
     private navigateToRolodexNode;

package/dist/controllers/problem-controller.js

@@ -6,28 +6,44 @@ export class ProblemController extends EventTarget {
         this.deps = deps;
     }
     problemClicked(event) {
+        const target = this.resolveProblemClickTarget(event.detail);
         if (this.deps.viewingHistoricalViolations) {
-            this.navigateInHistoricalDiff(event.detail.problem, event.detail.launchedFromProblems);
+            this.navigateInHistoricalDiff(target, event.detail.launchedFromProblems);
         }
         else {
             this.ensureSpecTabActive();
-            const sourceLocation = this.normalizeSourceLocation(event.detail.problem);
+            const sourceLocation = this.normalizeSourceLocation(target.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);
+                this.navigateToRolodexNode(node, sourceLocation, target);
             }
             else if (this.isRolodexFilePath(sourceLocation)) {
-                this.navigateToRolodexFile(sourceLocation, event.detail.problem);
+                this.navigateToRolodexFile(sourceLocation, target);
             }
             else {
-                this.navigateInEditor(event.detail.problem, event.detail.launchedFromProblems);
+                this.navigateInEditor(target, event.detail.launchedFromProblems);
             }
         }
         this.deps.genericDrawer.close();
     }
+    resolveProblemClickTarget(event) {
+        if (event.problemItem) {
+            return {
+                problem: event.problem,
+                problemItem: event.problemItem,
+                line: event.problemItem.line,
+                column: event.problemItem.column
+            };
+        }
+        return {
+            problem: event.problem,
+            line: event.problem.startLineNumber,
+            column: event.problem.startColumn
+        };
+    }
     ensureSpecTabActive() {
         if (this.deps.selectedEditorTab !== "spec") {
             this.deps.editorPanel?.showTab("spec");
@@ -35,19 +51,19 @@ export class ProblemController extends EventTarget {
         }
     }
     normalizeSourceLocation(problem) {
-        const sourceLocation = problem.problemObject.sourceLocation;
+        const sourceLocation = problem.sourceLocation;
         if (!sourceLocation || sourceLocation === 'root') {
             return this.deps.rolodexRootPath;
         }
         return sourceLocation;
     }
-    navigateToRolodexNode(node, path, problem) {
+    navigateToRolodexNode(node, path, target) {
         this.deps.nodeClickerController.rolodexTreeNodeClicked(new CustomEvent(RolodexTreeNodeClicked, {
             detail: {
                 nodeHashId: node.idHash,
                 path: path,
-                line: problem.problemObject.startLineNumber,
-                column: problem.problemObject.startColumn
+                line: target.problem.startLineNumber,
+                column: target.problem.startColumn
             }
         }));
         this.deps.rolodexTree.openNodeByPath(path);
@@ -60,46 +76,46 @@ export class ProblemController extends EventTarget {
         }
         return /\.(ya?ml|json)(#.*)?$/i.test(sourceLocation);
     }
-    navigateToRolodexFile(path, problem) {
+    navigateToRolodexFile(path, target) {
         this.deps.nodeClickerController.rolodexTreeNodeClicked(new CustomEvent(RolodexTreeNodeClicked, {
             detail: {
                 path: path,
-                line: problem.problemObject.startLineNumber,
-                column: problem.problemObject.startColumn
+                line: target.problem.startLineNumber,
+                column: target.problem.startColumn
             }
         }));
         this.deps.rolodexTree.openNodeByPath(path);
     }
-    navigateInEditor(problem, launchedFromProblems) {
+    navigateInEditor(target, 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);
+        if (editor && target.line !== undefined && target.column !== undefined) {
+            editor.revealLineInCenter(target.line);
             editor.setPosition({
-                lineNumber: problem.line,
-                column: problem.column
+                lineNumber: target.line,
+                column: target.column
             });
         }
         if (!launchedFromProblems) {
-            this.deps.problemList.lineClicked(problem.problemObject.startLineNumber);
+            this.deps.problemList.lineClicked(target.problem.startLineNumber);
         }
     }
-    navigateInHistoricalDiff(problem, launchedFromProblems) {
+    navigateInHistoricalDiff(target, 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);
+            if (diffEditor && target.line !== undefined && target.column !== undefined) {
+                diffEditor.revealLineInCenterOriginal(target.line);
                 diffEditor.setPositionOriginal({
-                    lineNumber: problem.line,
-                    column: problem.column
+                    lineNumber: target.line,
+                    column: target.column
                 });
             }
         }
         if (!launchedFromProblems) {
-            this.deps.problemList.lineClicked(problem.problemObject.startLineNumber);
+            this.deps.problemList.lineClicked(target.problem.startLineNumber);
         }
     }
 }