@flow-scanner/lightning-flow-scanner-core 6.10.6 → 6.11.1

package/main/libs/ExportDiagram.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "exportDiagram", {
+    enumerable: true,
+    get: function() {
+        return exportDiagram;
+    }
+});
+function exportDiagram(parsedFlows, options = {
+    includeDetails: true,
+    includeMarkdownDocs: true,
+    collapsedDetails: true
+}) {
+    const validFlows = parsedFlows.filter((p)=>p.flow).map((p)=>p.flow);
+    let markdown = "# Flow Documentation\n\n";
+    if (validFlows.length === 0) {
+        markdown += "No valid flows found.\n\n";
+    }
+    for (const flow of validFlows){
+        markdown += `## ${flow.name}\n\n`;
+        const vizOptions = {
+            includeDetails: options.includeDetails,
+            includeMarkdownDocs: options.includeMarkdownDocs,
+            collapsedDetails: options.collapsedDetails
+        };
+        markdown += flow.visualize("mermaid", vizOptions) + "\n\n";
+    }
+    // Optionally add errors section if any
+    const errors = parsedFlows.filter((p)=>p.errorMessage);
+    if (errors.length > 0) {
+        markdown += "## Parse Errors\n\n";
+        for (const err of errors){
+            markdown += `- ${err.uri}: ${err.errorMessage}\n`;
+        }
+        markdown += "\n";
+    }
+    return markdown;
+}

package/main/models/Flow.d.ts

@@ -1,5 +1,6 @@
 import { FlowElement } from "./FlowElement";
 import { FlowNode } from "./FlowNode";
