@pb33f/cowboy-components 0.7.17 → 0.8.0

package/dist/treemap-KMMF4GRG-BvEKHn43.js

@@ -0,0 +1,5 @@
+import { T as a, h as m } from "./mermaid-parser.core-BPror82d.js";
+export {
+  a as TreemapModule,
+  m as createTreemapServices
+};

package/dist/utils/language-utils.d.ts

@@ -0,0 +1 @@
+export declare function getMonacoLanguageFromExtension(filePath: string): string;

package/dist/utils/language-utils.js

@@ -0,0 +1,23 @@
+import { NodeType } from "../model/node_type.js";
+export function getMonacoLanguageFromExtension(filePath) {
+    const ext = filePath?.split('.').pop();
+    if (!ext)
+        return 'yaml';
+    const extensionMap = {
+        [NodeType.JSON]: NodeType.JSON,
+        [NodeType.GO]: NodeType.GO,
+        [NodeType.PY]: 'python',
+        [NodeType.JS]: 'javascript',
+        [NodeType.TS]: 'typescript',
+        [NodeType.PHP]: NodeType.PHP,
+        [NodeType.XML]: NodeType.XML,
+        [NodeType.JAVA]: NodeType.JAVA,
+        [NodeType.RB]: 'ruby',
+        [NodeType.RS]: 'rust',
+        [NodeType.C]: NodeType.C,
+        [NodeType.CPP]: NodeType.CPP,
+        [NodeType.CS]: 'csharp',
+        [NodeType.MD]: 'markdown',
+    };
+    return extensionMap[ext] || 'yaml';
+}

package/dist/utils/lru-cache.d.ts

@@ -0,0 +1,11 @@
+export declare class LRUCache<K, V> {
+    private cache;
+    private maxSize;
+    constructor(maxSize?: number);
+    get(key: K): V | undefined;
+    set(key: K, value: V): void;
+    has(key: K): boolean;
+    clear(): void;
+    get size(): number;
+    delete(key: K): boolean;
+}

package/dist/utils/lru-cache.js

@@ -0,0 +1,38 @@
+// Copyright 2023-2025 Princess Beef Heavy Industries, LLC / Dave Shanley
+// https://pb33f.io
+export class LRUCache {
+    constructor(maxSize = 50) {
+        this.cache = new Map();
+        this.maxSize = maxSize;
+    }
+    get(key) {
+        if (!this.cache.has(key))
+            return undefined;
+        const value = this.cache.get(key);
+        this.cache.delete(key);
+        this.cache.set(key, value);
+        return value;
+    }
+    set(key, value) {
+        if (this.cache.has(key)) {
+            this.cache.delete(key);
+        }
+        else if (this.cache.size >= this.maxSize) {
+            const firstKey = this.cache.keys().next().value;
+            this.cache.delete(firstKey);
+        }
+        this.cache.set(key, value);
+    }
+    has(key) {
+        return this.cache.has(key);
+    }
+    clear() {
+        this.cache.clear();
+    }
+    get size() {
+        return this.cache.size;
+    }
+    delete(key) {
+        return this.cache.delete(key);
+    }
+}

package/dist/utils/node-helpers.d.ts

@@ -0,0 +1,6 @@
+import { Node } from "../model/graph.js";
+export declare function buildNodeMap(nodes: Node[] | undefined): Map<string, Node>;
+export declare function buildHashToNodeMap(nodeMap: Map<string, Node>): Map<string, Node>;
+export declare function findParentNode(node: Node, nodeMap: Map<string, Node>, hashToNode?: Map<string, Node>): Node | undefined;
+export declare function collectAncestors(node: Node, nodeMap: Map<string, Node>, hashToNode?: Map<string, Node>): Node[];
+export declare function resolveNodeIdFromHash(hash: string, nodeMap: Map<string, Node>, hashToNode?: Map<string, Node>): string | undefined;

package/dist/utils/node-helpers.js

