@flow-scanner/lightning-flow-scanner-core 6.16.2 → 6.17.1

package/tests/models/Flow.test.ts

@@ -0,0 +1,107 @@
+import { describe, it, expect, jest } from "@jest/globals";
+
+import { Flow } from "../../src/main/models/Flow";
+
+describe("Flow Model", () => {
+  beforeAll(() => {
+    jest.spyOn(console, "warn").mockImplementation(() => jest.fn());
+  });
+
+it("should print as xml when correct parameters", () => {
+  const sut: Flow = new Flow();
+  sut.xmldata = {
+    "@_xmlns": "http://soap.sforce.com/2006/04/metadata",
+    "@_xmlns:xsi": "http://www.w3.org/2001/XMLSchema-instance",
+    dynamicChoiceSets: {
+      name: "Priority",
+      dataType: "Picklist",
+      displayField: {
+        "@_xsi:nil": "true",  // String "true" (boolean true also works, but string matches parsed output)
+      },
+      object: {
+        "@_xsi:nil": "true",
+      },
+      picklistField: "Priority",
+      picklistObject: "Task",
+    },
+  };
+  const out = sut.toXMLString();
+  expect(out).toBeTruthy();
+  expect(out).toMatch('<displayField xsi:nil="true"></displayField>');  // UPDATED: Expanded form
+  expect(out).toMatch('<object xsi:nil="true"></object>');              // UPDATED: Expanded form
+});
+
+  class NoErrorThrownError extends Error {}
+  const getError = (call: () => unknown): Error => {
+    try {
+      call();
+      throw new NoErrorThrownError();
+    } catch (error: unknown) {
+      return error as Error;
+    }
+  };
+
+  it("should throw an exception for bad document", async () => {
+    const sut: Flow = new Flow();
+    const errors = getError(sut["generateDoc"]);
+    expect(errors).toBeTruthy();
+    expect(errors).not.toBeInstanceOf(NoErrorThrownError);
+  });
+
+  it("should identify transformElement as a FlowNode", () => {
+    const sut: Flow = new Flow();
+    sut.xmldata = {
+      transforms: [
+        {
+          name: "OCR_Mapping",
+          description: "OCR Mapping",
+          label: "OCR Mapping",
+          locationX: "176",
+          locationY: "323",
+          connector: {
+            targetReference: "OCR",
+          },
+          dataType: "SObject",
+          isCollection: "false",
+          objectType: "OpportunityContactRole",
+          scale: "0",
+          transformValues: {
+            transformValueActions: [
+              {
+                outputFieldApiName: "OpportunityId",
+                transformType: "Map",
+                value: {
+                  elementReference: "$Record.Id",
+                },
+              },
+              {
+                outputFieldApiName: "ContactId",
+                transformType: "Map",
+                value: {
+                  elementReference: "$Record.ContactId",
+                },
+              },
+              {
+                outputFieldApiName: "Role",
+                transformType: "Map",
+                value: {
+                  stringValue: "Decision Maker",
+                },
+              },
+            ],
+          },
+        },
+      ],
+    };
+
+    sut["preProcessNodes"]();
+
+    expect(sut.elements).toBeDefined();
+    expect(sut.elements).toHaveLength(1);
+    const element = sut.elements?.pop();
+    expect(element).toBeDefined();
+    expect(element).toHaveProperty("name", "OCR_Mapping");
+    expect(element?.metaType).toBe("node");
+    expect(element?.subtype).toBe("transforms");
+  });
+});

package/tests/models/LoopRuleCommon.test.ts

