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

package/eslint.config.mjs

@@ -0,0 +1,36 @@
+import deMorgan from "eslint-plugin-de-morgan";
+import github from "eslint-plugin-github";
+import pluginJest from "eslint-plugin-jest";
+import perfectionist from "eslint-plugin-perfectionist";
+import sonarjs from "eslint-plugin-sonarjs";
+import globals from "globals";
+import tseslint from "typescript-eslint";
+
+export default [
+  { languageOptions: { globals: globals.browser } },
+  ...tseslint.configs.recommended,
+  {
+    files: ["tests/*.test.ts"],
+    languageOptions: {
+      globals: pluginJest.environments.globals.globals,
+    },
+    plugins: { jest: pluginJest },
+    rules: {
+      "jest/no-alias-methods": "error",
+      "jest/no-disabled-tests": "warn",
+      "jest/no-focused-tests": "error",
+      "jest/no-identical-title": "error",
+      "jest/prefer-to-have-length": "warn",
+      "jest/valid-expect": "error",
+    },
+  },
+  {
+    ignores: ["jest.config.ts", "example-flows/**"],
+  },
+  perfectionist.configs["recommended-alphabetical"],
+  perfectionist.configs["recommended-line-length"],
+  perfectionist.configs["recommended-natural"],
+  sonarjs.configs.recommended,
+  deMorgan.configs.recommended,
+  ...github.getFlatConfigs().typescript,
+];

package/jest.config.cjs

@@ -0,0 +1,32 @@
+module.exports = {
+  automock: false,
+  clearMocks: true,
+  collectCoverage: true,
+  coverageDirectory: "coverage",
+  coverageProvider: "v8",
+  coverageReporters: ["json", "text", "lcov"],
+  modulePathIgnorePatterns: ["./jest.config.cjs", "./out/"],
+  setupFilesAfterEnv: ["<rootDir>/jest.env-setup.js"],
+  testEnvironment: "node",
+  testPathIgnorePatterns: ["/node_modules/"],
+  transform: {
+    "^.+\\.(t|j)sx?$": [
+      "@swc-node/jest",
+      {
+        module: "commonjs",
+        swc: {
+          jsc: {
+            target: "es2020",
+            parser: {
+              syntax: "typescript",
+              tsx: false,
+            },
+          },
+          sourceMaps: "inline",
+          minify: false,
+        },
+      },
+    ],
+  },
+  transformIgnorePatterns: ["/node_modules/", "\\.pnp\\.[^\\/]+$"],
+};

package/jest.env-setup.js

@@ -0,0 +1,101 @@
+const fs = require("fs");
+const path = require("path");
+
+module.exports = () => {
+  if (!process.env.UMD_PATH) {
+    console.log("UMD Setup: No UMD_PATH—skipping (Node-only mode)");
+    return;
+  }
+
+  const umdFilePath = path.resolve(process.env.UMD_PATH);
+
+  if (!fs.existsSync(umdFilePath)) {
+    console.warn("UMD Setup: File not found at", umdFilePath, "—skipping.");
+    return;
+  }
+
+  let umdCode = fs.readFileSync(umdFilePath, "utf8");
+  const fastXmlParser = require("fast-xml-parser");
+
+  // Vite UMD pattern: (function(global, factory) { ... })(this, function(exports, dependency) { ... });
+  // We need to extract and execute the factory function
+
+  // Try to match Vite's UMD pattern more flexibly
+  const viteUmdMatch = umdCode.match(
+    /\(function\s*\([^,]+,\s*(\w+)\)\s*\{[\s\S]*?\}\)\s*\(this,\s*function\s*\((\w+)(?:,\s*(\w+))?\)\s*\{([\s\S]+)\}\s*\)\s*;?\s*$/
+  );
+
+  if (viteUmdMatch) {
+    const factoryBody = viteUmdMatch[4];
+    const exportsParam = viteUmdMatch[2];
+    const depParam = viteUmdMatch[3];
+
+    try {
+      // Create the factory function with proper parameters
+      const factoryFn = depParam
+        ? new Function(exportsParam, depParam, factoryBody)
+        : new Function(exportsParam, factoryBody);
+
+      // Create exports object and invoke factory
+      const exports = {};
+      if (depParam) {
+        factoryFn(exports, fastXmlParser);
+      } else {
+        factoryFn(exports);
+      }
+
+      // Assign to global
+      global.lightningflowscanner = exports;
+
+      if (Object.keys(exports).length === 0) {
+        console.error("UMD Setup: WARNING - exports object is empty!");
+      }
+    } catch (e) {
+      console.error("UMD Factory error:", e.message);
+      console.error("Stack:", e.stack);
+    }
+  } else {
+    // Fallback: Try direct execution approach
+
+    try {
+      // Create a mock global/window context
+      const mockGlobal = {};
+      const mockFactory = new Function(
+        "global",
+        "factory",
+        `
+        return (function(root, factoryFn) {
+          if (typeof exports === 'object' && typeof module !== 'undefined') {
+            factoryFn(exports, require('fast-xml-parser'));
+          } else {
+            factoryFn((root.lightningflowscanner = {}), root.fastXmlParser);
+          }
+        })(global, factory);
+      `
+      );
+
+      // Execute in controlled context
+      const vm = require("vm");
+      const sandbox = {
+        exports: {},
+        require: (id) => (id === "fast-xml-parser" ? fastXmlParser : require(id)),
+        module: { exports: {} },
+        console: console,
+      };
+
+      vm.runInNewContext(umdCode, sandbox);
+
+      // Check what got exported
+      const exports = sandbox.exports.default || sandbox.exports || sandbox.module.exports;
+
+      if (exports && Object.keys(exports).length > 0) {
+        global.lightningflowscanner = exports;
+      } else {
+        console.error("UMD Setup: Direct execution failed - no exports found");
+      }
+    } catch (e) {
+      console.error("UMD Direct execution error:", e.message);
+      console.error("Stack:", e.stack.slice(0, 400));
+    }
+  }
+};