@@ -0,0 +1,62 @@
+// Copyright 2023-2025 Princess Beef Heavy Industries, LLC / Dave Shanley
+// https://pb33f.io
+export function buildNodeMap(nodes) {
+    const nodeMap = new Map();
+    if (nodes) {
+        for (const node of nodes) {
+            nodeMap.set(node.id, node);
+        }
+    }
+    return nodeMap;
+}
+export function buildHashToNodeMap(nodeMap) {
+    const hashToNode = new Map();
+    for (const node of nodeMap.values()) {
+        if (node.idHash) {
+            hashToNode.set(node.idHash, node);
+        }
+    }
+    return hashToNode;
+}
+export function findParentNode(node, nodeMap, hashToNode) {
+    if (!node.parentId || node.parentId === 'root') {
+        return undefined;
+    }
+    let parent = nodeMap.get(node.parentId);
+    if (parent) {
+        return parent;
+    }
+    if (hashToNode) {
+        parent = hashToNode.get(node.parentId);
+        if (parent) {
+            return parent;
+        }
+    }
+    return undefined;
+}
+export function collectAncestors(node, nodeMap, hashToNode) {
+    const ancestors = [];
+    let current = node;
+    while (current && current.parentId && current.parentId !== 'root') {
+        const parent = findParentNode(current, nodeMap, hashToNode);
+        if (parent) {
+            ancestors.push(parent);
+            current = parent;
+        }
+        else {
+            break;
+        }
+    }
+    return ancestors;
+}
+export function resolveNodeIdFromHash(hash, nodeMap, hashToNode) {
+    if (nodeMap.has(hash)) {
+        return hash;
+    }
+    const hashMap = hashToNode ?? buildHashToNodeMap(nodeMap);
+    const node = hashMap.get(hash);
+    if (node) {
+        return node.id;
+    }
+    return undefined;
+}

package/dist/utils/path-utils.d.ts

@@ -0,0 +1,5 @@
+export declare class PathUtils {
+    static getShortPath(jsonPath: string, maxParts?: number): string;
+}
+export declare function normalizeRolodexPath(path: string | undefined | null): string;
+export declare function pathsMatch(a: string | undefined, b: string | undefined): boolean;

package/dist/utils/path-utils.js

@@ -0,0 +1,22 @@
+// Copyright 2023-2025 Princess Beef Heavy Industries, LLC / Dave Shanley
+// https://pb33f.io
+export class PathUtils {
+    static getShortPath(jsonPath, maxParts = 2) {
+        if (!jsonPath)
+            return 'unknown';
+        const parts = jsonPath.split('.');
+        if (parts.length <= maxParts)
+            return jsonPath;
+        return '...' + parts.slice(-maxParts).join('.');
+    }
+}
+export function normalizeRolodexPath(path) {
+    if (!path || path === '' || path === '/')
+        return 'root';
+    if (path === '/root.yaml' || path === 'root.yaml')
+        return 'root';
+    return path;
+}
+export function pathsMatch(a, b) {
+    return normalizeRolodexPath(a) === normalizeRolodexPath(b);
+}

package/dist/workers/elk-layout.worker.d.ts

@@ -0,0 +1,2 @@
+declare const _default: (this: Window, e: MessageEvent<any>) => Promise<void>;
+export default _default;

package/dist/workers/elk-layout.worker.js

@@ -0,0 +1,31 @@
+import ELK from 'elkjs/lib/elk-api.js';
+import ElkWorkerUrl from 'elkjs/lib/elk-worker.min.js?url';
+const elk = new ELK({
+    workerUrl: ElkWorkerUrl
+});
+export default onmessage = async function (e) {
+    const { graph, layoutOptions, requestId } = e.data;
+    if (!graph || !layoutOptions) {
+        postMessage({
+            success: false,
+            error: 'Missing graph or layoutOptions',
+            requestId
+        });
+        return;
+    }
+    try {
+        const result = await elk.layout(graph, {
+            layoutOptions: layoutOptions,
+            logging: false,
+            measureExecutionTime: false
+        });
+        postMessage({ success: true, graph: result, requestId });
+    }
+    catch (error) {
+        postMessage({
+            success: false,
+            error: error instanceof Error ? error.message : 'Unknown error',
+            requestId
+        });
+    }
+};