@@ -0,0 +1,246 @@
+import { describe, expect, it } from "@jest/globals";
+
+import { Flow, FlowNode } from "../../src/main/internals/internals";
+import { LoopRuleCommon } from "../../src/main/models/LoopRuleCommon";
+
+class TestLoopRule extends LoopRuleCommon {
+  constructor() {
+    super({
+      description: "Test Rule Description",
+      docRefs: [],
+      label: "Test Rule",
+      name: "TestRule",
+      supportedTypes: [],
+    });
+  }
+
+  protected getStatementTypes(): string[] {
+    return ["actionCalls"];
+  }
+}
+
+describe("LoopRuleCommon", () => {
+  let rule: TestLoopRule;
+
+  beforeEach(() => {
+    rule = new TestLoopRule();
+  });
+
+  describe("execute", () => {
+    it("should return empty when no loop elements exists", () => {
+      const actionCalls: FlowNode[] = [
+        new FlowNode("create_case_manually", "actionCalls", {
+          connector: { targetReference: "create_case_manually_2" },
+          description: "create case manually",
+          label: "create case manually",
+          locationX: "0",
+          locationY: "0",
+          name: "create_case_manually",
+        }),
+        new FlowNode("create_case_manually_2", "actionCalls", {
+          description: "create case manually 2",
+          label: "create case manually 2",
+          locationX: "0",
+          locationY: "0",
+          name: "create_case_manually_2",
+        }),
+      ];
+      const flow = new Flow();
+      flow.elements = [...actionCalls];
+
+      const result = rule.execute(flow);
+
+      expect(result.occurs).toBe(false);
+    });
+
+    it("should return empty when no statements in loops exists", () => {
+      const flow = new Flow();
+      flow.elements = [
+        new FlowNode("loop1", "loops", {
+          description: "loop 1",
+          label: "loop",
+          locationX: "0",
+          locationY: "0",
+          name: "loop1",
+          nextValueConnector: { targetReference: "assign1" },
+          noMoreValuesConnector: { targetReference: "End" },
+        }),
+        new FlowNode("assign1", "assignments", {
+          connector: { targetReference: "End" },
+          name: "assign1",
+        }),
+      ];
+
+      const result = rule.execute(flow);
+
+      expect(result.occurs).toBe(false);
+    });
+
+    it("should return when loop elements with statements exists", () => {
+      const actionCalls: FlowNode[] = [
+        new FlowNode("create_case_manually", "actionCalls", {
+          connector: { targetReference: "create_case_manually_2" },
+          description: "create case manually",
+          label: "create case manually",
+          locationX: "0",
+          locationY: "0",
+          name: "create_case_manually",
+        }),
+        new FlowNode("create_case_manually_2", "actionCalls", {
+          description: "create case manually 2",
+          label: "create case manually 2",
+          locationX: "0",
+          locationY: "0",
+          name: "create_case_manually_2",
+        }),
+      ];
+
+      const loopElements: FlowNode[] = [
+        new FlowNode("loop1", "loops", {
+          description: "loop 1",
+          label: "loop",
+          locationX: "0",
+          locationY: "0",
+          name: "loop1",
+          nextValueConnector: { targetReference: "create_case_manually" },
+          noMoreValuesConnector: { targetReference: "End" },
+        }),
+      ];
+
+      const flow = new Flow();
+      flow.elements = [...loopElements, ...actionCalls];
+
+      const result = rule.execute(flow);
+
+      expect(result.occurs).toBe(true);
+    });
+  });
+
+  describe("findLoopElements", () => {
+    it("should return empty when all elements are not loops", () => {
+      const actionCalls: FlowNode[] = [
+        new FlowNode("create_case_manually", "actionCalls", {
+          connector: { targetReference: "create_case_manually_2" },
+          description: "create case manually",
+          label: "create case manually",
+          locationX: "0",
+          locationY: "0",
+          name: "create_case_manually",
+        }),
+        new FlowNode("create_case_manually_2", "actionCalls", {
+          description: "create case manually 2",
+          label: "create case manually 2",
+          locationX: "0",
+          locationY: "0",
+          name: "create_case_manually_2",
+        }),
+      ];
+      const flow = new Flow();
+      flow.elements = [...actionCalls];
+
+      const result = rule["findLoopElements"](flow);
+
+      expect(result).toHaveLength(0);
+      expect(result).toEqual([]);
+    });
+    it("should return empty when no loop elements exists", () => {
+      const flow = new Flow();
+      flow.elements = [];
+
+      const result = rule["findLoopElements"](flow);
+
+      expect(result).toHaveLength(0);
+      expect(result).toEqual([]);
+    });
+  });
+
+  describe("findLoopEnd", () => {
+    it("should return current element when noMoreValuesConnector is not defined", () => {
+      const element = new FlowNode("loop1", "loops", {
+        name: "loop1",
+      });
+
+      const result = rule["findLoopEnd"](element);
+
+      expect(result).toBe("loop1");
+    });
+    it("should return the targetReference of noMoreValuesConnector", () => {
+      const element = new FlowNode("loop1", "loops", {
+        noMoreValuesConnector: { targetReference: "End" },
+      });
+
+      const result = rule["findLoopEnd"](element);
+
+      expect(result).toBe("End");
+    });
+  });
+
+  describe("findStatementsInLoops", () => {
+    it("should return empty when no statements in loops exists", () => {
+      const actionCalls: FlowNode[] = [
+        new FlowNode("create_case_manually", "actionCalls", {
+          connector: { targetReference: "create_case_manually_2" },
+          description: "create case manually",
+          label: "create case manually",
+          locationX: "0",
+          locationY: "0",
+          name: "create_case_manually",
+        }),
+        new FlowNode("create_case_manually_2", "actionCalls", {
+          description: "create case manually 2",
+          label: "create case manually 2",
+          locationX: "0",
+          locationY: "0",
+          name: "create_case_manually_2",
+        }),
+      ];
+
+      const flow = new Flow();
+      flow.elements = [...actionCalls];
+
+      const result = rule["findStatementsInLoops"](flow, []);
+
+      expect(result).toHaveLength(0);
+    });
+
+    it("should find statements in loop", () => {
+      const actionCalls: FlowNode[] = [
+        new FlowNode("create_case_manually", "actionCalls", {
+          connector: { targetReference: "create_case_manually_2" },
+          description: "create case manually",
+          label: "create case manually",
+          locationX: "0",
+          locationY: "0",
+          name: "create_case_manually",
+        }),
+        new FlowNode("create_case_manually_2", "actionCalls", {
+          description: "create case manually 2",
+          label: "create case manually 2",
+          locationX: "0",
+          locationY: "0",
+          name: "create_case_manually_2",
+        }),
+      ];
+
+      const loopElements: FlowNode[] = [
+        new FlowNode("loop1", "loops", {
+          description: "loop 1",
+          label: "loop",
+          locationX: "0",
+          locationY: "0",
+          name: "loop1",
+          nextValueConnector: { targetReference: "create_case_manually" },
+          noMoreValuesConnector: { targetReference: "End" },
+        }),
+      ];
+
+      const flow = new Flow();
+      flow.elements = [...loopElements, ...actionCalls];
+
+      const result = rule["findStatementsInLoops"](flow, loopElements);
+
+      expect(result).toHaveLength(2);
+      expect(result).toEqual(actionCalls);
+    });
+  });
+});