package/lint-staged.config.mjs

@@ -0,0 +1,8 @@
+import micromatch from "micromatch";
+
+const isNotExampleFlows = (files) => micromatch.not(files, ["example-flows/**"]);
+
+export default {
+  "**/*.{js,json,md,xml,yaml,yml}": (files) =>
+    isNotExampleFlows(files).map((f) => `prettier --write "${f}"`),
+};

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

@@ -0,0 +1,32 @@
+/**
+ * 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[];

package/out/main/config/RegexAdapter.js

@@ -0,0 +1,86 @@
+/**
+ * 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.
+ */ "use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: Object.getOwnPropertyDescriptor(all, name).get
+    });
+}
+_export(exports, {
+    get flowElementToMetadataElement () {
+        return flowElementToMetadataElement;
+    },
+    get toMetadataElements () {
+        return toMetadataElements;
+    },
+    get toMetadataFile () {
+        return toMetadataFile;
+    },
+    get toViolation () {
+        return toViolation;
+    },
+    get toViolations () {
+        return toViolations;
+    }
+});
+const _FlowAttribute = require("../models/FlowAttribute");
+const _Violation = require("../models/Violation");
+function toMetadataFile(flow) {
+    // Handle case where toXMLString may not exist (e.g., in tests with partial Flow objects)
+    let content = "";
+    if (typeof flow.toXMLString === "function") {
+        content = flow.toXMLString();
+    }
+    var _flow_uri_split_pop;
+    return {
+        name: flow.name,
+        fileName: flow.uri ? (_flow_uri_split_pop = flow.uri.split(/[\\/]/).pop()) !== null && _flow_uri_split_pop !== void 0 ? _flow_uri_split_pop : `${flow.name}.flow-meta.xml` : `${flow.name}.flow-meta.xml`,
+        filePath: flow.fsPath,
+        metadataType: "Flow",
+        content,
+        elements: toMetadataElements(flow)
+    };
+}
+function toMetadataElements(flow) {
+    if (!flow.elements || flow.elements.length === 0) {
+        return [];
+    }
+    return flow.elements.map((element)=>{
+        var _element_element;
+        return {
+            name: element.name,
+            type: element.subtype,
+            content: (_element_element = element.element) !== null && _element_element !== void 0 ? _element_element : element
+        };
+    });
+}
+function toViolation(rv) {
+    var _rv_expression;
+    // Create a FlowAttribute to represent the violation
+    // This is the simplest approach that works for all regex rules
+    const flowElement = new _FlowAttribute.FlowAttribute(rv.name, rv.type, (_rv_expression = rv.expression) !== null && _rv_expression !== void 0 ? _rv_expression : rv.matchedText);
+    const violation = new _Violation.Violation(flowElement);
+    // Override line/column from regex violation
+    violation.lineNumber = rv.lineNumber;
+    violation.columnNumber = rv.columnNumber;
+    return violation;
+}
+function flowElementToMetadataElement(element) {
+    var _element_element;
+    return {
+        name: element.name,
+        type: element.subtype,
+        content: (_element_element = element.element) !== null && _element_element !== void 0 ? _element_element : element
+    };
+}
+function toViolations(violations) {
+    return violations.map(toViolation);
+}

