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

package/README.md

@@ -201,8 +201,8 @@ Specifying exceptions allows you to exclude specific scenarios from rule enforce
   "exceptions": {
     "<FlowName>": {
       "<RuleName>": [
-        "<ResultName>",
-        "<ResultName>",
+        "<ResultName>",   // Suppress specific result
+        "*",              // Suppress ALL results of this rule
         ...
       ]
     },
@@ -211,6 +211,19 @@ Specifying exceptions allows you to exclude specific scenarios from rule enforce
 }
 ```
 
+_Example_
+
+```json
+{
+  "exceptions": {
+    "MyFlow": {
+      "MissingNullHandler": ["*"],
+      "HardcodedId": ["Old_Lookup_1"]
+    }
+  }
+}
+```
+
 ### Include Beta Rules
 
 New rules are introduced in Beta mode before being added to the default ruleset. To include current Beta rules, enable the optional betamode parameter in your configuration:
@@ -279,11 +292,11 @@ _Runs all enabled rules and returns detailed violations._
 
 _Automatically applies available fixes(removing variables and unconnected elements)._
 
-#### [`exportDetails(results: ScanResult[]): FlatViolation[]`](https://github.com/Flow-Scanner/lightning-flow-scanner-core/tree/main/src/main/libs/exportDetails.ts)
+#### [`exportDetails(results: ScanResult[]): FlatViolation[]`](https://github.com/Flow-Scanner/lightning-flow-scanner-core/tree/main/src/main/libs/exportAsDetails.ts)
 
-_Get flattened output of violations only._
+_Get output of violations only(Reserved for future use)._
 
-#### [`exportSarif(results: ScanResult[]): string`](https://github.com/Flow-Scanner/lightning-flow-scanner-core/tree/main/src/main/libs/exportSarif.ts)
+#### [`exportSarif(results: ScanResult[]): string`](https://github.com/Flow-Scanner/lightning-flow-scanner-core/tree/main/src/main/libs/exportAsSarif.ts)
 
 _Get SARIF output including exact line numbers of violations._
 
@@ -294,7 +307,7 @@ _Get SARIF output including exact line numbers of violations._
 [![GitHub stars](https://img.shields.io/github/stars/Flow-Scanner/lightning-flow-scanner-core)](https://img.shields.io/github/stars/Flow-Scanner/lightning-flow-scanner-core)
 [![GitHub contributors](https://img.shields.io/github/contributors/Flow-Scanner/lightning-flow-scanner-core.svg)](https://gitHub.com/Flow-Scanner/lightning-flow-scanner-core/graphs/contributors/)
 [![License](https://img.shields.io/npm/l/lightning-flow-scanner-core.svg)](https://github.com/Flow-Scanner/lightning-flow-scanner-core/raw/main/LICENSE.md)
-[![npm version](https://img.shields.io/npm/v/lightning-flow-scanner?label=npm)](https://www.npmjs.com/package/lightning-flow-scanner)
+[![npm version](https://img.shields.io/npm/v/Flow-Scanner/lightning-flow-scanner-core?label=npm)](https://www.npmjs.com/package/@flow-scanner/lightning-flow-scanner-core)
 [![Known Vulnerabilities](https://snyk.io/test/github/Flow-Scanner/lightning-flow-scanner-core/badge.svg)](https://snyk.io/test/github/Flow-Scanner/lightning-flow-scanner-core)
 
 **To install with npm:**
@@ -315,7 +328,7 @@ npm install @flow-scanner/lightning-flow-scanner-core
 >
 > Volta will automatically use the Node.js version defined in `package.json`.
 
-1. Clone the repo:
+1. Clone the repository
 
    ```bash
    git clone https://github.com/Flow-Scanner/lightning-flow-scanner-core.git
@@ -327,7 +340,7 @@ npm install @flow-scanner/lightning-flow-scanner-core
    npm install
    ```
 
-3. Build the project:
+3. Compile a new version:
 
    ```bash
    npm run build
@@ -340,13 +353,13 @@ npm install @flow-scanner/lightning-flow-scanner-core
    ```
 
 5. Test as local dependency(Optional):
-   To test changes to the core module locally, run:
+   a. run:
 
    ```bash
    npm run link
    ```
 
-   b) Go to the dependent project (e.g. VSX or CLI) and use:
+   b. Go to the dependent project (e.g. VSX or CLI) and use:
 
    ```bash
    npm link @flow-scanner/lightning-flow-scanner-core