package/tests/models/RuleCommon.test.ts

@@ -0,0 +1,41 @@
+import { describe, expect, it } from "@jest/globals";
+import { ruleRegistry } from "../../src/main/config/RuleRegistry";
+
+describe("RuleCommon automatically sets isConfigurable correctly", () => {
+  it("isConfigurable=true only when check() actually uses options", () => {
+    // Get all rule classes (including beta, since the test should cover everything)
+    const allRuleIds = ruleRegistry.getAllRuleIds(true);
+
+    for (const ruleId of allRuleIds) {
+      const ruleInstance = ruleRegistry.createInstance(ruleId);
+
+      const checkSource = (ruleInstance as any).check.toString();
+      const usesOptions = /options[.\?]/.test(checkSource);
+
+      expect(ruleInstance.isConfigurable).toBe(usesOptions);
+
+      if (ruleInstance.isConfigurable !== usesOptions) {
+        console.log(`\nMISMATCH on rule: ${ruleInstance.name} (${ruleId})`);
+        console.log(`   isConfigurable = ${ruleInstance.isConfigurable}`);
+        console.log(`   source ${usesOptions ? "DOES" : "does NOT"} use options`);
+        console.log(`   check() source:\n${checkSource}\n`);
+      }
+    }
+  });
+
+  it("known configurable rules have isConfigurable=true", () => {
+    const cyclomatic = ruleRegistry.createInstance("excessive-cyclomatic-complexity");
+    const flowName = ruleRegistry.createInstance("invalid-naming-convention");
+
+    expect(cyclomatic.isConfigurable).toBe(true);
+    expect(flowName.isConfigurable).toBe(true);
+  });
+
+  it("known non-configurable rules have isConfigurable=false", () => {
+    const duplicateDml = ruleRegistry.createInstance("duplicate-dml");
+    const autoLayout = ruleRegistry.createInstance("missing-auto-layout");
+
+    expect(duplicateDml.isConfigurable).toBe(false);
+    expect(autoLayout.isConfigurable).toBe(false);
+  });
+});

