chore: refactor rule definition to only use advanced rule c

Author: junners

src/main/rules/CopyAPIName.ts

@@ -1,17 +1,17 @@
 import * as core from "../internals/internals";
 import { AdvancedRule } from "../models/AdvancedRule";
 
-export class CopyAPIName extends AdvancedRule implements core.IRuleDefinition {
+export class CopyAPIName extends AdvancedRule {
   constructor() {
     super({
-      name: "CopyAPIName",
-      label: "Copy API Name",
+      autoFixable: false,
       description:
         "Maintaining multiple elements with a similar name, like 'Copy_X_Of_Element,' can diminish the overall readability of your Flow. When copying and pasting these elements, it's crucial to remember to update the API name of the newly created copy.",
-      supportedTypes: core.FlowType.allTypes(),
       docRefs: [],
       isConfigurable: false,
-      autoFixable: false,
+      label: "Copy API Name",
+      name: "CopyAPIName",
+      supportedTypes: core.FlowType.allTypes(),
     });
   }
 

src/main/rules/CyclomaticComplexity.ts

@@ -1,31 +1,31 @@
-import { AdvancedRule } from "../models/AdvancedRule";
 import * as core from "../internals/internals";
+import { AdvancedRule } from "../models/AdvancedRule";
+
+export class CyclomaticComplexity extends AdvancedRule {
+  private cyclomaticComplexityUnit: number = 0;
+
+  private defaultThreshold: number = 25;
 
-export class CyclomaticComplexity extends AdvancedRule implements core.IRuleDefinition {
   constructor() {
     super(
       {
-        name: "CyclomaticComplexity",
-        label: "Cyclomatic Complexity",
+        autoFixable: false,
         description: `The number of loops and decision rules, plus the number of decisions. Use a combination of 1) subflows and 2) breaking flows into multiple concise trigger ordered flows, to reduce the cyclomatic complexity within a single flow, ensuring maintainability and simplicity.`,
-        supportedTypes: core.FlowType.backEndTypes,
         docRefs: [
           {
             label: `Cyclomatic complexity is a software metric used to indicate the complexity of a program. It is a quantitative measure of the number of linearly independent paths through a program's source code.`,
             path: "https://en.wikipedia.org/wiki/Cyclomatic_complexity",
           },
         ],
         isConfigurable: true,
-        autoFixable: false,
+        label: "Cyclomatic Complexity",
+        name: "CyclomaticComplexity",
+        supportedTypes: core.FlowType.backEndTypes,
       },
       { severity: "note" }
     );
   }
 
-  private defaultThreshold: number = 25;
-
-  private cyclomaticComplexityUnit: number = 0;
-
   public execute(flow: core.Flow, options?: { threshold: number }): core.RuleResult {
     // Set Threshold
     const threshold = options?.threshold || this.defaultThreshold;