@flow-scanner/lightning-flow-scanner-core 6.3.1 → 6.4.1

package/main/rules/CopyAPIName.js

@@ -9,7 +9,7 @@ Object.defineProperty(exports, "CopyAPIName", {
     }
 });
 const _internals = /*#__PURE__*/ _interop_require_wildcard(require("../internals/internals"));
-const _AdvancedRule = require("../models/AdvancedRule");
+const _RuleCommon = require("../models/RuleCommon");
 function _getRequireWildcardCache(nodeInterop) {
     if (typeof WeakMap !== "function") return null;
     var cacheBabelInterop = new WeakMap();
@@ -51,22 +51,20 @@ function _interop_require_wildcard(obj, nodeInterop) {
     }
     return newObj;
 }
-let CopyAPIName = class CopyAPIName extends _AdvancedRule.AdvancedRule {
-    execute(flow) {
-        const flowElements = flow.elements.filter((node)=>node instanceof _internals.FlowNode);
-        const copyOfElements = [];
-        for (const element of flowElements){
-            // eslint-disable-next-line sonarjs/concise-regex
-            const copyOf = new RegExp("Copy_[0-9]+_of_[A-Za-z0-9]+").test(element.name);
-            if (copyOf) {
-                copyOfElements.push(element);
+let CopyAPIName = class CopyAPIName extends _RuleCommon.RuleCommon {
+    execute(flow, options, suppressions = []) {
+        return this.executeWithSuppression(flow, options, suppressions, (suppSet)=>{
+            const flowElements = flow.elements.filter((node)=>node instanceof _internals.FlowNode);
+            const copyOfElements = [];
+            for (const element of flowElements){
+                const copyOf = new RegExp("Copy_[0-9]+_of_[A-Za-z0-9]+").test(element.name);
+                if (copyOf && !suppSet.has(element.name)) {
+                    copyOfElements.push(element);
+                }
             }
-        }
-        const results = [];
-        for (const det of copyOfElements){
-            results.push(new _internals.ResultDetails(det));
-        }
-        return new _internals.RuleResult(this, results);
+            const results = copyOfElements.map((det)=>new _internals.ResultDetails(det));
+            return new _internals.RuleResult(this, results);
+        });
     }
     constructor(){
         super({

package/main/rules/CyclomaticComplexity.d.ts

@@ -1,10 +1,11 @@
-import { AdvancedRule } from "../models/AdvancedRule";
 import * as core from "../internals/internals";
-export declare class CyclomaticComplexity extends AdvancedRule implements core.IRuleDefinition {
+import { RuleCommon } from "../models/RuleCommon";
+import { IRuleDefinition } from "../interfaces/IRuleDefinition";
+export declare class CyclomaticComplexity extends RuleCommon implements IRuleDefinition {
     constructor();
     private defaultThreshold;
     private cyclomaticComplexityUnit;
     execute(flow: core.Flow, options?: {
         threshold: number;
-    }): core.RuleResult;
+    }, suppressions?: string[]): core.RuleResult;
 }

package/main/rules/CyclomaticComplexity.js

@@ -8,8 +8,8 @@ Object.defineProperty(exports, "CyclomaticComplexity", {
         return CyclomaticComplexity;
     }
 });
-const _AdvancedRule = require("../models/AdvancedRule");
 const _internals = /*#__PURE__*/ _interop_require_wildcard(require("../internals/internals"));
+const _RuleCommon = require("../models/RuleCommon");
 function _define_property(obj, key, value) {
     if (key in obj) {
         Object.defineProperty(obj, key, {
@@ -64,31 +64,34 @@ function _interop_require_wildcard(obj, nodeInterop) {
     }
     return newObj;
 }
-let CyclomaticComplexity = class CyclomaticComplexity extends _AdvancedRule.AdvancedRule {
-    execute(flow, options) {
-        var _flow_elements, _flow_elements1;
-        // Set Threshold
-        const threshold = (options === null || options === void 0 ? void 0 : options.threshold) || this.defaultThreshold;
-        // Calculate Cyclomatic Complexity based on the number of decision rules and loops, adding the number of decisions plus 1.
-        let cyclomaticComplexity = 1;
-        const flowDecisions = flow === null || flow === void 0 ? void 0 : (_flow_elements = flow.elements) === null || _flow_elements === void 0 ? void 0 : _flow_elements.filter((node)=>node.subtype === "decisions");
-        const flowLoops = flow === null || flow === void 0 ? void 0 : (_flow_elements1 = flow.elements) === null || _flow_elements1 === void 0 ? void 0 : _flow_elements1.filter((node)=>node.subtype === "loops");
-        for (const decision of flowDecisions || []){
-            const rules = decision.element["rules"];
-            if (Array.isArray(rules)) {
-                cyclomaticComplexity += rules.length + 1;
-            } else {
-                cyclomaticComplexity += 1;
+let CyclomaticComplexity = class CyclomaticComplexity extends _RuleCommon.RuleCommon {
+    execute(flow, options, suppressions = []) {
+        return this.executeWithSuppression(flow, options, suppressions, (suppSet)=>{
+            var _flow_elements, _flow_elements1;
+            const threshold = (options === null || options === void 0 ? void 0 : options.threshold) || this.defaultThreshold;
+            let cyclomaticComplexity = 1;
+            const flowDecisions = flow === null || flow === void 0 ? void 0 : (_flow_elements = flow.elements) === null || _flow_elements === void 0 ? void 0 : _flow_elements.filter((node)=>node.subtype === "decisions");
+            const flowLoops = flow === null || flow === void 0 ? void 0 : (_flow_elements1 = flow.elements) === null || _flow_elements1 === void 0 ? void 0 : _flow_elements1.filter((node)=>node.subtype === "loops");
+            for (const decision of flowDecisions || []){
+                const rules = decision.element["rules"];
+                if (Array.isArray(rules)) {
+                    cyclomaticComplexity += rules.length + 1;
+                } else {
+                    cyclomaticComplexity += 1;
+                }
             }
-        }
-        var _flowLoops_length;
-        cyclomaticComplexity += (_flowLoops_length = flowLoops === null || flowLoops === void 0 ? void 0 : flowLoops.length) !== null && _flowLoops_length !== void 0 ? _flowLoops_length : 0;
-        this.cyclomaticComplexityUnit = cyclomaticComplexity; // for unit testing
-        const results = [];
-        if (cyclomaticComplexity > threshold) {
-            results.push(new _internals.ResultDetails(new _internals.FlowAttribute(`${cyclomaticComplexity}`, "CyclomaticComplexity", `>${threshold}`)));
-        }
-        return new _internals.RuleResult(this, results);
+            var _flowLoops_length;
+            cyclomaticComplexity += (_flowLoops_length = flowLoops === null || flowLoops === void 0 ? void 0 : flowLoops.length) !== null && _flowLoops_length !== void 0 ? _flowLoops_length : 0;
+            this.cyclomaticComplexityUnit = cyclomaticComplexity;
+            const results = [];
+            if (cyclomaticComplexity > threshold) {
+                const detail = new _internals.ResultDetails(new _internals.FlowAttribute(`${cyclomaticComplexity}`, "CyclomaticComplexity", `>${threshold}`));
+                if (!suppSet.has(detail.name)) {
+                    results.push(detail);
+                }
+            }
+            return new _internals.RuleResult(this, results);
+        });
     }
     constructor(){
         super({

package/main/rules/DuplicateDMLOperation.d.ts

@@ -1,8 +1,9 @@
-import { AdvancedRule } from "../models/AdvancedRule";
 import * as core from "../internals/internals";
-export declare class DuplicateDMLOperation extends AdvancedRule implements core.IRuleDefinition {
+import { RuleCommon } from "../models/RuleCommon";
+import { IRuleDefinition } from "../interfaces/IRuleDefinition";
+export declare class DuplicateDMLOperation extends RuleCommon implements IRuleDefinition {
     constructor();
-    execute(flow: core.Flow): core.RuleResult;
+    execute(flow: core.Flow, options?: object, suppressions?: string[]): core.RuleResult;
     private flagDML;
     private findStart;
 }

package/main/rules/DuplicateDMLOperation.js

@@ -8,8 +8,8 @@ Object.defineProperty(exports, "DuplicateDMLOperation", {
         return DuplicateDMLOperation;
     }
 });
-const _AdvancedRule = require("../models/AdvancedRule");
 const _internals = /*#__PURE__*/ _interop_require_wildcard(require("../internals/internals"));
+const _RuleCommon = require("../models/RuleCommon");
 function _getRequireWildcardCache(nodeInterop) {
     if (typeof WeakMap !== "function") return null;
     var cacheBabelInterop = new WeakMap();
@@ -51,65 +51,65 @@ function _interop_require_wildcard(obj, nodeInterop) {
     }
     return newObj;
 }
-let DuplicateDMLOperation = class DuplicateDMLOperation extends _AdvancedRule.AdvancedRule {
-    execute(flow) {
-        const flowElements = flow.elements.filter((node)=>node instanceof _internals.FlowNode);
-        const processedElementIndexes = [];
-        const unconnectedElementIndexes = [];
-        const DuplicateDMLOperations = [];
-        const startingNode = this.findStart(flow);
-        if (!startingNode || startingNode === -1) {
-            throw "Can not find starting element";
-        }
-        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);
+let DuplicateDMLOperation = class DuplicateDMLOperation extends _RuleCommon.RuleCommon {
+    execute(flow, options, suppressions = []) {
+        return this.executeWithSuppression(flow, options, suppressions, (suppSet)=>{
+            const flowElements = flow.elements.filter((node)=>node instanceof _internals.FlowNode);
+            const processedElementIndexes = [];
+            const unconnectedElementIndexes = [];
+            const DuplicateDMLOperations = [];
+            const startingNode = this.findStart(flow);
+            if (startingNode === -1) {
+                return new _internals.RuleResult(this, []);
+            }
+            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((element)=>references.includes(element.name));
-                            for (const nextElement of elementsByReferences){
-                                const nextIndex = flowElements.findIndex((element)=>nextElement.name === element.name);
-                                if ("screens" === nextElement.subtype) {
-                                    if (dmlFlag && nextElement.element["allowBack"] && nextElement.element["allowBack"] == "true" && nextElement.element["showFooter"] == "true") {
-                                        DuplicateDMLOperations.push(nextElement);
+                            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 (!suppSet.has(nextElement.name)) {
+                                                DuplicateDMLOperations.push(nextElement);
+                                            }
+                                        }
+                                    }
+                                    if (!processedElementIndexes.includes(nextIndex)) {
+                                        indexesToProcess.push(nextIndex);
                                     }
-                                }
-                                if (!processedElementIndexes.includes(nextIndex)) {
-                                    indexesToProcess.push(nextIndex);
                                 }
                             }
+                            processedElementIndexes.push(index);
                         }
-                        processedElementIndexes.push(index);
                     }
-                }
-            } else {
-                // skip unconnected elements
-                for (const index of flowElements.keys()){
-                    if (!processedElementIndexes.includes(index)) {
-                        unconnectedElementIndexes.push(index);
+                } else {
+                    for (const index of flowElements.keys()){
+                        if (!processedElementIndexes.includes(index)) {
+                            unconnectedElementIndexes.push(index);
+                        }
                     }
                 }
-            }
-        }while (processedElementIndexes.length + unconnectedElementIndexes.length < flowElements.length)
-        const results = [];
-        for (const det of DuplicateDMLOperations){
-            results.push(new _internals.ResultDetails(det));
-        }
-        return new _internals.RuleResult(this, results);
+            }while (processedElementIndexes.length + unconnectedElementIndexes.length < flowElements.length)
+            const results = DuplicateDMLOperations.map((det)=>new _internals.ResultDetails(det));
+            return new _internals.RuleResult(this, results);
+        });
     }
     flagDML(element, dmlFlag) {
         const dmlStatementTypes = [
@@ -119,7 +119,7 @@ let DuplicateDMLOperation = class DuplicateDMLOperation extends _AdvancedRule.Ad
         ];
         if (dmlStatementTypes.includes(element.subtype)) {
             return true;
-        } else if (dmlFlag === true && element.subtype === "screens" && element.element["allowBack"] && element.element["allowBack"] == "true") {
+        } else if (dmlFlag === true && element.subtype === "screens" && element.element["allowBack"] === "true") {
             return false;
         } else {
             return dmlFlag;
@@ -127,17 +127,11 @@ let DuplicateDMLOperation = class DuplicateDMLOperation extends _AdvancedRule.Ad
     }
     findStart(flow) {
         const flowElements = flow.elements.filter((node)=>node instanceof _internals.FlowNode);
-        let start;
         if (flow.startElementReference) {
-            start = flowElements.findIndex((n)=>{
-                return n.name == flow.startElementReference;
-            });
+            return flowElements.findIndex((n)=>n.name === flow.startElementReference);
         } else {
-            start = flowElements.findIndex((n)=>{
-                return n.subtype === "start";
-            });
+            return flowElements.findIndex((n)=>n.subtype === "start");
         }
-        return start;
     }
     constructor(){
         super({

package/main/rules/FlowDescription.d.ts

@@ -1,6 +1,7 @@
 import * as core from "../internals/internals";
-import { AdvancedRule } from "../models/AdvancedRule";
-export declare class FlowDescription extends AdvancedRule implements core.IRuleDefinition {
+import { RuleCommon } from "../models/RuleCommon";
+import { IRuleDefinition } from "../interfaces/IRuleDefinition";
+export declare class FlowDescription extends RuleCommon implements IRuleDefinition {
     constructor();
-    execute(flow: core.Flow): core.RuleResult;
+    execute(flow: core.Flow, options?: object, suppressions?: string[]): core.RuleResult;
 }

package/main/rules/FlowDescription.js

@@ -9,7 +9,7 @@ Object.defineProperty(exports, "FlowDescription", {
     }
 });
 const _internals = /*#__PURE__*/ _interop_require_wildcard(require("../internals/internals"));
-const _AdvancedRule = require("../models/AdvancedRule");
+const _RuleCommon = require("../models/RuleCommon");
 function _getRequireWildcardCache(nodeInterop) {
     if (typeof WeakMap !== "function") return null;
     var cacheBabelInterop = new WeakMap();
@@ -51,13 +51,19 @@ function _interop_require_wildcard(obj, nodeInterop) {
     }
     return newObj;
 }
-let FlowDescription = class FlowDescription extends _AdvancedRule.AdvancedRule {
-    execute(flow) {
-        var _flow_xmldata;
-        const missingFlowDescription = !((_flow_xmldata = flow.xmldata) === null || _flow_xmldata === void 0 ? void 0 : _flow_xmldata.description);
-        return missingFlowDescription ? new _internals.RuleResult(this, [
-            new _internals.ResultDetails(new _internals.FlowAttribute("undefined", "description", "!==null"))
-        ]) : new _internals.RuleResult(this, []);
+let FlowDescription = class FlowDescription extends _RuleCommon.RuleCommon {
+    execute(flow, options, suppressions = []) {
+        return this.executeWithSuppression(flow, options, suppressions, (suppSet)=>{
+            var _flow_xmldata;
+            const missingFlowDescription = !((_flow_xmldata = flow.xmldata) === null || _flow_xmldata === void 0 ? void 0 : _flow_xmldata.description);
+            if (!missingFlowDescription || suppSet.has("FlowDescription")) {
+                return new _internals.RuleResult(this, []);
+            }
+            const detail = new _internals.ResultDetails(new _internals.FlowAttribute("undefined", "description", "!==null"));
+            return new _internals.RuleResult(this, [
+                detail
+            ]);
+        });
     }
     constructor(){
         super({

package/main/rules/FlowName.d.ts

@@ -1,7 +1,9 @@
-import { AdvancedConfig } from "../interfaces/AdvancedRuleConfig";
 import * as core from "../internals/internals";
-import { AdvancedRule } from "../models/AdvancedRule";
-export declare class FlowName extends AdvancedRule implements core.IRuleDefinition {
+import { RuleCommon } from "../models/RuleCommon";
+import { IRuleDefinition } from "../interfaces/IRuleDefinition";
+export declare class FlowName extends RuleCommon implements IRuleDefinition {
     constructor();
-    execute(flow: core.Flow, advancedConfig?: AdvancedConfig): core.RuleResult;
+    execute(flow: core.Flow, options?: {
+        expression?: string;
+    }, suppressions?: string[]): core.RuleResult;
 }

package/main/rules/FlowName.js

@@ -9,7 +9,7 @@ Object.defineProperty(exports, "FlowName", {
     }
 });
 const _internals = /*#__PURE__*/ _interop_require_wildcard(require("../internals/internals"));
-const _AdvancedRule = require("../models/AdvancedRule");
+const _RuleCommon = require("../models/RuleCommon");
 function _getRequireWildcardCache(nodeInterop) {
     if (typeof WeakMap !== "function") return null;
     var cacheBabelInterop = new WeakMap();
@@ -51,15 +51,24 @@ function _interop_require_wildcard(obj, nodeInterop) {
     }
     return newObj;
 }
-let FlowName = class FlowName extends _AdvancedRule.AdvancedRule {
-    execute(flow, advancedConfig) {
-        const rawRegexp = advancedConfig && advancedConfig.expression ? advancedConfig.expression : "[A-Za-z0-9]+_[A-Za-z0-9]+";
-        const regexExp = rawRegexp;
-        const flowName = flow.name;
-        const conventionApplied = new RegExp(regexExp).test(flowName);
-        return !conventionApplied ? new _internals.RuleResult(this, [
-            new _internals.ResultDetails(new _internals.FlowAttribute(flowName, "name", regexExp))
-        ]) : new _internals.RuleResult(this, []);
+let FlowName = class FlowName extends _RuleCommon.RuleCommon {
+    execute(flow, options, suppressions = []) {
+        return this.executeWithSuppression(flow, options, suppressions, (suppSet)=>{
+            var _options_expression;
+            const rawRegexp = (_options_expression = options === null || options === void 0 ? void 0 : options.expression) !== null && _options_expression !== void 0 ? _options_expression : "[A-Za-z0-9]+_[A-Za-z0-9]+";
+            const flowName = flow.name;
+            const conventionApplied = new RegExp(rawRegexp).test(flowName);
+            if (conventionApplied) {
+                return new _internals.RuleResult(this, []);
+            }
+            const detail = new _internals.ResultDetails(new _internals.FlowAttribute(flowName, "name", rawRegexp));
+            if (suppSet.has(detail.name)) {
+                return new _internals.RuleResult(this, []);
+            }
+            return new _internals.RuleResult(this, [
+                detail
+            ]);
+        });
     }
     constructor(){
         super({

package/main/rules/GetRecordAllFields.d.ts

@@ -1,6 +1,7 @@
 import * as core from "../internals/internals";
-import { AdvancedRule } from "../models/AdvancedRule";
-export declare class GetRecordAllFields extends AdvancedRule implements core.IRuleDefinition {
+import { RuleCommon } from "../models/RuleCommon";
+import { IRuleDefinition } from "../interfaces/IRuleDefinition";
+export declare class GetRecordAllFields extends RuleCommon implements IRuleDefinition {
     constructor();
-    execute(flow: core.Flow): core.RuleResult;
+    execute(flow: core.Flow, options?: object, suppressions?: string[]): core.RuleResult;
 }

package/main/rules/GetRecordAllFields.js

@@ -9,7 +9,7 @@ Object.defineProperty(exports, "GetRecordAllFields", {
     }
 });
 const _internals = /*#__PURE__*/ _interop_require_wildcard(require("../internals/internals"));
-const _AdvancedRule = require("../models/AdvancedRule");
+const _RuleCommon = require("../models/RuleCommon");
 function _getRequireWildcardCache(nodeInterop) {
     if (typeof WeakMap !== "function") return null;
     var cacheBabelInterop = new WeakMap();
@@ -51,30 +51,28 @@ function _interop_require_wildcard(obj, nodeInterop) {
     }
     return newObj;
 }
-let GetRecordAllFields = class GetRecordAllFields extends _AdvancedRule.AdvancedRule {
-    execute(flow) {
-        var _flow_elements;
-        const results = [];
-        const getElementNodes = (_flow_elements = flow.elements) === null || _flow_elements === void 0 ? void 0 : _flow_elements.filter((element)=>element.subtype === "recordLookups");
-        if (getElementNodes == null || getElementNodes.length === 0) {
-            return new _internals.RuleResult(this, results);
-        }
-        const errorNodes = getElementNodes.filter((element)=>{
-            const getRecordElement = element;
-            const hasQualifiedElementDefinition = typeof getRecordElement.element === "object";
-            if (!hasQualifiedElementDefinition) {
-                return false;
+let GetRecordAllFields = class GetRecordAllFields extends _RuleCommon.RuleCommon {
+    execute(flow, options, suppressions = []) {
+        return this.executeWithSuppression(flow, options, suppressions, (suppSet)=>{
+            var _flow_elements;
+            const results = [];
+            const getElementNodes = (_flow_elements = flow.elements) === null || _flow_elements === void 0 ? void 0 : _flow_elements.filter((element)=>element.subtype === "recordLookups");
+            if (!getElementNodes || getElementNodes.length === 0) {
+                return new _internals.RuleResult(this, results);
             }
-            const concreteChildElement = getRecordElement.element;
-            const storeAllFields = "storeOutputAutomatically" in concreteChildElement && concreteChildElement["storeOutputAutomatically"];
-            const hasQueriedFields = "queriedFields" in concreteChildElement && concreteChildElement["queriedFields"].length > 0;
-            return storeAllFields && !hasQueriedFields;
-        }).map((element)=>{
-            const getRecordElement = element;
-            return new _internals.ResultDetails(getRecordElement);
+            const errorNodes = getElementNodes.filter((element)=>{
+                const getRecordElement = element;
+                const hasQualifiedElementDefinition = typeof getRecordElement.element === "object";
+                if (!hasQualifiedElementDefinition) return false;
+                const concreteChildElement = getRecordElement.element;
+                const storeAllFields = "storeOutputAutomatically" in concreteChildElement && concreteChildElement["storeOutputAutomatically"];
+                const hasQueriedFields = "queriedFields" in concreteChildElement && Array.isArray(concreteChildElement["queriedFields"]) && concreteChildElement["queriedFields"].length > 0;
+                const isViolation = storeAllFields && !hasQueriedFields;
+                return isViolation && !suppSet.has(getRecordElement.name);
+            }).map((element)=>new _internals.ResultDetails(element));
+            results.push(...errorNodes);
+            return new _internals.RuleResult(this, results);
         });
-        results.push(...errorNodes);
-        return new _internals.RuleResult(this, results);
     }
     constructor(){
         super({

package/main/rules/HardcodedId.d.ts

@@ -1,6 +1,7 @@
-import { AdvancedRule } from "../models/AdvancedRule";
 import * as core from "../internals/internals";
-export declare class HardcodedId extends AdvancedRule implements core.IRuleDefinition {
+import { RuleCommon } from "../models/RuleCommon";
+import { IRuleDefinition } from "../interfaces/IRuleDefinition";
+export declare class HardcodedId extends RuleCommon implements IRuleDefinition {
     constructor();
-    execute(flow: core.Flow): core.RuleResult;
+    execute(flow: core.Flow, options?: object, suppressions?: string[]): core.RuleResult;
 }

package/main/rules/HardcodedId.js

@@ -8,8 +8,8 @@ Object.defineProperty(exports, "HardcodedId", {
         return HardcodedId;
     }
 });
-const _AdvancedRule = require("../models/AdvancedRule");
 const _internals = /*#__PURE__*/ _interop_require_wildcard(require("../internals/internals"));
+const _RuleCommon = require("../models/RuleCommon");
 function _getRequireWildcardCache(nodeInterop) {
     if (typeof WeakMap !== "function") return null;
     var cacheBabelInterop = new WeakMap();
@@ -51,18 +51,21 @@ function _interop_require_wildcard(obj, nodeInterop) {
     }
     return newObj;
 }
-let HardcodedId = class HardcodedId extends _AdvancedRule.AdvancedRule {
-    execute(flow) {
-        const nodesWithHardcodedIds = [];
-        const salesforceIdRegex = /\b[a-zA-Z0-9]{5}0[a-zA-Z0-9]{9}([a-zA-Z0-9]{3})?\b/g;
-        for (const node of flow.elements){
-            const nodeString = JSON.stringify(node);
-            if (salesforceIdRegex.test(nodeString)) {
-                nodesWithHardcodedIds.push(node);
+let HardcodedId = class HardcodedId extends _RuleCommon.RuleCommon {
+    execute(flow, options, suppressions = []) {
+        return this.executeWithSuppression(flow, options, suppressions, (suppSet)=>{
+            const salesforceIdRegex = /\b[a-zA-Z0-9]{5}0[a-zA-Z0-9]{9}([a-zA-Z0-9]{3})?\b/g;
+            const results = [];
+            for (const node of flow.elements){
+                const nodeString = JSON.stringify(node);
+                if (salesforceIdRegex.test(nodeString)) {
+                    if (!suppSet.has(node.name)) {
+                        results.push(new _internals.ResultDetails(node));
+                    }
+                }
             }
-        }
-        const results = nodesWithHardcodedIds.map((node)=>new _internals.ResultDetails(node));
-        return new _internals.RuleResult(this, results);
+            return new _internals.RuleResult(this, results);
+        });
     }
     constructor(){
         super({

package/main/rules/HardcodedUrl.d.ts

@@ -1,6 +1,7 @@
-import { Flow, IRuleDefinition, RuleResult } from "../internals/internals";
-import { AdvancedRule } from "../models/AdvancedRule";
-export declare class HardcodedUrl extends AdvancedRule implements IRuleDefinition {
+import { Flow, RuleResult } from "../internals/internals";
+import { RuleCommon } from "../models/RuleCommon";
+import { IRuleDefinition } from "../interfaces/IRuleDefinition";
+export declare class HardcodedUrl extends RuleCommon implements IRuleDefinition {
     constructor();
-    execute(flow: Flow): RuleResult;
+    execute(flow: Flow, options?: object, suppressions?: string[]): RuleResult;
 }

package/main/rules/HardcodedUrl.js

@@ -9,21 +9,25 @@ Object.defineProperty(exports, "HardcodedUrl", {
     }
 });
 const _internals = require("../internals/internals");
-const _AdvancedRule = require("../models/AdvancedRule");
-let HardcodedUrl = class HardcodedUrl extends _AdvancedRule.AdvancedRule {
-    execute(flow) {
-        const results = [];
-        if (!flow.elements || flow.elements.length === 0) {
-            return new _internals.RuleResult(this, results);
-        }
-        const urlRegex = /https?:\/\/(www\.)?[-a-zA-Z0-9@:%._\+~#=]{1,256}force\.com/g;
-        for (const element of flow.elements){
-            const nodeString = JSON.stringify(element);
-            if (urlRegex.test(nodeString)) {
-                results.push(new _internals.ResultDetails(element));
+const _RuleCommon = require("../models/RuleCommon");
+let HardcodedUrl = class HardcodedUrl extends _RuleCommon.RuleCommon {
+    execute(flow, options, suppressions = []) {
+        return this.executeWithSuppression(flow, options, suppressions, (suppSet)=>{
+            const results = [];
+            if (!flow.elements || flow.elements.length === 0) {
+                return new _internals.RuleResult(this, results);
+            }
+            const urlRegex = /https?:\/\/(www\.)?[-a-zA-Z0-9@:%._\+~#=]{1,256}force\.com/g;
+            for (const element of flow.elements){
+                const nodeString = JSON.stringify(element);
+                if (urlRegex.test(nodeString)) {
+                    if (!suppSet.has(element.name)) {
+                        results.push(new _internals.ResultDetails(element));
+                    }
+                }
             }
-        }
-        return new _internals.RuleResult(this, results);
+            return new _internals.RuleResult(this, results);
+        });
     }
     constructor(){
         super({

package/main/rules/InactiveFlow.d.ts

@@ -1,6 +1,7 @@
-import { AdvancedRule } from "../models/AdvancedRule";
 import * as core from "../internals/internals";
-export declare class InactiveFlow extends AdvancedRule implements core.IRuleDefinition {
+import { RuleCommon } from "../models/RuleCommon";
+import { IRuleDefinition } from "../interfaces/IRuleDefinition";
+export declare class InactiveFlow extends RuleCommon implements IRuleDefinition {
     constructor();
-    execute(flow: core.Flow): core.RuleResult;
+    execute(flow: core.Flow, options?: object, suppressions?: string[]): core.RuleResult;
 }