package/tsconfig.json

@@ -0,0 +1,28 @@
+{
+  "compilerOptions": {
+    "composite": true,
+    "incremental": true,
+    "tsBuildInfoFile": "../../.tsbuildinfo/core.tsbuildinfo",
+
+    "declaration": true,
+    "emitDeclarationOnly": true,
+    "outDir": "types",
+    "target": "ES2020",
+    "module": "Node16",
+    "lib": ["ES2020"],
+    "downlevelIteration": true,
+    "rootDir": "src",
+    "declarationMap": true,
+    "skipLibCheck": true,
+    "baseUrl": ".",
+    "paths": {
+      "@flow-scanner/regex-scanner": ["../regex-scanner/out"],
+      "@flow-scanner/regex-scanner/*": ["../regex-scanner/out/*"]
+    }
+  },
+  "include": ["src/**/*.ts"],
+  "exclude": ["node_modules", "out"],
+  "references": [
+    { "path": "../regex-scanner" }
+  ]
+}

package/tsconfig.types.json

@@ -0,0 +1,26 @@
+{
+  "compilerOptions": {
+    "module": "ES6",
+    "target": "es6",
+    "moduleResolution": "node",
+    "outDir": "out",
+    "lib": ["es2020.string", "es6"],
+    "experimentalDecorators": true,
+    "sourceMap": false,
+    "rootDir": "src",
+    "strict": false,
+    "strictNullChecks": true,
+    "baseUrl": ".",
+    "declaration": true,
+    "esModuleInterop": true
+  },
+  "exclude": [
+    "node_modules",
+    "node_modules/**",
+    "example-flows/**",
+    "tests/**/*.ts",
+    "jest.config.ts",
+    "vite.config.ts",
+    "jest.setup.ts"
+  ]
+}

package/types/index.d.ts

@@ -0,0 +1,27 @@
+import type { IRuleDefinition } from "./main/interfaces/IRuleDefinition";
+import type { IRulesConfig } from "./main/interfaces/IRulesConfig";
+import type { FlatViolation } from "./main/models/FlatViolation";
+import { Compiler } from "./main/libs/Compiler";
+import { exportDetails } from "./main/libs/ExportDetails";
+import { exportSarif } from "./main/libs/ExportSarif";
+import { fix } from "./main/libs/FixFlows";
+import { getRules } from "./main/libs/GetRuleDefinitions";
+import { parse } from "./main/libs/ParseFlows";
+import { scan } from "./main/libs/ScanFlows";
+import { Flow } from "./main/models/Flow";
+import { FlowAttribute } from "./main/models/FlowAttribute";
+import { FlowElement } from "./main/models/FlowElement";
+import { FlowNode } from "./main/models/FlowNode";
+import { FlowResource } from "./main/models/FlowResource";
+import { FlowType } from "./main/models/FlowType";
+import { FlowVariable } from "./main/models/FlowVariable";
+import { ParsedFlow } from "./main/models/ParsedFlow";
+import { RuleResult } from "./main/models/RuleResult";
+import { ScanResult } from "./main/models/ScanResult";
+import { Violation } from "./main/models/Violation";
+import { DEFAULT_ICONS, ASCII_ICONS, type NodeIconConfig } from "./main/config/NodeIcons";
+import { DEFAULT_VARIABLE_ICONS, ASCII_VARIABLE_ICONS, type VariableIconConfig } from "./main/config/VariableIcons";
+import { exportDiagram, type DiagramOptions } from "./main/libs/ExportDiagram";
+export { Compiler, exportDetails, exportDiagram, exportSarif, fix, Flow, FlowAttribute, FlowElement, FlowNode, FlowResource, FlowType, FlowVariable, getRules, parse, ParsedFlow, Violation, RuleResult, scan, ScanResult, DEFAULT_ICONS, ASCII_ICONS, DEFAULT_VARIABLE_ICONS, ASCII_VARIABLE_ICONS, };
+export type { FlatViolation, IRuleDefinition, IRulesConfig, NodeIconConfig, DiagramOptions, VariableIconConfig };
+//# sourceMappingURL=index.d.ts.map

