@pb33f/cowboy-components 0.6.7 → 0.7.0

package/dist/components/model-renderer/security-scheme.js

@@ -62,7 +62,7 @@ let RenderedSecuritySchemeNodeComponent = class RenderedSecuritySchemeNodeCompon
         }
         return html `
             ${type}
-            ${name}${scheme}${schemeIn}${openidConnectUrl}${description}${flows}${ext}`;
+            ${name}${scheme}${schemeIn}${openidConnectUrl}${description}${flows}${ext}${super.renderChanges()}`;
     }
 };
 RenderedSecuritySchemeNodeComponent.styles = [sharedCss, modelSharedCss, listsCss, formattingCss];

package/dist/components/model-renderer/server.js

@@ -65,6 +65,7 @@ let RenderedServerNodeComponent = class RenderedServerNodeComponent extends Clic
             ${description}
             ${variables}
             ${ext}
+            ${super.renderChanges()}
         `;
     }
 };

package/dist/components/model-renderer/tag.js

@@ -39,7 +39,9 @@ let RenderedTagNodeComponent = class RenderedTagNodeComponent extends ClickableR
         return html `
             ${description}
             ${externalDocs}
-            ${ext}`;
+            ${ext}
+            ${super.renderChanges()}
+        `;
     }
 };
 RenderedTagNodeComponent.styles = [sharedCss, modelSharedCss, formattingCss];

package/dist/components/model-tree/tree.d.ts

@@ -2,7 +2,7 @@ import '@shoelace-style/shoelace/dist/components/tree/tree.js';
 import '@shoelace-style/shoelace/dist/components/tree-item/tree-item.js';
 import { LitElement, TemplateResult } from "lit";
 import { SlTreeItem } from "@shoelace-style/shoelace";
-import { Node } from "../../model/graph.js";
+import { Change, Node } from "../../model/graph.js";
 export declare class ModelTree extends LitElement {
     static styles: import("lit").CSSResult[];
     node: Node;
@@ -10,19 +10,22 @@ export declare class ModelTree extends LitElement {
     nodeIdMap: Map<string, Node>;
     nodeIdHashMap: Map<string, Node>;
     filteredNodes: Map<string, Node>;
+    expand: boolean;
     renderedNodes: Map<string, Node>;
     nodeLimitExceeded: boolean;
     nodeLimit: number;
+    nodesWithChanges: Map<string, Node>;
+    expandedNodes: Map<string, Node>;
     isRolodex: boolean;
     constructor(nodeMap: Map<string, Node>, nodeIdMap: Map<string, Node>, nodeIdHashMap: Map<string, Node>);
-    nodeClicked(nodeHashId: string): void;
-    rolodexClicked(nodeHashId: string, path?: string): void;
+    nodeClicked(nodeId: string, changes?: Change[]): void;
+    rolodexClicked(nodeId: string, path?: string, changes?: Change[]): void;
     openNode(parentId: string): void;
     pendingNavigationHash: string;
     pendingNavigationPath: string;
     updated(): void;
     openNodeByPath(path: string): void;
-    explorerClicked(nodeHashId: string): void;
+    explorerClicked(nodeId: string): void;
     collapse(evt: Event, node: Node): void;
     expanded(evt: Event, node: Node): void;
     renderLabel(node: Node, filtered?: boolean): TemplateResult;

package/dist/components/model-tree/tree.js

@@ -26,38 +26,44 @@ let ModelTree = class ModelTree extends LitElement {
         this.filteredNodes = new Map();
         this.pendingNavigationHash = "";
         this.pendingNavigationPath = "";
+        this.nodesWithChanges = new Map();
+        this.expand = false;
+        this.expandedNodes = new Map();
     }
-    nodeClicked(nodeHashId) {
+    nodeClicked(nodeId, changes = []) {
         this.dispatchEvent(new CustomEvent(ModelTreeNodeClicked, {
             bubbles: true,
             composed: true,
             detail: {
-                nodeHashId: nodeHashId,
+                nodeId: nodeId,
+                changes: changes,
             }
         }));
     }
-    rolodexClicked(nodeHashId, path = '') {
+    rolodexClicked(nodeId, path = '', changes = []) {
         this.dispatchEvent(new CustomEvent(RolodexTreeNodeClicked, {
             bubbles: true,
             composed: true,
             detail: {
-                nodeHashId: nodeHashId,
-                path: path
+                nodeId: nodeId,
+                path: path,
+                changes: changes
             }
         }));
     }
     openNode(parentId) {
-        if (this.nodeIdMap.get(parentId)) {
-            const parent = this.nodeIdMap.get(parentId);
+        if (this.nodeIdHashMap.get(parentId)) {
+            const parent = this.nodeIdHashMap.get(parentId);
             if (parent) {
+                this.expandedNodes.set(parent.id, parent);
                 this.openNode(parent.parentId);
+                this.renderRoot.querySelectorAll(`sl-tree-item#model-${CSS.escape(parent.id)}`)[0]?.setAttribute('expanded', 'true');
             }