package/index.d.ts

@@ -7,7 +7,6 @@ import { fix } from "./main/libs/FixFlows";
 import { getBetaRules, getRules } from "./main/libs/GetRuleDefinitions";
 import { parse } from "./main/libs/ParseFlows";
 import { scan } from "./main/libs/ScanFlows";
-import { AdvancedRule } from "./main/models/AdvancedRule";
 import { Flow } from "./main/models/Flow";
 import { FlowAttribute } from "./main/models/FlowAttribute";
 import { FlowElement } from "./main/models/FlowElement";
@@ -19,5 +18,5 @@ import { ParsedFlow } from "./main/models/ParsedFlow";
 import { ResultDetails } from "./main/models/ResultDetails";
 import { RuleResult } from "./main/models/RuleResult";
 import { ScanResult } from "./main/models/ScanResult";
-export { AdvancedRule, Compiler, exportDetails, exportSarif, fix, Flow, FlowAttribute, FlowElement, FlowNode, FlowResource, FlowType, FlowVariable, getBetaRules, getRules, parse, ParsedFlow, ResultDetails, RuleResult, scan, ScanResult, };
+export { Compiler, exportDetails, exportSarif, fix, Flow, FlowAttribute, FlowElement, FlowNode, FlowResource, FlowType, FlowVariable, getBetaRules, getRules, parse, ParsedFlow, ResultDetails, RuleResult, scan, ScanResult, };
 export type { IRuleDefinition, IRulesConfig };

package/index.js