package/types/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,mCAAmC,CAAC;AACzE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,gCAAgC,CAAC;AACnE,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,6BAA6B,CAAC;AACjE,OAAO,EAAE,QAAQ,EAAE,MAAM,sBAAsB,CAAC;AAChD,OAAO,EAAE,aAAa,EAAE,MAAM,2BAA2B,CAAC;AAC1D,OAAO,EAAE,WAAW,EAAE,MAAM,yBAAyB,CAAC;AACtD,OAAO,EAAE,GAAG,EAAE,MAAM,sBAAsB,CAAC;AAC3C,OAAO,EAAE,QAAQ,EAAE,MAAM,gCAAgC,CAAC;AAC1D,OAAO,EAAE,KAAK,EAAE,MAAM,wBAAwB,CAAC;AAC/C,OAAO,EAAE,IAAI,EAAE,MAAM,uBAAuB,CAAC;AAC7C,OAAO,EAAE,IAAI,EAAE,MAAM,oBAAoB,CAAC;AAC1C,OAAO,EAAE,aAAa,EAAE,MAAM,6BAA6B,CAAC;AAC5D,OAAO,EAAE,WAAW,EAAE,MAAM,2BAA2B,CAAC;AACxD,OAAO,EAAE,QAAQ,EAAE,MAAM,wBAAwB,CAAC;AAClD,OAAO,EAAE,YAAY,EAAE,MAAM,4BAA4B,CAAC;AAC1D,OAAO,EAAE,QAAQ,EAAE,MAAM,wBAAwB,CAAC;AAClD,OAAO,EAAE,YAAY,EAAE,MAAM,4BAA4B,CAAC;AAC1D,OAAO,EAAE,UAAU,EAAE,MAAM,0BAA0B,CAAC;AACtD,OAAO,EAAE,UAAU,EAAE,MAAM,0BAA0B,CAAC;AACtD,OAAO,EAAE,UAAU,EAAE,MAAM,0BAA0B,CAAC;AACtD,OAAO,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAC;AACpD,OAAO,EAAE,aAAa,EAAE,WAAW,EAAE,KAAK,cAAc,EAAE,MAAM,yBAAyB,CAAC;AAC1F,OAAO,EAAE,sBAAsB,EAAE,oBAAoB,EAAE,KAAK,kBAAkB,EAAE,MAAM,6BAA6B,CAAC;AACpH,OAAO,EAAE,aAAa,EAAE,KAAK,cAAc,EAAE,MAAM,2BAA2B,CAAC;AAE/E,OAAO,EACL,QAAQ,EACR,aAAa,EACb,aAAa,EACb,WAAW,EACX,GAAG,EACH,IAAI,EACJ,aAAa,EACb,WAAW,EACX,QAAQ,EACR,YAAY,EACZ,QAAQ,EACR,YAAY,EACZ,QAAQ,EACR,KAAK,EACL,UAAU,EACV,SAAS,EACT,UAAU,EACV,IAAI,EACJ,UAAU,EACV,aAAa,EACb,WAAW,EACX,sBAAsB,EACtB,oBAAoB,GACrB,CAAC;AACF,YAAY,EAAE,aAAa,EAAE,eAAe,EAAE,YAAY,EAAE,cAAc,EAAE,cAAc,EAAE,kBAAkB,EAAE,CAAC"}