-            this.renderRoot.querySelectorAll(`sl-tree-item#model-${parent?.idHash}`)[0]?.setAttribute('expanded', 'true');
             this.requestUpdate();
             return;
         }
         else {
-            const model = this.renderRoot.querySelectorAll(`sl-tree-item#model-${parentId}`)[0];
+            const model = this.renderRoot.querySelectorAll(`sl-tree-item#model-${CSS.escape(parentId)}`)[0];
             if (model) {
                 model.setAttribute('expanded', 'true');
                 // check if the model has a parent
@@ -104,21 +110,21 @@ let ModelTree = class ModelTree extends LitElement {
             }
         }
     }
-    explorerClicked(nodeHashId) {
+    explorerClicked(nodeId) {
         const treeItems = this.renderRoot?.querySelectorAll(`sl-tree-item`);
         if (!treeItems) {
-            this.pendingNavigationHash = nodeHashId;
+            this.pendingNavigationHash = nodeId;
         }
         else {
             if (this.pendingNavigationHash != "") {
-                nodeHashId = this.pendingNavigationHash;
+                nodeId = this.pendingNavigationHash;
                 this.pendingNavigationHash = "";
             }
         }
         let selected = null;
         for (let i = 0; i < treeItems?.length; i++) {
             const item = treeItems[i];
-            item.selected = item.id === `model-${nodeHashId}`;
+            item.selected = item.id === `model-${nodeId}`;
             if (item.selected) {
                 selected = item;
                 item.expanded = true;
@@ -187,8 +193,11 @@ let ModelTree = class ModelTree extends LitElement {
         if (node.label.toLowerCase() == 'document') {
             expanded = true;
         }
+        if (this.expandedNodes && this.expandedNodes.get(node.id)) {
+            expanded = true;
+        }
         let styleIco = IconColor.primary;
-        const filtered = (this.filteredNodes.size > 0 && !this.filteredNodes.get(node.idHash));
+        const filtered = (this.filteredNodes.size > 0 && !this.filteredNodes.get(node.id));
         if (node.type === NodeType.RESPONSE) {
             const label = parseInt(node.label);
             const style = ExtractStatusStyleFromCodeByCode(label);
@@ -212,8 +221,8 @@ let ModelTree = class ModelTree extends LitElement {
         }
         let warnBadge = html ``;
         let errorBadge = html ``;
-        if (this.renderedNodes && this.renderedNodes.get(node.idHash)) {
-            const renderedNode = this.renderedNodes.get(node.idHash);
+        if (this.renderedNodes && this.renderedNodes.get(node.id)) {
+            const renderedNode = this.renderedNodes.get(node.id);
             if (renderedNode && renderedNode.results) {
                 let warnings = 0;
                 let errors = 0;
@@ -325,9 +334,21 @@ let ModelTree = class ModelTree extends LitElement {
                 }
             }
         }
+        let changes = html ``;
+        if (node.timeline) {
+            this.nodesWithChanges.set(node.id, node);
+            changes = html `
+                <sl-tooltip content="total changes for ${node.label} object">
+                    <sl-icon name="stack" style="font-size: 1rem; vertical-align: bottom"></sl-icon> ${node.timeline.length}
+                </sl-tooltip>`;
+        }
+        // hard override if all nodes are expanded
+        if (this.expand) {
+            expanded = true;
+        }
         return html `
 
-            <sl-tree-item id="model-${node.idHash}" ?expanded="${expanded}"
+            <sl-tree-item id="model-${node.id}" ?expanded="${expanded}"
                           @sl-expand="${(evt) => {
             this.expanded(evt, node);
         }}"
@@ -346,7 +367,7 @@ let ModelTree = class ModelTree extends LitElement {
                                 <sl-icon name="eye-slash" style="vertical-align: middle; font-size: 0.8rem"></sl-icon>
                             </sl-tooltip>
                         </span>` : html `${this.renderLabel(node)}`}
-                        ${errorBadge} ${warnBadge}
+                        ${errorBadge} ${warnBadge} ${changes}
                     </div>
                 </div>
                 ${results}
@@ -356,20 +377,25 @@ let ModelTree = class ModelTree extends LitElement {
     nodesSelected(treeItems) {
         this.selectedNodes = treeItems;
         for (let i = 0; i < treeItems.length; i++) {
-            const hash = treeItems[i].getAttribute('data-hashId');
+            const nodeId = treeItems[i].id.replace('model-', '');
             const path = treeItems[i].getAttribute('data-path');
-            if (hash) {
+            if (nodeId) {
+                let changes = [];
+                const n = this.nodesWithChanges.get(nodeId);
+                if (n?.timeline) {
+                    changes = n.timeline;
+                }
                 if (!this.isRolodex) {
-                    this.nodeClicked(hash);
+                    this.nodeClicked(nodeId, changes);
                 }
                 else {
                     if (path && path != '') {
-                        if (this.currentHash === hash && this.currentPath === path) {
+                        if (this.currentHash === nodeId && this.currentPath === path) {
                             return;
                         }
-                        this.currentHash = hash;
+                        this.currentHash = nodeId;
                         this.currentPath = path;
-                        this.rolodexClicked(hash, path);
+                        this.rolodexClicked(nodeId, path, changes);
                     }
                 }
             }
@@ -382,7 +408,7 @@ let ModelTree = class ModelTree extends LitElement {
             return;
         // if the clicked item is already in selectedNodes, re-fire
         if (this.selectedNodes.some(item => item === clickedItem)) {
-            this.nodesSelected(this.selectedNodes);
+            // this.nodesSelected(this.selectedNodes);
         }
     }
     render() {
@@ -427,6 +453,9 @@ __decorate([
 __decorate([
     property()
 ], ModelTree.prototype, "filteredNodes", void 0);
+__decorate([
+    property({ type: Boolean })
+], ModelTree.prototype, "expand", void 0);
 __decorate([
     property()
 ], ModelTree.prototype, "isRolodex", void 0);

package/dist/components/paginator/paginator.css.js

@@ -3,9 +3,12 @@ export default css `
 
     .paginator-values {
         overflow-y: auto;
-        max-height: calc(100vh - 400px);
+        //max-height: calc(100vh - 490px);
+        max-height: calc(100vh - 550px);
     }
 
+ 
+
     .paginator-values::-webkit-scrollbar {
         width: 8px;
     }
@@ -34,7 +37,7 @@ export default css `
 
     .error {
         color: var(--error-color);
-    }
+    } 
     
     .no-values sl-icon {
         margin-bottom: 30px;

package/dist/components/problem-list/problem-mainview.js

@@ -101,13 +101,20 @@ let ProblemMainView = class ProblemMainView extends LitElement {
             (problem.sourceLocation != 'root.yaml' && problem.sourceLocation != 'root' && problem.sourceLocation != '/root.yaml')) {
             sourceLocation = html `<div class="source-location">Problem file:<br/> <strong>${problem.sourceLocation}</strong></div>`;
         }
+        let msg = '';
+        if (problem.message && problem.message.length > 0) {
+            msg = problem.message;
+        }
+        else {
+            msg = '[no message available]';
+        }
         return html `
             <div class="problem">
                 <div class="icon ${getProblemClass(problem)}">
                     <sl-icon name="${getProblemIcon(problem)}"></sl-icon>
                 </div>
                 <div class="message">
-                    ${unsafeHTML(marked.parse(problem.message).toString())}
+                    ${unsafeHTML(marked.parse(msg).toString())}
                     <div class="location">
                         Location: <pb33f-render-json-path path="${problem.jsonPath}"></pb33f-render-json-path>
                     </div>

package/dist/components/rodeo/npm/download-statistic.d.ts

@@ -0,0 +1,41 @@
+import { Colorful } from "../../charts/chart-colors.js";
+import { ChartResultData } from "../../../model/chart-data.js";
+import '../../charts/beefy-chart';
+import '../../charts/doughnut-chart.js';
+import { BeefyChart } from "../../charts/beefy-chart";
+interface StatisticSummary {
+    total: number;
+    peak: number;
+    peakDate: string;
+}
+export declare class RodeoDownloadStatistics extends Colorful {
+    vacuumStatistics: ChartResultData;
+    wiretapStatistics: ChartResultData;
+    openapiChangesStatistics: ChartResultData;
+    vacuumGithubTotal: ChartResultData;
+    changesGithubTotal: ChartResultData;
+    wiretapGithubTotal: ChartResultData;
+    vacuumClones: ChartResultData;
+    libopenapiClones: ChartResultData;
+    libopenapiValidatorClones: ChartResultData;
+    changesClones: ChartResultData;
+    wiretapClones: ChartResultData;
+    vacuumStars: ChartResultData;
+    libopenapiStars: ChartResultData;
+    libopenapiValidatorStars: ChartResultData;
+    wiretapStars: ChartResultData;
+    changesStars: ChartResultData;
+    doctorStars: ChartResultData;
+    saddlebagStars: ChartResultData;
+    vacuumDockerPulls: ChartResultData;
+    changesDockerPulls: ChartResultData;
+    wiretapDockerPulls: ChartResultData;
+    starHistory: ChartResultData;
+    charts: BeefyChart[];
+    constructor();
+    firstUpdated(): void;
+    calculateStatistics(stats: ChartResultData): StatisticSummary;
+    composeStarHistory(): number;
+    render(): import("lit-html").TemplateResult<1>;
+}
+export {};