@@ -9,9 +9,6 @@ function _export(target, all) {
     });
 }
 _export(exports, {
-    get AdvancedRule () {
-        return _AdvancedRule.AdvancedRule;
-    },
     get Compiler () {
         return _Compiler.Compiler;
     },
@@ -77,7 +74,6 @@ const _FixFlows = require("./main/libs/FixFlows");
 const _GetRuleDefinitions = require("./main/libs/GetRuleDefinitions");
 const _ParseFlows = require("./main/libs/ParseFlows");
 const _ScanFlows = require("./main/libs/ScanFlows");
-const _AdvancedRule = require("./main/models/AdvancedRule");
 const _Flow = require("./main/models/Flow");
 const _FlowAttribute = require("./main/models/FlowAttribute");
 const _FlowElement = require("./main/models/FlowElement");

package/main/interfaces/IRuleDefinition.d.ts

@@ -1,5 +1,4 @@
-import { Flow } from "../models/Flow";
-import { RuleResult } from "../models/RuleResult";
+import { Flow, RuleResult } from "../internals/internals";
 export interface IRuleDefinition {
     autoFixable: boolean;
     description: string;
@@ -7,7 +6,7 @@ export interface IRuleDefinition {
         label: string;
         path: string;
     }>;
-    execute(flow: Flow, ruleOptions?: {}): RuleResult;
+    execute(flow: Flow, options?: object, suppressions?: string[]): RuleResult;
     isConfigurable: boolean;
     label: string;
     name: string;

package/main/interfaces/IRulesConfig.d.ts

@@ -1,8 +1,7 @@
-import { AdvancedRuleConfig } from "./AdvancedRuleConfig";
 import { IExceptions } from "./IExceptions";
 import { IRuleOptions } from "./IRuleOptions";
 export interface IRulesConfig {
     betamode?: boolean;
     exceptions?: IExceptions;
-    rules?: AdvancedRuleConfig | IRuleOptions;
+    rules?: IRuleOptions;
 }

package/main/libs/DynamicRule.d.ts

@@ -1,5 +1,4 @@
 import { IRuleDefinition } from "../interfaces/IRuleDefinition";
-import { AdvancedRule } from "../models/AdvancedRule";
-export declare class DynamicRule<T extends AdvancedRule | IRuleDefinition> {
+export declare class DynamicRule<T extends IRuleDefinition> {
     constructor(className: string);
 }

package/main/libs/ScanFlows.js

@@ -18,35 +18,23 @@ _export(exports, {
 });
 const _internals = require("../../main/internals/internals");
 const _GetRuleDefinitions = require("./GetRuleDefinitions");
-const _Scan2 = require("./Scan2");
-const { IS_NEW_SCAN_ENABLED: isNewScanEnabled, OVERRIDE_CONFIG: overrideConfig } = process.env;
 function scan(parsedFlows, ruleOptions) {
-    // TD see jest.env-setup.ts for testing scan2
-    if (isNewScanEnabled === "true" && overrideConfig !== null && overrideConfig !== undefined) {
-        return (0, _Scan2.scan2)(parsedFlows, ruleOptions);
-    }
     const flows = [];
     for (const flow of parsedFlows){
         if (!flow.errorMessage && flow.flow) {
             flows.push(flow.flow);
         }
     }
-    let scanResults;
-    if ((ruleOptions === null || ruleOptions === void 0 ? void 0 : ruleOptions.rules) && Object.entries(ruleOptions.rules).length > 0) {
-        scanResults = ScanFlows(flows, ruleOptions);
-    } else {
-        scanResults = ScanFlows(flows);
-    }
-    generalSuppressions(scanResults, ruleOptions);
-    return scanResults;
+    const scanResults = ScanFlows(flows, ruleOptions);
+    return scanResults; // generalSuppressions removed — suppression now inline
 }
 function ScanFlows(flows, ruleOptions) {
     const flowResults = [];
     let selectedRules = [];
-    if (ruleOptions && ruleOptions.rules) {
+    if ((ruleOptions === null || ruleOptions === void 0 ? void 0 : ruleOptions.rules) && Object.keys(ruleOptions.rules).length > 0) {
         const ruleMap = new Map();
-        for (const [ruleName, rule] of Object.entries(ruleOptions.rules)){
-            ruleMap.set(ruleName, rule);
+        for (const [ruleName, config] of Object.entries(ruleOptions.rules)){
+            ruleMap.set(ruleName, config);
         }
         selectedRules = (0, _GetRuleDefinitions.GetRuleDefinitions)(ruleMap);
     } else {
@@ -56,19 +44,25 @@ function ScanFlows(flows, ruleOptions) {
         const ruleResults = [];
         for (const rule of selectedRules){
             try {
-                if (rule.supportedTypes.includes(flow.type)) {
-                    let config = undefined;
-                    if (ruleOptions && ruleOptions["rules"] && ruleOptions["rules"][rule.name]) {
-                        config = ruleOptions["rules"][rule.name];
-                    }
-                    const result = config && Object.keys(config).length > 0 ? rule.execute(flow, config) : rule.execute(flow);
-                    if (result.severity !== rule.severity) {
-                        result.severity = rule.severity;
-                    }
-                    ruleResults.push(result);
-                } else {
+                var _ruleOptions_rules, _ruleOptions_exceptions_flow_name, _ruleOptions_exceptions;
+                if (!rule.supportedTypes.includes(flow.type)) {
                     ruleResults.push(new _internals.RuleResult(rule, []));
+                    continue;
                 }
+                let config = undefined;
+                if (ruleOptions === null || ruleOptions === void 0 ? void 0 : (_ruleOptions_rules = ruleOptions.rules) === null || _ruleOptions_rules === void 0 ? void 0 : _ruleOptions_rules[rule.name]) {
+                    config = ruleOptions.rules[rule.name];
+                }
+                // WILDCARD SUPPORT: "*" = suppress all
+                const rawSuppressions = ruleOptions === null || ruleOptions === void 0 ? void 0 : (_ruleOptions_exceptions = ruleOptions.exceptions) === null || _ruleOptions_exceptions === void 0 ? void 0 : (_ruleOptions_exceptions_flow_name = _ruleOptions_exceptions[flow.name]) === null || _ruleOptions_exceptions_flow_name === void 0 ? void 0 : _ruleOptions_exceptions_flow_name[rule.name];
+                const suppressions = (rawSuppressions === null || rawSuppressions === void 0 ? void 0 : rawSuppressions.includes("*")) ? [
+                    "*"
+                ] : rawSuppressions !== null && rawSuppressions !== void 0 ? rawSuppressions : [];
+                const result = config && Object.keys(config).length > 0 ? rule.execute(flow, config, suppressions) : rule.execute(flow, undefined, suppressions);
+                if (result.severity !== rule.severity) {
+                    result.severity = rule.severity;
+                }
+                ruleResults.push(result);
             } catch (error) {
                 const message = `Something went wrong while executing ${rule.name} in the Flow: ${flow.name} with error ${error}`;
                 ruleResults.push(new _internals.RuleResult(rule, [], message));
@@ -78,26 +72,3 @@ function ScanFlows(flows, ruleOptions) {
     }
     return flowResults;
 }
-function generalSuppressions(scanResults, ruleOptions) {
-    if (!(ruleOptions === null || ruleOptions === void 0 ? void 0 : ruleOptions.exceptions)) {
-        return;
-    }
-    const applyExceptionToResults = (ruleResult, exceptions)=>{
-        const filteredDetails = ruleResult.details.filter((detail)=>!exceptions.includes(detail.name));
-        ruleResult.details = filteredDetails;
-        ruleResult.occurs = filteredDetails.length > 0;
-    };
-    for (const [flowName, exceptionElements] of Object.entries(ruleOptions.exceptions)){
-        const matchingScanResult = scanResults.find((result)=>result.flow.name === flowName);
-        if (!matchingScanResult) {
-            continue;
-        }
-        for (const ruleResult of matchingScanResult.ruleResults){
-            const exceptions = exceptionElements[ruleResult.ruleName];
-            if (!exceptions) {
-                continue;
-            }
-            applyExceptionToResults(ruleResult, exceptions);
-        }
-    }
-}

package/main/models/LoopRuleCommon.d.ts

@@ -1,7 +1,10 @@
+import { IRuleDefinition } from "../interfaces/IRuleDefinition";
 import { Flow, RuleResult } from "../internals/internals";
-import { AdvancedRule } from "./AdvancedRule";
-export declare abstract class LoopRuleCommon extends AdvancedRule {
-    execute(flow: Flow): RuleResult;
+import { RuleCommon } from "./RuleCommon";
+import { RuleInfo } from "./RuleInfo";
+export declare abstract class LoopRuleCommon extends RuleCommon implements IRuleDefinition {
+    constructor(info: RuleInfo);
+    execute(flow: Flow, options?: object, suppressions?: string[]): RuleResult;
     protected abstract getStatementTypes(): string[];
     private findLoopElements;
     private findLoopEnd;

package/main/models/LoopRuleCommon.js

@@ -9,16 +9,18 @@ Object.defineProperty(exports, "LoopRuleCommon", {
     }
 });
 const _internals = require("../internals/internals");
-const _AdvancedRule = require("./AdvancedRule");
-let LoopRuleCommon = class LoopRuleCommon extends _AdvancedRule.AdvancedRule {
-    execute(flow) {
-        const loopElements = this.findLoopElements(flow);
-        if (!loopElements.length) {
-            return new _internals.RuleResult(this, []);
-        }
-        const statementsInLoops = this.findStatementsInLoops(flow, loopElements);
-        const results = statementsInLoops.map((det)=>new _internals.ResultDetails(det));
-        return new _internals.RuleResult(this, results);
+const _RuleCommon = require("./RuleCommon");
+let LoopRuleCommon = class LoopRuleCommon extends _RuleCommon.RuleCommon {
+    execute(flow, options, suppressions = []) {
+        return this.executeWithSuppression(flow, options, suppressions, (suppSet)=>{
+            const loopElements = this.findLoopElements(flow);
+            if (!loopElements.length) {
+                return new _internals.RuleResult(this, []);
+            }
+            const statementsInLoops = this.findStatementsInLoops(flow, loopElements);
+            const results = statementsInLoops.filter((det)=>!suppSet.has(det.name)).map((det)=>new _internals.ResultDetails(det));
+            return new _internals.RuleResult(this, results);
+        });
     }
     findLoopElements(flow) {
         var _flow_elements;
@@ -39,10 +41,11 @@ let LoopRuleCommon = class LoopRuleCommon extends _AdvancedRule.AdvancedRule {
         };
         for (const element of loopElements){
             const loopEnd = this.findLoopEnd(element);
-            // decide if we should count fault connectors as a violation
-            // if (typeof element.element === "object" && "faultConnector" in (element.element as object)) {}
             new _internals.Compiler().traverseFlow(flow, element.name, findStatement, loopEnd);
         }
         return statementsInLoops;
     }
+    constructor(info){
+        super(info);
+    }
 };

package/main/models/RuleCommon.d.ts

@@ -1,4 +1,5 @@
 import { RuleInfo } from "./RuleInfo";
+import * as core from "../internals/internals";
 export declare class RuleCommon {
     autoFixable: boolean;
     description: string;
@@ -7,13 +8,14 @@ export declare class RuleCommon {
         path: string;
     }>;
     isConfigurable: boolean;
-    label: any;
-    name: any;
-    severity?: any;
+    label: string;
+    name: string;
+    severity?: string;
     supportedTypes: string[];
     suppressionElement?: string;
-    uri: any;
+    uri?: string;
     constructor(info: RuleInfo, optional?: {
         severity?: string;
     });
+    protected executeWithSuppression<T extends any[]>(flow: core.Flow, options: object | undefined, suppressions: string[], executeLogic: (suppSet: Set<string>) => core.RuleResult): core.RuleResult;
 }

package/main/models/RuleCommon.js

@@ -8,6 +8,7 @@ Object.defineProperty(exports, "RuleCommon", {
         return RuleCommon;
     }
 });
+const _internals = /*#__PURE__*/ _interop_require_wildcard(require("../internals/internals"));
 function _define_property(obj, key, value) {
     if (key in obj) {
         Object.defineProperty(obj, key, {
@@ -21,7 +22,56 @@ function _define_property(obj, key, value) {
     }
     return obj;
 }
+function _getRequireWildcardCache(nodeInterop) {
+    if (typeof WeakMap !== "function") return null;
+    var cacheBabelInterop = new WeakMap();
+    var cacheNodeInterop = new WeakMap();
+    return (_getRequireWildcardCache = function(nodeInterop) {
+        return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
+    })(nodeInterop);
+}
+function _interop_require_wildcard(obj, nodeInterop) {
+    if (!nodeInterop && obj && obj.__esModule) {
+        return obj;
+    }
+    if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
+        return {
+            default: obj
+        };
+    }
+    var cache = _getRequireWildcardCache(nodeInterop);
+    if (cache && cache.has(obj)) {
+        return cache.get(obj);
+    }
+    var newObj = {
+        __proto__: null
+    };
+    var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
+    for(var key in obj){
+        if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
+            var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
+            if (desc && (desc.get || desc.set)) {
+                Object.defineProperty(newObj, key, desc);
+            } else {
+                newObj[key] = obj[key];
+            }
+        }
+    }
+    newObj.default = obj;
+    if (cache) {
+        cache.set(obj, newObj);
+    }
+    return newObj;
+}
 let RuleCommon = class RuleCommon {
+    // NEW: Centralized suppression logic
+    executeWithSuppression(flow, options, suppressions, executeLogic) {
+        if (suppressions.includes("*")) {
+            return new _internals.RuleResult(this, []);
+        }
+        const suppSet = new Set(suppressions);
+        return executeLogic(suppSet);
+    }
     constructor(info, optional){
         _define_property(this, "autoFixable", void 0);
         _define_property(this, "description", void 0);

package/main/rules/APIVersion.d.ts

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

package/main/rules/APIVersion.js

@@ -9,7 +9,7 @@ Object.defineProperty(exports, "APIVersion", {
     }
 });
 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,26 +51,32 @@ function _interop_require_wildcard(obj, nodeInterop) {
     }
     return newObj;
 }
-let APIVersion = class APIVersion extends _AdvancedRule.AdvancedRule {
-    execute(flow, options) {
-        let flowAPIVersionNumber = null;
-        if (flow.xmldata.apiVersion) {
-            const flowAPIVersion = flow.xmldata.apiVersion;
-            flowAPIVersionNumber = +flowAPIVersion;
-        }
-        const results = [];
-        if (!flowAPIVersionNumber) {
-            results.push(new _internals.ResultDetails(new _internals.FlowAttribute("API Version <49", "apiVersion", "<49")));
-            return new _internals.RuleResult(this, results);
-        }
-        if (options && options.expression) {
-            // eslint-disable-next-line sonarjs/code-eval
-            const isApiNumberMoreThanConfiguredExpression = new Function(`return ${flowAPIVersionNumber}${options.expression};`);
-            if (!isApiNumberMoreThanConfiguredExpression()) {
-                results.push(new _internals.ResultDetails(new _internals.FlowAttribute(`${flowAPIVersionNumber}`, "apiVersion", options.expression)));
+let APIVersion = class APIVersion extends _RuleCommon.RuleCommon {
+    execute(flow, options, suppressions = []) {
+        return this.executeWithSuppression(flow, options, suppressions, (suppSet)=>{
+            let flowAPIVersionNumber = null;
+            if (flow.xmldata.apiVersion) {
+                flowAPIVersionNumber = +flow.xmldata.apiVersion;
             }
-        }
-        return new _internals.RuleResult(this, results);
+            const results = [];
+            if (!flowAPIVersionNumber) {
+                const detail = new _internals.ResultDetails(new _internals.FlowAttribute("API Version <49", "apiVersion", "<49"));
+                if (!suppSet.has(detail.name)) {
+                    results.push(detail);
+                }
+                return new _internals.RuleResult(this, results);
+            }
+            if (options === null || options === void 0 ? void 0 : options.expression) {
+                const isValid = new Function(`return ${flowAPIVersionNumber}${options.expression};`)();
+                if (!isValid) {
+                    const detail = new _internals.ResultDetails(new _internals.FlowAttribute(`${flowAPIVersionNumber}`, "apiVersion", options.expression));
+                    if (!suppSet.has(detail.name)) {
+                        results.push(detail);
+                    }
+                }
+            }
+            return new _internals.RuleResult(this, results);
+        });
     }
     constructor(){
         super({

package/main/rules/ActionCallsInLoop.js

@@ -31,8 +31,6 @@ let ActionCallsInLoop = class ActionCallsInLoop extends _LoopRuleCommon.LoopRule
             label: "**Beta** Action Calls In Loop",
             name: "ActionCallsInLoop",
             supportedTypes: _internals.FlowType.backEndTypes
-        }, {
-            severity: "warning"
         });
     }
 };

package/main/rules/AutoLayout.d.ts

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

package/main/rules/AutoLayout.js

@@ -9,7 +9,7 @@ Object.defineProperty(exports, "AutoLayout", {
     }
 });
 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,18 +51,27 @@ function _interop_require_wildcard(obj, nodeInterop) {
     }
     return newObj;
 }
-let AutoLayout = class AutoLayout extends _AdvancedRule.AdvancedRule {
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    execute(flow, options) {
-        if (flow.processMetadataValues) {
+let AutoLayout = class AutoLayout extends _RuleCommon.RuleCommon {
+    execute(flow, options, suppressions = []) {
+        return this.executeWithSuppression(flow, options, suppressions, (suppSet)=>{
             var _CanvasMode_value;
+            if (!flow.processMetadataValues) {
+                return new _internals.RuleResult(this, []);
+            }
             const CanvasMode = flow.xmldata.processMetadataValues.find((mdv)=>mdv.name === "CanvasMode");
-            const autoLayout = CanvasMode.value && typeof CanvasMode.value === "object" && CanvasMode.value.stringValue && CanvasMode.value.stringValue === "AUTO_LAYOUT_CANVAS";
-            return !autoLayout ? new _internals.RuleResult(this, [
-                new _internals.ResultDetails(new _internals.FlowAttribute((_CanvasMode_value = CanvasMode.value) === null || _CanvasMode_value === void 0 ? void 0 : _CanvasMode_value.stringValue, "CanvasMode", "!== AUTO_LAYOUT_CANVAS"))
-            ]) : new _internals.RuleResult(this, []);
-        }
-        return new _internals.RuleResult(this, []);
+            const autoLayout = (CanvasMode === null || CanvasMode === void 0 ? void 0 : CanvasMode.value) && typeof CanvasMode.value === "object" && CanvasMode.value.stringValue === "AUTO_LAYOUT_CANVAS";
+            if (autoLayout) {
+                return new _internals.RuleResult(this, []);
+            }
+            var _CanvasMode_value_stringValue;
+            const detail = new _internals.ResultDetails(new _internals.FlowAttribute((_CanvasMode_value_stringValue = CanvasMode === null || CanvasMode === void 0 ? void 0 : (_CanvasMode_value = CanvasMode.value) === null || _CanvasMode_value === void 0 ? void 0 : _CanvasMode_value.stringValue) !== null && _CanvasMode_value_stringValue !== void 0 ? _CanvasMode_value_stringValue : "undefined", "CanvasMode", "!== AUTO_LAYOUT_CANVAS"));
+            if (suppSet.has(detail.name)) {
+                return new _internals.RuleResult(this, []);
+            }
+            return new _internals.RuleResult(this, [
+                detail
+            ]);
+        });
     }
     constructor(){
         super({

package/main/rules/CopyAPIName.d.ts

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

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;
 }