package/types/main/adapters/RegexAdapter.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Adapter functions to convert between core models (Flow, Violation)
+ * and regex-scanner models (MetadataFile, RegexViolation).
+ *
+ * This allows core rules to delegate to regex-scanner while maintaining
+ * backward compatibility with existing consumers.
+ */
+import type { MetadataFile, MetadataElement, RegexViolation } from "@flow-scanner/regex-scanner";
+import { Flow } from "../models/Flow";
+import { FlowElement } from "../models/FlowElement";
+import { Violation } from "../models/Violation";
+/**
+ * Convert a Flow object to a MetadataFile for regex-scanner.
+ */
+export declare function toMetadataFile(flow: Flow): MetadataFile;
+/**
+ * Convert Flow elements to MetadataElements for element-level scanning.
+ */
+export declare function toMetadataElements(flow: Flow): MetadataElement[];
+/**
+ * Convert a RegexViolation to a core Violation.
+ * Creates the appropriate FlowElement subclass based on metaType.
+ */
+export declare function toViolation(rv: RegexViolation): Violation;
+/**
+ * Convert a core FlowElement to a regex-scanner MetadataElement.
+ */
+export declare function flowElementToMetadataElement(element: FlowElement): MetadataElement;
+/**
+ * Convert multiple RegexViolations to core Violations.
+ */
+export declare function toViolations(violations: RegexViolation[]): Violation[];
+//# sourceMappingURL=RegexAdapter.d.ts.map

package/types/main/adapters/RegexAdapter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"RegexAdapter.d.ts","sourceRoot":"","sources":["../../../src/main/adapters/RegexAdapter.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,KAAK,EACV,YAAY,EACZ,eAAe,EACf,cAAc,EACf,MAAM,6BAA6B,CAAC;AAErC,OAAO,EAAE,IAAI,EAAE,MAAM,gBAAgB,CAAC;AAEtC,OAAO,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAC;AACpD,OAAO,EAAE,SAAS,EAAE,MAAM,qBAAqB,CAAC;AAGhD;;GAEG;AACH,wBAAgB,cAAc,CAAC,IAAI,EAAE,IAAI,GAAG,YAAY,CAiBvD;AAED;;GAEG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,IAAI,GAAG,eAAe,EAAE,CAUhE;AAED;;;GAGG;AACH,wBAAgB,WAAW,CAAC,EAAE,EAAE,cAAc,GAAG,SAAS,CAgBzD;AAED;;GAEG;AACH,wBAAgB,4BAA4B,CAC1C,OAAO,EAAE,WAAW,GACnB,eAAe,CAMjB;AAED;;GAEG;AACH,wBAAgB,YAAY,CAAC,UAAU,EAAE,cAAc,EAAE,GAAG,SAAS,EAAE,CAEtE"}

package/types/main/config/NodeIcons.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Icon configuration for flow node types.
+ * Emoji are safe in UTF-8 encoded source files and will work in all modern builds.
+ * If you need ASCII fallback, use FlowNode.setIconConfig(ASCII_ICONS)
+ */
+export interface NodeIconConfig {
+    [nodeType: string]: {
+        [subtype: string]: string;
+    } | {
+        default: string;
+    };
+}
+/**
+ * Default icons using emoji (recommended for modern environments)
+ */
+export declare const DEFAULT_ICONS: NodeIconConfig;
+/**
+ * ASCII fallback icons (for environments without emoji support)
+ */
+export declare const ASCII_ICONS: NodeIconConfig;
+/**
+ * Get default icon config (can be overridden at runtime)
+ */
+export declare function getDefaultIconConfig(): NodeIconConfig;
+//# sourceMappingURL=NodeIcons.d.ts.map

package/types/main/config/NodeIcons.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"NodeIcons.d.ts","sourceRoot":"","sources":["../../../src/main/config/NodeIcons.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,MAAM,WAAW,cAAc;IAC7B,CAAC,QAAQ,EAAE,MAAM,GAAG;QAClB,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAAC;KAC3B,GAAG;QAAE,OAAO,EAAE,MAAM,CAAA;KAAE,CAAC;CACzB;AAED;;GAEG;AACH,eAAO,MAAM,aAAa,EAAE,cA8C3B,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,WAAW,EAAE,cAwBzB,CAAC;AAEF;;GAEG;AACH,wBAAgB,oBAAoB,IAAI,cAAc,CAErD"}