package/dist/workers/equalizer.worker.d.ts

@@ -1,4 +1,9 @@
 import { Edge, Node } from "../model/graph.js";
-export declare function checkEdge(edge: Edge, parentNode: Node, dependentNodes: Map<string, Node>, dependentEdges: Map<string, Edge>, extractedNodes: Map<string, Node>, extractedEdgeSources: Map<string, Edge[]>, extractedEdgeTargets: Map<string, Edge[]>, objects: string[]): void;
+export declare function processPovRequest(povNodeId: string, nodeMap: Map<string, Node>, edges: Edge[], includeAncestors?: boolean): {
+    nodes: Node[];
+    edges: Edge[];
+    povMode: true;
+    povNodeId: string;
+};
 declare const _default: (this: Window, e: MessageEvent<any>) => void;
 export default _default;

package/dist/workers/equalizer.worker.js

@@ -1,209 +1,158 @@
-import { NodeType } from "../model/node_type.js";
-export function checkEdge(edge, parentNode, dependentNodes, dependentEdges, extractedNodes, extractedEdgeSources, extractedEdgeTargets, objects) {
-    if (edge) {
-        if (edge.sources.length > 0) {
-            for (let i = 0; i < edge.sources.length; i++) {
-                const source = edge.sources[i];
-                // edge.sources.forEach(source => {
-                if (extractedNodes.has(source)) {
-                    const ext = extractedNodes.get(source);
-                    if (ext) {
-                        if (ext.filtered) {
-                            return;
-                        }
-                        delete (ext.x);
-                        delete (ext.y);
-                        if (!dependentNodes.has(ext.id)) {
-                            if (!Object.keys(objects).includes(ext.type)) {
-                                ext.dependency = true;
-                            }
-                            dependentNodes.set(ext.id, ext);
-                        }
-                        if (!ext.processed) {
-                            const extractedTargets = extractedEdgeTargets.get(ext.id);
-                            // look through extracted sources for this node and recurse
-                            if (extractedTargets) {
-                                extractedTargets.forEach(edge => {
-                                    delete (edge.container);
-                                    delete (edge.sections);
-                                    edge.dependency = true;
-                                    dependentEdges.set(edge.id, edge);
-                                    checkEdge(edge, ext, dependentNodes, dependentEdges, extractedNodes, extractedEdgeSources, extractedEdgeTargets, objects);
-                                });
-                            }
-                        }
-                        const extractedSources = extractedEdgeSources.get(ext.id);
-                        if (extractedSources) {
-                            extractedSources.forEach(edge => {
-                                if (edge.targets.includes(parentNode.id)) {
-                                    delete (edge.container);
-                                    delete (edge.sections);
-                                    //edge.dependency = true;
-                                    dependentEdges.set(edge.id, edge);
-                                    checkEdge(edge, ext, dependentNodes, dependentEdges, extractedNodes, extractedEdgeSources, extractedEdgeTargets, objects);
-                                }
-                            });
-                        }
-                        ext.processed = true;
-                    }
-                }
-            }
-        }
+export function processPovRequest(povNodeId, nodeMap, edges, includeAncestors = true) {
+    // Create maps for efficient lookups
+    const descendantNodes = new Map();
+    const ancestorNodes = new Map();
+    const relevantEdges = new Map();
+    // Get the POV node
+    const povNode = nodeMap.get(povNodeId);
+    if (!povNode) {
+        return { nodes: [], edges: [], povMode: true, povNodeId };
     }
-}
-export default onmessage = function (e) {
-    if (e.data.graphResponse && e.data.spacing) {
-        // loop through all the nodes in the graph response
-        // and find the nodes that are in the objects array
-        const objects = e.data.objects;
-        const references = e.data.references;
-        const graphResponse = e.data.graphResponse;
-        const filteredGraphResponse = {
-            nodes: [],
-            edges: [],
-            nodesRendered: graphResponse.nodesRendered,
-            spacing: e.data.spacing,
-            references: e.data.references,
-        };
-        const extractedNodes = new Map();
-        const extractedRenderedNodes = new Map();
-        const filteredNodes = new Map();
-        const extractedEdgeSources = new Map();
-        const extractedEdgeTargets = new Map();
-        const extractFilters = (filterKey, jsonBlob) => {
-            const filters = [];
-            for (const key in jsonBlob) {
-                if (key.includes(filterKey + '_filter_')) {
-                    const [, , value] = key.split('_');
-                    filters.push(value);
-                }
-            }
-            return filters;
-        };
-        // no work to do.
-        if (!objects) {
-            postMessage(filteredGraphResponse);
-            return;
-        }
-        graphResponse.nodes?.forEach(node => {
-            if (Object.keys(objects).includes(node.type)) {
-                filteredNodes.set(node.id, node);
+    // Add POV node as the center (not marked as dependency)
+    descendantNodes.set(povNodeId, { ...povNode });
+    // Build edge maps for traversal
+    const edgesBySource = new Map();
+    const edgesByTarget = new Map();
+    edges.forEach(edge => {
+        edge.sources.forEach(source => {
+            if (!edgesBySource.has(source)) {
+                edgesBySource.set(source, []);
             }
-            extractedNodes.set(node.id, node);
+            edgesBySource.get(source).push(edge);
         });
-        graphResponse.nodesRendered?.forEach(node => {
-            extractedRenderedNodes.set(node.id, node);
-        });
-        const filterResponseNode = (code, node, filters) => {
-            if (!filters.includes(code + 'XX')) {
-                node.filtered = true;
-                const ext = extractedNodes.get(node.id);
-                if (ext) {
-                    ext.filtered = true;
-                }
-            }
-        };
-        filteredNodes.forEach((node) => {
-            const filters = extractFilters(node.type, objects);
-            let knownResponseObjects = [];
-            let renderedNode;
-            if (filters.length > 0) {
-                switch (node.type) {
-                    case NodeType.RESPONSE:
-                        knownResponseObjects = ['1', '2', '3', '4', '5'];
-                        for (const knownResponseObject of knownResponseObjects) {
-                            if (node.label.startsWith(knownResponseObject)) {
-                                filterResponseNode(knownResponseObject, node, filters);
-                            }
-                        }
-                        break;
-                    case NodeType.PARAMETER:
-                        knownResponseObjects = ['cookie', 'header', 'path', 'query'];
-                        renderedNode = extractedRenderedNodes.get(node.id);
-                        if (renderedNode) {
-                            if (renderedNode?.instance?.hasOwnProperty('in')) {
-                                if (!filters.includes(renderedNode.instance.in)) {
-                                    filterResponseNode(renderedNode.instance.in, node, filters);
-                                }
-                            }
-                        }
-                        break;
-                    case NodeType.OPERATION:
-                        knownResponseObjects = ['get', 'post', 'put', 'patch', 'delete', 'head', 'options', 'trace'];
-                        if (!filters.includes(node.label.toLowerCase())) {
-                            filterResponseNode(node.label, node, filters);
-                        }
-                        break;
-                }
+        edge.targets.forEach(target => {
+            if (!edgesByTarget.has(target)) {
+                edgesByTarget.set(target, []);
             }
+            edgesByTarget.get(target).push(edge);
         });
-        graphResponse.edges?.forEach(edge => {
-            if (references && !references.renderRefs) {
-                if (edge.ref && edge.ref != '') {
-                    return;
-                }
-            }
-            if (references && !references.renderPoly) {
-                if (edge.ref && edge.ref != '' && edge.poly && edge.poly != '') {
-                    return;
-                }
-            }
-            edge.sources.forEach(source => {
-                if (!extractedEdgeSources.has(source)) {
-                    extractedEdgeSources.set(source, []);
-                }
-                delete (edge.container);
-                delete (edge.sections);
-                extractedEdgeSources.get(source)?.push(edge);
-            });
-            edge.targets.forEach(target => {
-                if (!extractedEdgeTargets.has(target)) {
-                    extractedEdgeTargets.set(target, []);
+    });
+    // Find all descendants from POV node using BFS
+    const descendantQueue = [povNodeId];
+    const visitedDescendants = new Set([povNodeId]);
+    while (descendantQueue.length > 0) {
+        const currentId = descendantQueue.shift();
+        const outgoingEdges = edgesBySource.get(currentId) || [];
+        outgoingEdges.forEach(edge => {
+            edge.targets.forEach(targetId => {
+                if (!visitedDescendants.has(targetId)) {
+                    visitedDescendants.add(targetId);
+                    descendantQueue.push(targetId);
+                    const targetNode = nodeMap.get(targetId);
+                    if (targetNode) {
+                        // Don't mark descendants as dependencies
+                        descendantNodes.set(targetId, { ...targetNode });
+                        relevantEdges.set(edge.id, edge);
+                    }
                 }
-                delete (edge.container);
-                delete (edge.sections);
-                extractedEdgeTargets.get(target)?.push(edge);
             });
         });
-        const dependentNodes = new Map();
-        const dependentEdges = new Map();
-        filteredNodes.forEach(node => {
-            if (Object.keys(objects).includes(node.type)) {
-                delete (node.x);
-                delete (node.y);
-                if (node.filtered) {
-                    return;
-                }
-                filteredGraphResponse.nodes.push(node);
-                const targetEdges = extractedEdgeTargets.get(node.id);
-                if (targetEdges) {
-                    targetEdges.forEach(edge => {
-                        checkEdge(edge, node, dependentNodes, dependentEdges, extractedNodes, extractedEdgeSources, extractedEdgeTargets, objects);
-                    });
+    }
+    // Only find ancestors if requested
+    if (includeAncestors) {
+        // Find path back to root using BFS (mark these as dependencies for dimming)
+        const ancestorQueue = [povNodeId];
+        const visitedAncestors = new Set([povNodeId]);
+        while (ancestorQueue.length > 0) {
+            const currentId = ancestorQueue.shift();
+            // Special case: if we've reached root, we're done
+            if (currentId === 'root') {
+                const rootNode = nodeMap.get('root');
+                if (rootNode && !descendantNodes.has('root')) {
+                    const dimmedRoot = { ...rootNode };
+                    dimmedRoot.dependency = true;
+                    ancestorNodes.set('root', dimmedRoot);
                 }
+                continue;
             }
-        });
-        dependentNodes.forEach(depNode => {
-            let found = false;
-            filteredGraphResponse.nodes.forEach(node => {
-                if (node.id == depNode.id) {
-                    found = true;
-                }
-            });
-            if (!found)
-                filteredGraphResponse.nodes.push(depNode);
-        });
-        dependentEdges.forEach(edge => {
-            let found = false;
-            filteredGraphResponse.edges.forEach(e => {
-                if (e.id == edge.id) {
-                    found = true;
-                }
+            const incomingEdges = edgesByTarget.get(currentId) || [];
+            incomingEdges.forEach(edge => {
+                edge.sources.forEach(sourceId => {
+                    if (!visitedAncestors.has(sourceId) && !visitedDescendants.has(sourceId)) {
+                        visitedAncestors.add(sourceId);
+                        ancestorQueue.push(sourceId);
+                        const sourceNode = nodeMap.get(sourceId);
+                        if (sourceNode) {
+                            // Mark ancestors as dependencies (will be dimmed)
+                            const dimmedNode = { ...sourceNode };
+                            dimmedNode.dependency = true;
+                            ancestorNodes.set(sourceId, dimmedNode);
+                            relevantEdges.set(edge.id, edge);
+                        }
+                    }
+                });
             });
-            if (!found)
-                filteredGraphResponse.edges.push(edge);
+        }
+    }
+    // Combine all nodes
+    const finalNodes = [];
+    // Add descendants (not dimmed)
+    descendantNodes.forEach(node => {
+        delete node.x;
+        delete node.y;
+        finalNodes.push(node);
+    });
+    // Add ancestors (dimmed)
+    ancestorNodes.forEach(node => {
+        delete node.x;
+        delete node.y;
+        finalNodes.push(node);
+    });
+    // Build final node set
+    const nodeIds = new Set([...descendantNodes.keys(), ...ancestorNodes.keys()]);
+    const finalEdges = [];
+    const addedEdgeIds = new Set();
+    // Include ALL edges that connect nodes in our final set
+    // This ensures reference edges are included even if found through different traversal paths
+    edges.forEach(edge => {
+        // Check if all sources and targets are in our node set
+        const hasAllSources = edge.sources.every(s => nodeIds.has(s));
+        const hasAllTargets = edge.targets.every(t => nodeIds.has(t));
+        if (hasAllSources && hasAllTargets && !addedEdgeIds.has(edge.id)) {
+            addedEdgeIds.add(edge.id);
+            // Clean edge for transmission
+            const cleanEdge = { ...edge };
+            delete cleanEdge.container;
+            delete cleanEdge.sections;
+            // Mark edges to ancestors as dependencies too
+            const isAncestorEdge = edge.sources.some(s => ancestorNodes.has(s)) ||
+                edge.targets.some(t => ancestorNodes.has(t));
+            if (isAncestorEdge && !edge.targets.some(t => descendantNodes.has(t))) {
+                cleanEdge.dependency = true;
+            }
+            finalEdges.push(cleanEdge);
+        }
+    });
+    return {
+        nodes: finalNodes,
+        edges: finalEdges,
+        povMode: true,
+        povNodeId
+    };
+}
+export default onmessage = function (e) {
+    // Handle POV mode request - UNCHANGED
+    if (e.data.povRequest) {
+        const nodeMap = new Map();
+        const nodes = e.data.nodeMap;
+        const edges = e.data.edges;
+        const includeAncestors = e.data.includeAncestors !== false; // Default to true
+        // Build nodeMap from array
+        nodes.forEach(node => {
+            nodeMap.set(node.id, node);
         });
-        filteredGraphResponse.rebuild = e.data.rebuild;
-        postMessage(filteredGraphResponse);
+        const povResult = processPovRequest(e.data.povNodeId, nodeMap, edges, includeAncestors);
+        postMessage(povResult);
+        return;
+    }
+    // Visual config only - pass through graph with spacing config (no filtering)
+    if (e.data.graphResponse && e.data.spacing) {
+        const response = {
+            nodes: e.data.graphResponse.nodes || [],
+            edges: e.data.graphResponse.edges || [],
+            spacing: e.data.spacing,
+            rebuild: e.data.rebuild
+        };
+        postMessage(response);
     }
 };

package/dist/workers/graph-dependent.worker.js

@@ -1,10 +1,10 @@
 function visitDependents(node, filteredNodes, filteredEdges, nodeMap, edgeMap, edgeTargets) {
-    if (node.nodes) {
-        for (const n of node.nodes) {
-            if (!filteredNodes.has(n.id)) {
-                filteredNodes.set(n.id, n);
+    if (node && node.nodes) {
+        for (const id of node.nodes) {
+            if (!filteredNodes.has(id)) {
+                filteredNodes.set(id, nodeMap.get(id));
                 // extract all the edge targets for this node
-                const targets = edgeTargets.get(n.id);
+                const targets = edgeTargets.get(id);
                 if (targets) {
                     targets.forEach(target => {
                         if (!filteredEdges.has(target.id)) {
@@ -12,7 +12,7 @@ function visitDependents(node, filteredNodes, filteredEdges, nodeMap, edgeMap, e
                         }
                     });
                 }
-                visitDependents(n, filteredNodes, filteredEdges, nodeMap, edgeMap, edgeTargets);
+                visitDependents(nodeMap.get(id), filteredNodes, filteredEdges, nodeMap, edgeMap, edgeTargets);
             }
         }
     }