package/{main → out/main}/config/RuleRegistry.js

@@ -20,6 +20,7 @@ const _FlowName = require("../rules/FlowName");
 const _GetRecordAllFields = require("../rules/GetRecordAllFields");
 const _HardcodedId = require("../rules/HardcodedId");
 const _HardcodedUrl = require("../rules/HardcodedUrl");
+const _HardcodedSecret = require("../rules/HardcodedSecret");
 const _InactiveFlow = require("../rules/InactiveFlow");
 const _MissingFaultPath = require("../rules/MissingFaultPath");
 const _MissingNullHandler = require("../rules/MissingNullHandler");
@@ -202,4 +203,5 @@ registry.register("missing-metadata-description", _MissingMetadataDescription.Mi
 registry.register("missing-record-trigger-filter", _MissingRecordTriggerFilter.MissingRecordTriggerFilter, "MissingFilterRecordTrigger", true);
 registry.register("transform-instead-of-loop", _TransformInsteadOfLoop.TransformInsteadOfLoop, "TransformInsteadOfLoop", true);
 registry.register("record-id-as-string", _RecordIdAsString.RecordIdAsString, "RecordIdAsString", true);
+registry.register("hardcoded-secret", _HardcodedSecret.HardcodedSecret, "HardcodedSecret", true);
 const ruleRegistry = registry;

package/out/main/rules/FlowName.d.ts

@@ -0,0 +1,15 @@
+import * as core from "../internals/internals";
+import { RuleCommon } from "../models/RuleCommon";
+import { IRuleDefinition } from "../interfaces/IRuleDefinition";
+/**
+ * Flow naming convention rule.
+ * This is a wrapper around the regex-scanner's NamingConvention rule,
+ * maintaining backward compatibility with the core scanner interface.
+ */
+export declare class FlowName extends RuleCommon implements IRuleDefinition {
+    private regexRule;
+    constructor();
+    protected check(flow: core.Flow, options: {
+        expression?: string;
+    } | undefined, _suppressions: Set<string>): core.Violation[];
+}

package/{main → out/main}/rules/FlowName.js

@@ -10,6 +10,21 @@ Object.defineProperty(exports, "FlowName", {
 });
 const _internals = /*#__PURE__*/ _interop_require_wildcard(require("../internals/internals"));
 const _RuleCommon = require("../models/RuleCommon");
+const _regexscanner = require("@flow-scanner/regex-scanner");
+const _RegexAdapter = require("../config/RegexAdapter");
+function _define_property(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
 function _getRequireWildcardCache(nodeInterop) {
     if (typeof WeakMap !== "function") return null;
     var cacheBabelInterop = new WeakMap();
@@ -53,16 +68,14 @@ function _interop_require_wildcard(obj, nodeInterop) {
 }
 let FlowName = class FlowName extends _RuleCommon.RuleCommon {
     check(flow, options, _suppressions) {
-        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]+";
-        var _flow_name;
-        const flowName = (_flow_name = flow.name) !== null && _flow_name !== void 0 ? _flow_name : "";
-        if (new RegExp(rawRegexp).test(flowName)) {
-            return [];
-        }
-        return [
-            new _internals.Violation(new _internals.FlowAttribute(flowName, "name", rawRegexp))
-        ];
+        // Convert Flow to MetadataFile for regex-scanner
+        const metadataFile = (0, _RegexAdapter.toMetadataFile)(flow);
+        // Execute regex rule
+        const regexViolations = this.regexRule.execute(metadataFile, {
+            expression: options === null || options === void 0 ? void 0 : options.expression
+        });
+        // Convert back to core Violations
+        return (0, _RegexAdapter.toViolations)(regexViolations);
     }
     constructor(){
         super({
@@ -81,6 +94,6 @@ let FlowName = class FlowName extends _RuleCommon.RuleCommon {
             supportedTypes: _internals.FlowType.allTypes()
         }, {
             severity: "error"
-        });
+        }), _define_property(this, "regexRule", new _regexscanner.NamingConvention());
     }
 };

package/out/main/rules/HardcodedId.d.ts

@@ -0,0 +1,13 @@
+import * as core from "../internals/internals";
+import { RuleCommon } from "../models/RuleCommon";
+import { IRuleDefinition } from "../interfaces/IRuleDefinition";
+/**
+ * Hardcoded Salesforce ID detection rule.
+ * This is a wrapper around the regex-scanner's HardcodedId rule,
+ * maintaining backward compatibility with the core scanner interface.
+ */
+export declare class HardcodedId extends RuleCommon implements IRuleDefinition {
+    private regexRule;
+    constructor();
+    protected check(flow: core.Flow, _options: object | undefined, _suppressions: Set<string>): core.Violation[];
+}

package/{main → out/main}/rules/HardcodedId.js

@@ -10,6 +10,21 @@ Object.defineProperty(exports, "HardcodedId", {
 });
 const _internals = /*#__PURE__*/ _interop_require_wildcard(require("../internals/internals"));
 const _RuleCommon = require("../models/RuleCommon");
+const _regexscanner = require("@flow-scanner/regex-scanner");
+const _RegexAdapter = require("../config/RegexAdapter");
+function _define_property(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
 function _getRequireWildcardCache(nodeInterop) {
     if (typeof WeakMap !== "function") return null;
     var cacheBabelInterop = new WeakMap();
@@ -53,15 +68,19 @@ function _interop_require_wildcard(obj, nodeInterop) {
 }
 let HardcodedId = class HardcodedId extends _RuleCommon.RuleCommon {
     check(flow, _options, _suppressions) {
-        const salesforceIdRegex = /\b[a-zA-Z0-9]{5}0[a-zA-Z0-9]{9}(?:[a-zA-Z0-9]{3})?\b/g;
-        return flow.elements.filter((node)=>salesforceIdRegex.test(JSON.stringify(node))).map((node)=>new _internals.Violation(node));
+        // Convert Flow to MetadataFile for regex-scanner
+        const metadataFile = (0, _RegexAdapter.toMetadataFile)(flow);
+        // Execute regex rule
+        const regexViolations = this.regexRule.execute(metadataFile);
+        // Convert back to core Violations
+        return (0, _RegexAdapter.toViolations)(regexViolations);
     }
     constructor(){
         super({
             ruleId: "hardcoded-id",
             name: "HardcodedId",
             category: "problem",
-            label: "Hardcoded Id",
+            label: "Hardcoded Salesforce Id",
             description: "Avoid hard-coding record IDs, as they are unique to a specific org and will not work in other environments. Instead, store IDs in variables—such as merge-field URL parameters or a **Get Records** element—to make the Flow portable, maintainable, and flexible.",
             summary: "Hardcoded IDs break portability across environments",
             supportedTypes: _internals.FlowType.allTypes(),
@@ -77,6 +96,6 @@ let HardcodedId = class HardcodedId extends _RuleCommon.RuleCommon {
             ]
         }, {
             severity: "error"
-        });
+        }), _define_property(this, "regexRule", new _regexscanner.HardcodedId());
     }
 };

package/out/main/rules/HardcodedSecret.d.ts

@@ -0,0 +1,13 @@
+import * as core from "../internals/internals";
+import { RuleCommon } from "../models/RuleCommon";
+import { IRuleDefinition } from "../interfaces/IRuleDefinition";
+/**
+ * Hardcoded secrets detection rule.
+ * This is a wrapper around the regex-scanner's HardcodedSecret rule,
+ * maintaining backward compatibility with the core scanner interface.
+ */
+export declare class HardcodedSecret extends RuleCommon implements IRuleDefinition {
+    private regexRule;
+    constructor();
+    protected check(flow: core.Flow, _options: object | undefined, _suppressions: Set<string>): core.Violation[];
+}

package/out/main/rules/HardcodedSecret.js

@@ -0,0 +1,101 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "HardcodedSecret", {
+    enumerable: true,
+    get: function() {
+        return HardcodedSecret;
+    }
+});
+const _internals = /*#__PURE__*/ _interop_require_wildcard(require("../internals/internals"));
+const _RuleCommon = require("../models/RuleCommon");
+const _regexscanner = require("@flow-scanner/regex-scanner");
+const _RegexAdapter = require("../config/RegexAdapter");
+function _define_property(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        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 HardcodedSecret = class HardcodedSecret extends _RuleCommon.RuleCommon {
+    check(flow, _options, _suppressions) {
+        // Convert Flow to MetadataFile for regex-scanner
+        const metadataFile = (0, _RegexAdapter.toMetadataFile)(flow);
+        // Execute regex rule
+        const regexViolations = this.regexRule.execute(metadataFile);
+        // Convert back to core Violations
+        return (0, _RegexAdapter.toViolations)(regexViolations);
+    }
+    constructor(){
+        super({
+            ruleId: "hardcoded-secret",
+            name: "HardcodedSecret",
+            category: "problem",
+            label: "Hardcoded Secret",
+            description: "Avoid hardcoding secrets, API keys, tokens, or credentials in Flows. These should be stored securely in Named Credentials, Custom Settings, Custom Metadata, or external secret management systems.",
+            summary: "Hardcoded secrets pose security risks",
+            supportedTypes: _internals.FlowType.allTypes(),
+            docRefs: [
+                {
+                    label: "Salesforce Named Credentials",
+                    path: "https://help.salesforce.com/s/articleView?id=sf.named_credentials_about.htm"
+                },
+                {
+                    label: "OWASP Secrets Management Cheat Sheet",
+                    path: "https://cheatsheetseries.owasp.org/cheatsheets/Secrets_Management_Cheat_Sheet.html"
+                }
+            ]
+        }, {
+            severity: "error"
+        }), _define_property(this, "regexRule", new _regexscanner.HardcodedSecret());
+    }
+};

package/{main → out/main}/rules/HardcodedUrl.d.ts

@@ -1,7 +1,13 @@
 import { Flow, Violation } from "../internals/internals";
 import { RuleCommon } from "../models/RuleCommon";
 import { IRuleDefinition } from "../interfaces/IRuleDefinition";
+/**
+ * Hardcoded Salesforce URL detection rule.
+ * This is a wrapper around the regex-scanner's HardcodedUrl rule,
+ * maintaining backward compatibility with the core scanner interface.
+ */
 export declare class HardcodedUrl extends RuleCommon implements IRuleDefinition {
+    private regexRule;
     constructor();
     protected check(flow: Flow, _options: object | undefined, _suppressions: Set<string>): Violation[];
 }

package/{main → out/main}/rules/HardcodedUrl.js

@@ -10,11 +10,29 @@ Object.defineProperty(exports, "HardcodedUrl", {
 });
 const _internals = require("../internals/internals");
 const _RuleCommon = require("../models/RuleCommon");
+const _regexscanner = require("@flow-scanner/regex-scanner");
+const _RegexAdapter = require("../config/RegexAdapter");
+function _define_property(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
 let HardcodedUrl = class HardcodedUrl extends _RuleCommon.RuleCommon {
     check(flow, _options, _suppressions) {
-        if (!flow.elements || flow.elements.length === 0) return [];
-        const urlRegex = /https?:\/\/(www\.)?[-a-zA-Z0-9@:%._\+~#=]{1,256}force\.com/g;
-        return flow.elements.filter((element)=>urlRegex.test(JSON.stringify(element))).map((element)=>new _internals.Violation(element));
+        // Convert Flow to MetadataFile for regex-scanner
+        const metadataFile = (0, _RegexAdapter.toMetadataFile)(flow);
+        // Execute regex rule
+        const regexViolations = this.regexRule.execute(metadataFile);
+        // Convert back to core Violations
+        return (0, _RegexAdapter.toViolations)(regexViolations);
     }
     constructor(){
         super({
@@ -32,11 +50,11 @@ let HardcodedUrl = class HardcodedUrl extends _RuleCommon.RuleCommon {
                     path: "https://admin.salesforce.com/blog/2021/why-you-should-avoid-hard-coding-and-three-alternative-solutions"
                 }
             ],
-            label: "Hardcoded Url",
+            label: "Hardcoded Salesforce Url",
             name: "HardcodedUrl",
             supportedTypes: _internals.FlowType.allTypes()
         }, {
             severity: "error"
-        });
+        }), _define_property(this, "regexRule", new _regexscanner.HardcodedUrl());
     }
 };