package/types/main/config/RegexAdapter.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Adapter functions to convert between core models (Flow, Violation)
+ * and regex-scanner models (MetadataFile, RegexViolation).
+ *
+ * This allows core rules to delegate to regex-scanner while maintaining
+ * backward compatibility with existing consumers.
+ */
+import type { MetadataFile, MetadataElement, RegexViolation } from "@flow-scanner/regex-scanner";
+import { Flow } from "../models/Flow";
+import { FlowElement } from "../models/FlowElement";
+import { Violation } from "../models/Violation";
+/**
+ * Convert a Flow object to a MetadataFile for regex-scanner.
+ */
+export declare function toMetadataFile(flow: Flow): MetadataFile;
+/**
+ * Convert Flow elements to MetadataElements for element-level scanning.
+ */
+export declare function toMetadataElements(flow: Flow): MetadataElement[];
+/**
+ * Convert a RegexViolation to a core Violation.
+ * Creates the appropriate FlowElement subclass based on metaType.
+ */
+export declare function toViolation(rv: RegexViolation): Violation;
+/**
+ * Convert a core FlowElement to a regex-scanner MetadataElement.
+ */
+export declare function flowElementToMetadataElement(element: FlowElement): MetadataElement;
+/**
+ * Convert multiple RegexViolations to core Violations.
+ */
+export declare function toViolations(violations: RegexViolation[]): Violation[];
+//# sourceMappingURL=RegexAdapter.d.ts.map

package/types/main/config/RegexAdapter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"RegexAdapter.d.ts","sourceRoot":"","sources":["../../../src/main/config/RegexAdapter.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,KAAK,EACV,YAAY,EACZ,eAAe,EACf,cAAc,EACf,MAAM,6BAA6B,CAAC;AAErC,OAAO,EAAE,IAAI,EAAE,MAAM,gBAAgB,CAAC;AAEtC,OAAO,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAC;AACpD,OAAO,EAAE,SAAS,EAAE,MAAM,qBAAqB,CAAC;AAGhD;;GAEG;AACH,wBAAgB,cAAc,CAAC,IAAI,EAAE,IAAI,GAAG,YAAY,CAiBvD;AAED;;GAEG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,IAAI,GAAG,eAAe,EAAE,CAUhE;AAED;;;GAGG;AACH,wBAAgB,WAAW,CAAC,EAAE,EAAE,cAAc,GAAG,SAAS,CAgBzD;AAED;;GAEG;AACH,wBAAgB,4BAA4B,CAC1C,OAAO,EAAE,WAAW,GACnB,eAAe,CAMjB;AAED;;GAEG;AACH,wBAAgB,YAAY,CAAC,UAAU,EAAE,cAAc,EAAE,GAAG,SAAS,EAAE,CAEtE"}

package/types/main/config/RuleRegistry.d.ts

@@ -0,0 +1,23 @@
+import { IRuleDefinition } from "../interfaces/IRuleDefinition";
+import { IRulesConfig } from "../interfaces/IRulesConfig";
+type RuleConstructor = new () => IRuleDefinition;
+interface RuleRegistryEntry {
+    ruleId: string;
+    ruleClass: RuleConstructor;
+    legacyName: string;
+    isBeta: boolean;
+}
+declare class RuleRegistry {
+    private rules;
+    private legacyNameMap;
+    register(ruleId: string, ruleClass: RuleConstructor, legacyName: string, isBeta?: boolean): void;
+    get(idOrLegacyName: string): RuleRegistryEntry | undefined;
+    getAllRuleIds(includeBeta?: boolean): string[];
+    has(idOrLegacyName: string): boolean;
+    createInstance(idOrLegacyName: string): IRuleDefinition;
+    getRules(ruleConfig?: Map<string, unknown>, options?: IRulesConfig): IRuleDefinition[];
+    getRulesByNames(ruleNames?: string[], options?: IRulesConfig): IRuleDefinition[];
+}
+export declare const ruleRegistry: RuleRegistry;
+export {};
+//# sourceMappingURL=RuleRegistry.d.ts.map