+import { FlowGraph } from "./FlowGraph";
 export declare class Flow {
     /**
      * Metadata Tags of Salesforce Flow Attributes
@@ -42,11 +43,18 @@ export declare class Flow {
      * Access start element data via startNode.element
      */
     startNode?: FlowNode;
+    private _graph?;
+    get graph(): FlowGraph;
     root?: any;
     xmldata: any;
     constructor(path?: string, data?: unknown);
     static from(obj: Partial<Flow>): Flow;
     preProcessNodes(): void;
+    visualize(format?: 'mermaid' | 'plantuml', options?: {
+        includeDetails?: boolean;
+        includeMarkdownDocs?: boolean;
+        collapsedDetails?: boolean;
+    }): string;
     private processNodeType;
     /**
      * Find the name of the first element to execute.

package/main/models/Flow.js

@@ -14,6 +14,7 @@ const _FlowMetadata = require("./FlowMetadata");
 const _FlowNode = require("./FlowNode");
 const _FlowResource = require("./FlowResource");
 const _FlowVariable = require("./FlowVariable");
+const _FlowGraph = require("./FlowGraph");
 function _define_property(obj, key, value) {
     if (key in obj) {
         Object.defineProperty(obj, key, {
@@ -83,7 +84,39 @@ function _object_spread(target) {
     }
     return target;
 }
+function ownKeys(object, enumerableOnly) {
+    var keys = Object.keys(object);
+    if (Object.getOwnPropertySymbols) {
+        var symbols = Object.getOwnPropertySymbols(object);
+        if (enumerableOnly) {
+            symbols = symbols.filter(function(sym) {
+                return Object.getOwnPropertyDescriptor(object, sym).enumerable;
+            });
+        }
+        keys.push.apply(keys, symbols);
+    }
+    return keys;
+}
+function _object_spread_props(target, source) {
+    source = source != null ? source : {};
+    if (Object.getOwnPropertyDescriptors) {
+        Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
+    } else {
+        ownKeys(Object(source)).forEach(function(key) {
+            Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
+        });
+    }
+    return target;
+}
 let Flow = class Flow {
+    get graph() {
+        if (!this._graph) {
+            const flowNodes = this.elements.filter((e)=>e instanceof _FlowNode.FlowNode);
+            this.startReference || (this.startReference = this.findStart());
+            this._graph = new _FlowGraph.FlowGraph(flowNodes, this.startReference, this.startNode);
+        }
+        return this._graph;
+    }
     static from(obj) {
         if (obj instanceof Flow) {
             return obj;
@@ -115,14 +148,14 @@ let Flow = class Flow {
                 continue;
             }
             const data = this.xmldata[nodeType];
-            // Handle start nodes separately - store in startNode, don't add to elements
+            // Handle start nodes separately - store in startNode property
             if (nodeType === "start") {
                 if (Array.isArray(data) && data.length > 0) {
                     this.startNode = new _FlowNode.FlowNode(data[0].name || "start", "start", data[0]);
                 } else if (!Array.isArray(data)) {
                     this.startNode = new _FlowNode.FlowNode(data.name || "start", "start", data);
                 }
-                continue; // Don't add to elements array
+                continue;
             }
             // Process other node types
             if (Flow.ATTRIBUTE_TAGS.includes(nodeType)) {
@@ -137,6 +170,27 @@ let Flow = class Flow {
         }
         this.elements = allNodes;
         this.startReference = this.findStart();
+        // Build the connectivity graph
+        const flowNodes = allNodes.filter((e)=>e instanceof _FlowNode.FlowNode);
+        this._graph = new _FlowGraph.FlowGraph(flowNodes, this.startReference, this.startNode);
+    }
+    visualize(format = 'mermaid', options = {}) {
+        if (format === 'mermaid') {
+            var _this_xmldata, _this_startNode_element, _this_startNode, _this_startNode_element1, _this_startNode1;
+            return this.graph.toMermaid(_object_spread_props(_object_spread({}, options), {
+                flowMetadata: {
+                    label: this.label,
+                    processType: this.processType,
+                    status: this.status,
+                    description: (_this_xmldata = this.xmldata) === null || _this_xmldata === void 0 ? void 0 : _this_xmldata.description,
+                    triggerType: (_this_startNode = this.startNode) === null || _this_startNode === void 0 ? void 0 : (_this_startNode_element = _this_startNode.element) === null || _this_startNode_element === void 0 ? void 0 : _this_startNode_element['triggerType'],
+                    object: (_this_startNode1 = this.startNode) === null || _this_startNode1 === void 0 ? void 0 : (_this_startNode_element1 = _this_startNode1.element) === null || _this_startNode_element1 === void 0 ? void 0 : _this_startNode_element1['object']
+                }
+            }));
+        } else if (format === 'plantuml') {
+            return this.graph.toPlantUML();
+        }
+        throw new Error('Unsupported format');
     }
     processNodeType(data, nodeType, allNodes, NodeClass) {
         if (Array.isArray(data)) {
@@ -248,6 +302,7 @@ let Flow = class Flow {
    * Contains trigger information and connectors.
    * Access start element data via startNode.element
    */ _define_property(this, "startNode", void 0);
+        _define_property(this, "_graph", void 0);
         // Legacy/internal
         _define_property(this, "root", void 0);
         _define_property(this, "xmldata", void 0);

package/main/models/FlowGraph.d.ts

@@ -0,0 +1,85 @@
+import { FlowNode } from "./FlowNode";
+/**
+ * FlowGraph: Pre-computed connectivity cache built using Compiler.
+ * Built once during Flow.preProcessNodes() to avoid repeated traversals.
+ *
+ * Uses the existing Compiler to build the graph - no duplicate logic!
+ */
+export declare class FlowGraph {
+    private nodeMap;
+    private reachableFromStart;
+    private elementsInLoop;
+    private faultConnectors;
+    private normalConnectors;
+    private allConnectors;
+    private reverseConnectors;
+    constructor(nodes: FlowNode[], startReference?: string, startNode?: FlowNode);
+    /**
+     * Add START node connectors to the connector maps (for flows with explicit <start> element)
+     */
+    private addStartNodeConnectors;
+    /**
+     * Add START edge for newer flows that use startElementReference (no explicit <start> node)
+     */
+    private addStartEdgeFromReference;
+    /**
+     * Build node map for O(1) lookups
+     */
+    private buildNodeMaps;
+    /**
+     * Build connector maps by inspecting node connectors
+     */
+    private buildConnectorMaps;
+    /**
+     * Use Compiler to compute which elements are reachable from start.
+     * This reuses the existing IDDFS traversal logic!
+     */
+    private computeReachability;
+    /**
+     * Use Compiler to compute which elements are inside loops.
+     * Calls Compiler.traverseFlow() for each loop with endElementName.
+     */
+    private computeLoopBoundaries;
+    isReachable(elementName: string): boolean;
+    getReachableElements(): Set<string>;
+    isInLoop(elementName: string): boolean;
+    getContainingLoop(elementName: string): string | undefined;
+    getLoopElements(loopName: string): Set<string>;
+    hasFaultConnector(elementName: string): boolean;
+    getFaultTargets(elementName: string): string[];
+    getNextElements(elementName: string): string[];
+    getAllNextElements(elementName: string): string[];
+    getPreviousElements(elementName: string): string[];
+    getNode(elementName: string): FlowNode | undefined;
+    isPartOfFaultHandling(elementName: string): boolean;
+    getLoopNodes(): FlowNode[];
+    forEachReachable(callback: (node: FlowNode) => void): void;
+    /**
+     * Export the graph to Mermaid flowchart syntax with rich documentation.
+     */
+    toMermaid(options?: {
+        includeDetails?: boolean;
+        includeMarkdownDocs?: boolean;
+        collapsedDetails?: boolean;
+        flowMetadata?: any;
+    }): string;
+    private generateMermaidDiagram;
+    private generateStartNode;
+    private getNodeShape;
+    private generateEdges;
+    private findEndNodes;
+    private generateLoopSubgraphs;
+    private generateMermaidStyles;
+    private generateNodeDetailsMarkdown;
+    private nodeToMarkdownTable;
+    private prettifyValue;
+    /**
+     * Generate full markdown documentation with diagram and node details
+     */
+    private generateFullMarkdownDoc;
+    /**
+     * Export the graph to PlantUML syntax for UML-style diagrams.
+     * @returns PlantUML string.
+     */
+    toPlantUML(): string;
+}