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

package/main/models/FlowNode.js

@@ -11,6 +11,7 @@ Object.defineProperty(exports, "FlowNode", {
 const _MetadataTypes = require("../enums/MetadataTypes");
 const _FlowElement = require("./FlowElement");
 const _FlowElementConnector = require("./FlowElementConnector");
+const _NodeIcons = require("../config/NodeIcons");
 function _define_property(obj, key, value) {
     if (key in obj) {
         Object.defineProperty(obj, key, {
@@ -25,6 +26,146 @@ function _define_property(obj, key, value) {
     return obj;
 }
 let FlowNode = class FlowNode extends _FlowElement.FlowElement {
+    /**
+   * Set custom icon configuration for all FlowNodes
+   * @example
+   * ```typescript
+   * // Use ASCII icons for old terminals
+   * FlowNode.setIconConfig(ASCII_ICONS);
+   * 
+   * // Or provide custom icons
+   * FlowNode.setIconConfig({
+   *   actionCalls: { default: '[ACTION]' },
+   *   decisions: { default: '[IF]' }
+   * });
+   * ```
+   */ static setIconConfig(config) {
+        FlowNode.iconConfig = config;
+    }
+    /**
+   * Use ASCII icons instead of emoji (for older browsers/terminals)
+   */ static useAsciiIcons() {
+        FlowNode.iconConfig = _NodeIcons.ASCII_ICONS;
+    }
+    /**
+   * Reset to default emoji icons
+   */ static useDefaultIcons() {
+        FlowNode.iconConfig = _NodeIcons.DEFAULT_ICONS;
+    }
+    extractTypeSpecificProperties(subtype, element) {
+        switch(subtype){
+            case "actionCalls":
+                this.actionType = element.actionType;
+                this.actionName = element.actionName;
+                break;
+            case "recordCreates":
+            case "recordUpdates":
+            case "recordDeletes":
+            case "recordLookups":
+                this.object = element.object;
+                this.inputReference = element.inputReference;
+                this.outputReference = element.outputReference;
+                break;
+            case "collectionProcessors":
+                this.elementSubtype = element.elementSubtype;
+                this.collectionReference = element.collectionReference;
+                break;
+            case "subflows":
+                this.flowName = element.flowName;
+                break;
+            case "decisions":
+                this.rules = Array.isArray(element.rules) ? element.rules : element.rules ? [
+                    element.rules
+                ] : [];
+                this.defaultConnectorLabel = element.defaultConnectorLabel;
+                break;
+            case "loops":
+                this.collectionReference = element.collectionReference;
+                this.iterationOrder = element.iterationOrder;
+                break;
+            case "screens":
+                this.fields = Array.isArray(element.fields) ? element.fields : element.fields ? [
+                    element.fields
+                ] : [];
+                this.allowPause = element.allowPause;
+                this.showFooter = element.showFooter;
+                break;
+        }
+    }
+    /**
+   * Get a human-readable summary of this node
+   */ getSummary() {
+        const parts = [];
+        switch(this.subtype){
+            case "actionCalls":
+                if (this.actionType) parts.push(this.prettifyValue(this.actionType));
+                if (this.actionName) parts.push(this.actionName);
+                break;
+            case "recordCreates":
+            case "recordUpdates":
+            case "recordDeletes":
+            case "recordLookups":
+                if (this.object) parts.push(this.object);
+                break;
+            case "collectionProcessors":
+                if (this.elementSubtype) parts.push(this.prettifyValue(this.elementSubtype));
+                break;
+            case "decisions":
+                var _this_rules, _this_rules1;
+                parts.push(`${((_this_rules = this.rules) === null || _this_rules === void 0 ? void 0 : _this_rules.length) || 0} rule${((_this_rules1 = this.rules) === null || _this_rules1 === void 0 ? void 0 : _this_rules1.length) !== 1 ? 's' : ''}`);
+                break;
+            case "loops":
+                if (this.collectionReference) parts.push(`Loop: ${this.collectionReference}`);
+                break;
+            case "subflows":
+                if (this.flowName) parts.push(this.flowName);
+                break;
+        }
+        if (this.description) {
+            parts.push(this.description.substring(0, 50) + (this.description.length > 50 ? '...' : ''));
+        }
+        return parts.join(' • ');
+    }
+    /**
+   * Get the icon for this node type
+   */ getIcon() {
+        const typeIcons = FlowNode.iconConfig[this.subtype];
+        if (!typeIcons) {
+            // Fallback for unknown types
+            const fallback = FlowNode.iconConfig['default'];
+            return fallback && 'default' in fallback ? fallback.default : '\u2022'; // • BULLET
+        }
+        // For nodes with subtypes (like actionCalls or collectionProcessors)
+        const subtype = this.actionType || this.elementSubtype;
+        const icons = typeIcons;
+        if (subtype && icons[subtype]) {
+            return icons[subtype];
+        }
+        return icons.default || '\u2022'; // • BULLET fallback
+    }
+    /**
+   * Get the display name for this node type
+   */ getTypeLabel() {
+        const labelMap = {
+            actionCalls: 'Action',
+            assignments: 'Assignment',
+            collectionProcessors: 'Collection',
+            customErrors: 'Error',
+            decisions: 'Decision',
+            loops: 'Loop',
+            recordCreates: 'Create',
+            recordDeletes: 'Delete',
+            recordLookups: 'Get Records',
+            recordUpdates: 'Update',
+            screens: 'Screen',
+            subflows: 'Subflow',
+            transforms: 'Transform'
+        };
+        return labelMap[this.subtype] || this.subtype;
+    }
+    prettifyValue(value) {
+        return value.replace(/([A-Z])/g, ' $1').replace(/^./, (str)=>str.toUpperCase()).trim();
+    }
     getConnectors(subtype, element) {
         const connectors = [];
         if (subtype === "start") {
@@ -160,10 +301,27 @@ let FlowNode = class FlowNode extends _FlowElement.FlowElement {
     }
     constructor(provName, subtype, element){
         const nodeName = subtype === "start" ? "flowstart" : provName;
-        super(_MetadataTypes.MetaType.NODE, subtype, nodeName, element), _define_property(this, "connectors", []), _define_property(this, "locationX", void 0), _define_property(this, "locationY", void 0);
-        const connectors = this.getConnectors(subtype, element);
-        this.connectors = connectors;
+        super(_MetadataTypes.MetaType.NODE, subtype, nodeName, element), _define_property(this, "connectors", []), _define_property(this, "locationX", void 0), _define_property(this, "locationY", void 0), // Common properties across node types
+        _define_property(this, "label", void 0), _define_property(this, "description", void 0), // Action-specific properties
+        _define_property(this, "actionType", void 0), _define_property(this, "actionName", void 0), // Record operation properties
+        _define_property(this, "object", void 0), _define_property(this, "inputReference", void 0), _define_property(this, "outputReference", void 0), // Collection processor properties
+        _define_property(this, "elementSubtype", void 0), _define_property(this, "collectionReference", void 0), // Subflow properties
+        _define_property(this, "flowName", void 0), // Decision properties
+        _define_property(this, "rules", void 0), _define_property(this, "defaultConnectorLabel", void 0), // Loop properties
+        _define_property(this, "iterationOrder", void 0), // Screen properties
+        _define_property(this, "fields", void 0), _define_property(this, "allowPause", void 0), _define_property(this, "showFooter", void 0), // Fault handling
+        _define_property(this, "faultConnector", void 0);
+        // Extract common properties
+        this.label = element["label"];
+        this.description = element["description"];
         this.locationX = element["locationX"];
         this.locationY = element["locationY"];
+        // Extract type-specific properties
+        this.extractTypeSpecificProperties(subtype, element);
+        // Extract connectors
+        this.connectors = this.getConnectors(subtype, element);
+        this.faultConnector = this.connectors.find((c)=>c.type === "faultConnector");
     }
 };
+// Static icon configuration (can be overridden)
+_define_property(FlowNode, "iconConfig", _NodeIcons.DEFAULT_ICONS);

package/main/models/FlowVariable.d.ts

@@ -1,5 +1,63 @@
 import { FlowElement } from "./FlowElement";
+import { type VariableIconConfig } from "../config/VariableIcons";
 export declare class FlowVariable extends FlowElement {
-    dataType: string;
+    dataType?: string;
+    isCollection?: boolean;
+    isInput?: boolean;
+    isOutput?: boolean;
+    objectType?: string;
+    description?: string;
+    value?: any;
+    private static iconConfig;
+    /**
+     * Set custom icon configuration for all FlowVariables
+     * @example
+     * ```typescript
+     * // Use ASCII icons
+     * FlowVariable.setIconConfig(ASCII_VARIABLE_ICONS);
+     *
+     * // Or provide custom icons
+     * FlowVariable.setIconConfig({
+     *   subtypes: {
+     *     variables: '[VAR]',
+     *     constants: '[CONST]'
+     *   },
+     *   boolean: {
+     *     true: '[YES]',
+     *     false: '[NO]'
+     *   }
+     * });
+     * ```
+     */
+    static setIconConfig(config: VariableIconConfig): void;
+    /**
+     * Use ASCII icons instead of emoji
+     */
+    static useAsciiIcons(): void;
+    /**
+     * Reset to default emoji icons
+     */
+    static useDefaultIcons(): void;
     constructor(name: string, subtype: string, element: object);
+    /**
+     * Get the icon for this variable subtype
+     */
+    getIcon(): string;
+    /**
+     * Get icon for a boolean value
+     */
+    private getBooleanIcon;
+    /**
+     * Get a human-readable type label
+     */
+    getTypeLabel(): string;
+    /**
+     * Get a markdown table row for this variable
+     */
+    toTableRow(): string;
+    /**
+     * Get a detailed markdown table for this variable
+     */
+    toMarkdownTable(): string;
+    private formatValue;
 }

package/main/models/FlowVariable.js

@@ -10,6 +10,7 @@ Object.defineProperty(exports, "FlowVariable", {
 });
 const _MetadataTypes = require("../enums/MetadataTypes");
 const _FlowElement = require("./FlowElement");
+const _VariableIcons = require("../config/VariableIcons");
 function _define_property(obj, key, value) {
     if (key in obj) {
         Object.defineProperty(obj, key, {
@@ -24,8 +25,124 @@ function _define_property(obj, key, value) {
     return obj;
 }
 let FlowVariable = class FlowVariable extends _FlowElement.FlowElement {
+    /**
+   * Set custom icon configuration for all FlowVariables
+   * @example
+   * ```typescript
+   * // Use ASCII icons
+   * FlowVariable.setIconConfig(ASCII_VARIABLE_ICONS);
+   * 
+   * // Or provide custom icons
+   * FlowVariable.setIconConfig({
+   *   subtypes: {
+   *     variables: '[VAR]',
+   *     constants: '[CONST]'
+   *   },
+   *   boolean: {
+   *     true: '[YES]',
+   *     false: '[NO]'
+   *   }
+   * });
+   * ```
+   */ static setIconConfig(config) {
+        FlowVariable.iconConfig = config;
+    }
+    /**
+   * Use ASCII icons instead of emoji
+   */ static useAsciiIcons() {
+        FlowVariable.iconConfig = _VariableIcons.ASCII_VARIABLE_ICONS;
+    }
+    /**
+   * Reset to default emoji icons
+   */ static useDefaultIcons() {
+        FlowVariable.iconConfig = _VariableIcons.DEFAULT_VARIABLE_ICONS;
+    }
+    /**
+   * Get the icon for this variable subtype
+   */ getIcon() {
+        return FlowVariable.iconConfig.subtypes[this.subtype] || '\uD83D\uDCCA'; // 📊 default
+    }
+    /**
+   * Get icon for a boolean value
+   */ getBooleanIcon(value) {
+        if (value === true) {
+            return FlowVariable.iconConfig.boolean.true;
+        } else if (value === false) {
+            return FlowVariable.iconConfig.boolean.false;
+        }
+        return ''; // undefined/null
+    }
+    /**
+   * Get a human-readable type label
+   */ getTypeLabel() {
+        const labelMap = {
+            variables: 'Variable',
+            constants: 'Constant',
+            formulas: 'Formula',
+            choices: 'Choice',
+            dynamicChoiceSets: 'Dynamic Choice'
+        };
+        return labelMap[this.subtype] || this.subtype;
+    }
+    /**
+   * Get a markdown table row for this variable
+   */ toTableRow() {
+        const parts = [
+            this.name,
+            this.dataType || '',
+            this.getBooleanIcon(this.isCollection),
+            this.getBooleanIcon(this.isInput),
+            this.getBooleanIcon(this.isOutput),
+            this.objectType || '',
+            this.description || ''
+        ];
+        return `| ${parts.join(' | ')} |`;
+    }
+    /**
+   * Get a detailed markdown table for this variable
+   */ toMarkdownTable() {
+        let table = '| Property | Value |\n|:---|:---|\n';
+        table += `| Name | ${this.name} |\n`;
+        table += `| Type | ${this.getIcon()} ${this.getTypeLabel()} |\n`;
+        if (this.dataType) table += `| Data Type | ${this.dataType} |\n`;
+        if (this.objectType) table += `| Object Type | ${this.objectType} |\n`;
+        if (this.isCollection !== undefined) {
+            table += `| Collection | ${this.getBooleanIcon(this.isCollection)} |\n`;
+        }
+        if (this.isInput !== undefined) {
+            table += `| Input | ${this.getBooleanIcon(this.isInput)} |\n`;
+        }
+        if (this.isOutput !== undefined) {
+            table += `| Output | ${this.getBooleanIcon(this.isOutput)} |\n`;
+        }
+        if (this.value !== undefined) {
+            table += `| Value | ${this.formatValue(this.value)} |\n`;
+        }
+        if (this.description) table += `| Description | ${this.description} |\n`;
+        return table;
+    }
+    formatValue(value) {
+        if (typeof value === 'object') {
+            return JSON.stringify(value, null, 2);
+        }
+        return String(value);
+    }
     constructor(name, subtype, element){
-        super(_MetadataTypes.MetaType.VARIABLE, subtype, name, element), _define_property(this, "dataType", void 0);
+        super(_MetadataTypes.MetaType.VARIABLE, subtype, name, element), _define_property(this, "dataType", void 0), _define_property(this, "isCollection", void 0), _define_property(this, "isInput", void 0), _define_property(this, "isOutput", void 0), _define_property(this, "objectType", void 0), _define_property(this, "description", void 0), _define_property(this, "value", void 0);
+        // Extract properties based on variable subtype
         this.dataType = element["dataType"];
+        this.isCollection = element["isCollection"];
+        this.isInput = element["isInput"];
+        this.isOutput = element["isOutput"];
+        this.objectType = element["objectType"];
+        this.description = element["description"];
+        // Different subtypes have different value properties
+        if (subtype === "constants") {
+            this.value = element["value"];
+        } else if (subtype === "formulas") {
+            this.value = element["expression"];
+        }
     }
 };
+// Static icon configuration (can be overridden)
+_define_property(FlowVariable, "iconConfig", _VariableIcons.DEFAULT_VARIABLE_ICONS);

package/main/models/LoopRuleCommon.js

@@ -12,7 +12,7 @@ const _internals = require("../internals/internals");
 const _RuleCommon = require("./RuleCommon");
 let LoopRuleCommon = class LoopRuleCommon extends _RuleCommon.RuleCommon {
     check(flow, _options, suppressions) {
-        const loopElements = this.findLoopElements(flow);
+        const loopElements = flow.graph.getLoopNodes();
         if (!loopElements.length) {
             return [];
         }
@@ -21,25 +21,24 @@ let LoopRuleCommon = class LoopRuleCommon extends _RuleCommon.RuleCommon {
         return results;
     }
     findLoopElements(flow) {
-        var _flow_elements;
-        return ((_flow_elements = flow.elements) === null || _flow_elements === void 0 ? void 0 : _flow_elements.filter((node)=>node.subtype === "loops")) || [];
+        return flow.graph.getLoopNodes();
     }
     findLoopEnd(element) {
-        var _element_element_noMoreValuesConnector;
+        var _element_element_noMoreValuesConnector, _element_element;
         var _element_element_noMoreValuesConnector_targetReference;
-        return (_element_element_noMoreValuesConnector_targetReference = (_element_element_noMoreValuesConnector = element.element["noMoreValuesConnector"]) === null || _element_element_noMoreValuesConnector === void 0 ? void 0 : _element_element_noMoreValuesConnector.targetReference) !== null && _element_element_noMoreValuesConnector_targetReference !== void 0 ? _element_element_noMoreValuesConnector_targetReference : element.name;
+        return (_element_element_noMoreValuesConnector_targetReference = (_element_element = element.element) === null || _element_element === void 0 ? void 0 : (_element_element_noMoreValuesConnector = _element_element.noMoreValuesConnector) === null || _element_element_noMoreValuesConnector === void 0 ? void 0 : _element_element_noMoreValuesConnector.targetReference) !== null && _element_element_noMoreValuesConnector_targetReference !== void 0 ? _element_element_noMoreValuesConnector_targetReference : element.name;
     }
     findStatementsInLoops(flow, loopElements) {
         const statementsInLoops = [];
         const statementTypes = this.getStatementTypes();
-        const findStatement = (element)=>{
-            if (statementTypes.includes(element.subtype)) {
-                statementsInLoops.push(element);
-            }
-        };
         for (const element of loopElements){
-            const loopEnd = this.findLoopEnd(element);
-            new _internals.Compiler().traverseFlow(flow, element.name, findStatement, loopEnd);
+            const loopElems = flow.graph.getLoopElements(element.name);
+            for (const elemName of loopElems){
+                const node = flow.graph.getNode(elemName);
+                if (node && statementTypes.includes(node.subtype)) {
+                    statementsInLoops.push(node);
+                }
+            }
         }
         return statementsInLoops;
     }

package/main/rules/DuplicateDMLOperation.d.ts

@@ -4,5 +4,5 @@ import { IRuleDefinition } from "../interfaces/IRuleDefinition";
 export declare class DuplicateDMLOperation extends RuleCommon implements IRuleDefinition {
     constructor();
     protected check(flow: core.Flow, _options: object | undefined, suppressions: Set<string>): core.Violation[];
-    private flagDML;
+    private isDML;
 }

package/main/rules/DuplicateDMLOperation.js

@@ -53,81 +53,50 @@ function _interop_require_wildcard(obj, nodeInterop) {
 }
 let DuplicateDMLOperation = class DuplicateDMLOperation extends _RuleCommon.RuleCommon {
     check(flow, _options, suppressions) {
-        const flowElements = flow.elements.filter((node)=>node instanceof _internals.FlowNode);
-        // Use the helper to find the starting element index
-        const startingNode = this.findStartIndex(flow, flowElements);
-        if (startingNode === -1) {
-            return [];
-        }
-        const processedElementIndexes = [];
-        const unconnectedElementIndexes = [];
-        const DuplicateDMLOperations = [];
-        let dmlFlag = false;
-        let indexesToProcess = [
-            startingNode
-        ];
-        do {
-            indexesToProcess = indexesToProcess.filter((index)=>!processedElementIndexes.includes(index));
-            if (indexesToProcess.length > 0) {
-                for (const [index, element] of flowElements.entries()){
-                    if (indexesToProcess.includes(index)) {
-                        const references = [];
-                        if (element.connectors && element.connectors.length > 0) {
-                            for (const connector of element.connectors){
-                                if (connector.reference) {
-                                    references.push(connector.reference);
-                                }
-                            }
-                        }
-                        dmlFlag = this.flagDML(element, dmlFlag);
-                        if (references.length > 0) {
-                            const elementsByReferences = flowElements.filter((el)=>references.includes(el.name));
-                            for (const nextElement of elementsByReferences){
-                                const nextIndex = flowElements.findIndex((el)=>nextElement.name === el.name);
-                                if (nextElement.subtype === "screens") {
-                                    if (dmlFlag && nextElement.element["allowBack"] === "true" && nextElement.element["showFooter"] === "true") {
-                                        if (!suppressions.has(nextElement.name)) {
-                                            DuplicateDMLOperations.push(nextElement);
-                                        }
-                                    }
-                                }
-                                if (!processedElementIndexes.includes(nextIndex)) {
-                                    indexesToProcess.push(nextIndex);
-                                }
-                            }
-                        }
-                        processedElementIndexes.push(index);
-                    }
-                }
-            } else {
-                for (const index of flowElements.keys()){
-                    if (!processedElementIndexes.includes(index)) {
-                        unconnectedElementIndexes.push(index);
-                    }
-                }
+        const graph = flow.graph;
+        const start = flow.startReference;
+        if (!start) return [];
+        const violations = [];
+        const visited = new Set();
+        const stack = [
+            {
+                name: start,
+                seenDML: false
             }
-        }while (processedElementIndexes.length + unconnectedElementIndexes.length < flowElements.length)
-        return DuplicateDMLOperations.map((det)=>new _internals.Violation(det));
-    }
-    flagDML(element, dmlFlag) {
-        const dmlStatementTypes = [
-            "recordDeletes",
-            "recordUpdates",
-            "recordCreates"
         ];
-        if (dmlStatementTypes.includes(element.subtype)) {
-            return true;
-        } else if (dmlFlag === true && element.subtype === "screens" && element.element["allowBack"] === "true") {
-            return false;
-        } else {
-            return dmlFlag;
+        while(stack.length > 0){
+            const { name, seenDML } = stack.pop();
+            const stateKey = `${name}:${seenDML}`;
+            if (visited.has(stateKey)) continue;
+            visited.add(stateKey);
+            const node = graph.getNode(name);
+            if (!node) continue;
+            let nextSeenDML = seenDML || this.isDML(node);
+            if (nextSeenDML && node.subtype === "screens" && node.element["allowBack"] === "true" && node.element["showFooter"] === "true" && !suppressions.has(node.name)) {
+                violations.push(new _internals.Violation(node));
+            // Note: do NOT return early; multiple violations possible
+            }
+            // Reset DML flag after screen with back disabled
+            if (nextSeenDML && node.subtype === "screens" && node.element["allowBack"] !== "true") {
+                nextSeenDML = false;
+            }
+            for (const next of graph.getNextElements(name)){
+                stack.push({
+                    name: next,
+                    seenDML: nextSeenDML
+                });
+            }
         }
+        return violations;
+    }
+    isDML(node) {
+        return node.subtype === "recordCreates" || node.subtype === "recordUpdates" || node.subtype === "recordDeletes";
     }
     constructor(){
         super({
             name: "DuplicateDMLOperation",
             label: "Duplicate DML Operation",
-            description: "When the flow executes database changes or actions between two screens, it's important to prevent users from navigating back between screens. Failure to do so may result in duplicate database operations being performed within the flow.",
+            description: "When the flow executes database changes between screens, users must not be allowed to navigate back, or duplicate DML operations may occur.",
             supportedTypes: _internals.FlowType.visualTypes,
             docRefs: []
         });

package/main/rules/MissingFaultPath.js

@@ -82,7 +82,7 @@ let MissingFaultPath = class MissingFaultPath extends _RuleCommon.RuleCommon {
         return true;
     }
     check(flow, _options, suppressions) {
-        const compiler = new _internals.Compiler();
+        var _flow_graph;
         const results = [];
         const elementsWhereFaultPathIsApplicable = flow.elements.filter((node)=>{
             const proxyNode = node;
@@ -104,9 +104,7 @@ let MissingFaultPath = class MissingFaultPath extends _RuleCommon.RuleCommon {
                 }
             }
         };
-        if (flow.startReference) {
-            compiler.traverseFlow(flow, flow.startReference, visitCallback);
-        }
+        (_flow_graph = flow.graph) === null || _flow_graph === void 0 ? void 0 : _flow_graph.forEachReachable(visitCallback);
         return results;
     }
     /**
@@ -123,16 +121,8 @@ let MissingFaultPath = class MissingFaultPath extends _RuleCommon.RuleCommon {
         return false;
     }
     isPartOfFaultHandlingFlow(element, flow) {
-        const flowelements = flow.elements.filter((el)=>el instanceof _internals.FlowNode);
-        for (const otherElement of flowelements){
-            if (otherElement !== element) {
-                var _otherElement_connectors;
-                if ((_otherElement_connectors = otherElement.connectors) === null || _otherElement_connectors === void 0 ? void 0 : _otherElement_connectors.find((connector)=>connector.type === "faultConnector" && connector.reference && connector.reference === element.name)) {
-                    return true;
-                }
-            }
-        }
-        return false;
+        var _flow_graph;
+        return ((_flow_graph = flow.graph) === null || _flow_graph === void 0 ? void 0 : _flow_graph.isPartOfFaultHandling(element.name)) || false;
     }
     constructor(){
         super({

package/main/rules/TransformInsteadOfLoop.js

@@ -53,23 +53,22 @@ function _interop_require_wildcard(obj, nodeInterop) {
 }
 let TransformInsteadOfLoop = class TransformInsteadOfLoop extends _RuleCommon.RuleCommon {
     check(flow, _options, _suppressions) {
-        var _flow_elements;
         const violations = [];
-        var _flow_elements_filter;
-        // Get all loop elements
-        const loops = (_flow_elements_filter = (_flow_elements = flow.elements) === null || _flow_elements === void 0 ? void 0 : _flow_elements.filter((e)=>e.subtype === "loops")) !== null && _flow_elements_filter !== void 0 ? _flow_elements_filter : [];
-        for (const loop of loops){
-            var _loopNode_connectors;
-            const loopNode = loop;
-            // Check if the loop's nextValueConnector (the iterative path) leads to an assignment
-            const nextValueConnector = (_loopNode_connectors = loopNode.connectors) === null || _loopNode_connectors === void 0 ? void 0 : _loopNode_connectors.find((connector)=>connector.type === "nextValueConnector");
-            if (nextValueConnector === null || nextValueConnector === void 0 ? void 0 : nextValueConnector.reference) {
-                var _flow_elements1;
-                // Find the element that the nextValueConnector points to
-                const targetElement = (_flow_elements1 = flow.elements) === null || _flow_elements1 === void 0 ? void 0 : _flow_elements1.find((e)=>e.name === nextValueConnector.reference);
-                // Check if the target is an assignment
-                if ((targetElement === null || targetElement === void 0 ? void 0 : targetElement.subtype) === "assignments") {
+        const triggerType = this.getStartProperty(flow, 'triggerType');
+        const isRecordBeforeSave = triggerType === "RecordBeforeSave";
+        if (isRecordBeforeSave) {
+            return violations;
+        }
+        const loops = flow.graph.getLoopNodes();
+        for (const loopNode of loops){
+            // Get elements that the loop connects to (includes nextValueConnector)
+            const nextElements = flow.graph.getNextElements(loopNode.name);
+            // Check if any directly connected element is an assignment
+            for (const nextElementName of nextElements){
+                const nextElement = flow.graph.getNode(nextElementName);
+                if ((nextElement === null || nextElement === void 0 ? void 0 : nextElement.subtype) === "assignments") {
                     violations.push(new _internals.Violation(loopNode));
+                    break; // Only report once per loop
                 }
             }
         }
@@ -88,7 +87,7 @@ let TransformInsteadOfLoop = class TransformInsteadOfLoop extends _RuleCommon.Ru
                 }
             ]
         }, {
-            severity: "error"
+            severity: "note"
         });
     }
 };

package/main/rules/UnconnectedElement.js

@@ -53,16 +53,9 @@ function _interop_require_wildcard(obj, nodeInterop) {
 }
 let UnconnectedElement = class UnconnectedElement extends _RuleCommon.RuleCommon {
     check(flow, _options, suppressions) {
-        const connectedElements = new Set();
-        const logConnected = (element)=>{
-            connectedElements.add(element.name);
-        };
+        var _flow_graph;
+        const connectedElements = ((_flow_graph = flow.graph) === null || _flow_graph === void 0 ? void 0 : _flow_graph.getReachableElements()) || new Set();
         const flowElements = flow.elements.filter((node)=>node instanceof _internals.FlowNode);
-        // Use the helper to get the start reference
-        const startRef = this.getStartReference(flow);
-        if (startRef) {
-            new _internals.Compiler().traverseFlow(flow, startRef, logConnected);
-        }
         const unconnectedElements = flowElements.filter((element)=>!connectedElements.has(element.name) && !suppressions.has(element.name));
         return unconnectedElements.map((det)=>new _internals.Violation(det));
     }