package/types/main/config/RuleRegistry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"RuleRegistry.d.ts","sourceRoot":"","sources":["../../../src/main/config/RuleRegistry.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,+BAA+B,CAAC;AAEhE,OAAO,EAAE,YAAY,EAAE,MAAM,4BAA4B,CAAC;AA+B1D,KAAK,eAAe,GAAG,UAAU,eAAe,CAAC;AAEjD,UAAU,iBAAiB;IACzB,MAAM,EAAE,MAAM,CAAC;IACf,SAAS,EAAE,eAAe,CAAC;IAC3B,UAAU,EAAE,MAAM,CAAC;IACnB,MAAM,EAAE,OAAO,CAAC;CACjB;AAED,cAAM,YAAY;IAChB,OAAO,CAAC,KAAK,CAA6C;IAC1D,OAAO,CAAC,aAAa,CAAkC;IAEvD,QAAQ,CACN,MAAM,EAAE,MAAM,EACd,SAAS,EAAE,eAAe,EAC1B,UAAU,EAAE,MAAM,EAClB,MAAM,GAAE,OAAe,GACtB,IAAI;IAWP,GAAG,CAAC,cAAc,EAAE,MAAM,GAAG,iBAAiB,GAAG,SAAS;IAW1D,aAAa,CAAC,WAAW,GAAE,OAAe,GAAG,MAAM,EAAE;IAMrD,GAAG,CAAC,cAAc,EAAE,MAAM,GAAG,OAAO;IAIpC,cAAc,CAAC,cAAc,EAAE,MAAM,GAAG,eAAe;IAQvD,QAAQ,CACN,UAAU,CAAC,EAAE,GAAG,CAAC,MAAM,EAAE,OAAO,CAAC,EACjC,OAAO,CAAC,EAAE,YAAY,GACrB,eAAe,EAAE;IA4CpB,eAAe,CAAC,SAAS,CAAC,EAAE,MAAM,EAAE,EAAE,OAAO,CAAC,EAAE,YAAY,GAAG,eAAe,EAAE;CAejF;AAkCD,eAAO,MAAM,YAAY,cAAW,CAAC"}

package/types/main/config/VariableIcons.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Icon configuration for flow variable types.
+ * Includes icons for variable subtypes and boolean states.
+ */
+export interface VariableIconConfig {
+    subtypes: {
+        [subtype: string]: string;
+    };
+    boolean: {
+        true: string;
+        false: string;
+    };
+}
+/**
+ * Default icons using emoji (recommended for modern environments)
+ */
+export declare const DEFAULT_VARIABLE_ICONS: VariableIconConfig;
+/**
+ * ASCII fallback icons (for environments without emoji support)
+ */
+export declare const ASCII_VARIABLE_ICONS: VariableIconConfig;
+/**
+ * Get default variable icon config
+ */
+export declare function getDefaultVariableIconConfig(): VariableIconConfig;
+//# sourceMappingURL=VariableIcons.d.ts.map

package/types/main/config/VariableIcons.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"VariableIcons.d.ts","sourceRoot":"","sources":["../../../src/main/config/VariableIcons.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,MAAM,WAAW,kBAAkB;IAEjC,QAAQ,EAAE;QACR,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAAC;KAC3B,CAAC;IAEF,OAAO,EAAE;QACP,IAAI,EAAE,MAAM,CAAC;QACb,KAAK,EAAE,MAAM,CAAC;KACf,CAAC;CACH;AAED;;GAEG;AACH,eAAO,MAAM,sBAAsB,EAAE,kBAYpC,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,oBAAoB,EAAE,kBAYlC,CAAC;AAEF;;GAEG;AACH,wBAAgB,4BAA4B,IAAI,kBAAkB,CAEjE"}

package/types/main/enums/MetadataTypes.d.ts

@@ -0,0 +1,7 @@
+export declare enum MetaType {
+    ATTRIBUTE = "attribute",
+    VARIABLE = "variable",
+    RESOURCE = "resource",
+    NODE = "node"
+}
+//# sourceMappingURL=MetadataTypes.d.ts.map

package/types/main/enums/MetadataTypes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"MetadataTypes.d.ts","sourceRoot":"","sources":["../../../src/main/enums/MetadataTypes.ts"],"names":[],"mappings":"AAAA,oBAAY,QAAQ;IAClB,SAAS,cAAc;IACvB,QAAQ,aAAa;IACrB,QAAQ,aAAa;IACrB,IAAI,SAAS;CACd"}

package/types/main/interfaces/IExceptions.d.ts

@@ -0,0 +1,6 @@
+export interface IExceptions {
+    [exceptionName: string]: {
+        [property: string]: any[];
+    };
+}
+//# sourceMappingURL=IExceptions.d.ts.map