@flow-scanner/lightning-flow-scanner-core 6.0.3

package/main/rules/UnusedVariable.js

@@ -0,0 +1,100 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "UnusedVariable", {
+    enumerable: true,
+    get: function() {
+        return UnusedVariable;
+    }
+});
+const _AdvancedRule = require("../models/AdvancedRule");
+const _internals = /*#__PURE__*/ _interop_require_wildcard(require("../internals/internals"));
+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 UnusedVariable = class UnusedVariable extends _AdvancedRule.AdvancedRule {
+    execute(flow) {
+        const unusedVariables = [];
+        for (const variable of flow.elements.filter((node)=>node instanceof _internals.FlowVariable)){
+            const variableName = variable.name;
+            if ([
+                ...JSON.stringify(flow.elements.filter((node)=>node instanceof _internals.FlowNode)).matchAll(new RegExp(variableName, "gi"))
+            ].map((a)=>a.index).length === 0) {
+                // if not found in any inside of flow elements
+                if ([
+                    ...JSON.stringify(flow.elements.filter((node)=>node instanceof _internals.FlowResource)).matchAll(new RegExp(variableName, "gi"))
+                ].map((a)=>a.index).length === 0) {
+                    const insideCounter = [
+                        ...JSON.stringify(variable).matchAll(new RegExp(variable.name, "gi"))
+                    ].map((a)=>a.index);
+                    const variableUsage = [
+                        ...JSON.stringify(flow.elements.filter((node)=>node instanceof _internals.FlowVariable)).matchAll(new RegExp(variableName, "gi"))
+                    ].map((a)=>a.index);
+                    // finally also checks indexes where name occurs in the variable itself and where name occurs in all variables
+                    // when this is the same, variable must be unused.
+                    if (variableUsage.length === insideCounter.length) {
+                        unusedVariables.push(variable);
+                    }
+                }
+            }
+        }
+        const results = [];
+        for (const det of unusedVariables){
+            results.push(new _internals.ResultDetails(det));
+        }
+        return new _internals.RuleResult(this, results);
+    }
+    constructor(){
+        super({
+            name: "UnusedVariable",
+            label: "Unused Variable",
+            description: "To maintain the efficiency and manageability of your Flow, it's advisable to avoid including unconnected variables that are not in use.",
+            supportedTypes: [
+                ..._internals.FlowType.backEndTypes,
+                ..._internals.FlowType.visualTypes
+            ],
+            docRefs: [],
+            isConfigurable: false,
+            autoFixable: true
+        });
+    }
+};

package/main/store/DefaultRuleStore.d.ts

@@ -0,0 +1,2 @@
+export declare const DefaultRuleStore: object;
+export declare const BetaRuleStore: object;

package/main/store/DefaultRuleStore.js

@@ -0,0 +1,68 @@
+"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 BetaRuleStore () {
+        return BetaRuleStore;
+    },
+    get DefaultRuleStore () {
+        return DefaultRuleStore;
+    }
+});
+const _ActionCallsInLoop = require("../rules/ActionCallsInLoop");
+const _APIVersion = require("../rules/APIVersion");
+const _AutoLayout = require("../rules/AutoLayout");
+const _CopyAPIName = require("../rules/CopyAPIName");
+const _CyclomaticComplexity = require("../rules/CyclomaticComplexity");
+const _DMLStatementInLoop = require("../rules/DMLStatementInLoop");
+const _DuplicateDMLOperation = require("../rules/DuplicateDMLOperation");
+const _FlowDescription = require("../rules/FlowDescription");
+const _FlowName = require("../rules/FlowName");
+const _GetRecordAllFields = require("../rules/GetRecordAllFields");
+const _HardcodedId = require("../rules/HardcodedId");
+const _HardcodedUrl = require("../rules/HardcodedUrl");
+const _InactiveFlow = require("../rules/InactiveFlow");
+const _MissingFaultPath = require("../rules/MissingFaultPath");
+const _MissingNullHandler = require("../rules/MissingNullHandler");
+const _ProcessBuilder = require("../rules/ProcessBuilder");
+const _RecursiveAfterUpdate = require("../rules/RecursiveAfterUpdate");
+const _SameRecordFieldUpdates = require("../rules/SameRecordFieldUpdates");
+const _SOQLQueryInLoop = require("../rules/SOQLQueryInLoop");
+const _TriggerOrder = require("../rules/TriggerOrder");
+const _UnconnectedElement = require("../rules/UnconnectedElement");
+const _UnsafeRunningContext = require("../rules/UnsafeRunningContext");
+const _UnusedVariable = require("../rules/UnusedVariable");
+const DefaultRuleStore = {
+    APIVersion: _APIVersion.APIVersion,
+    AutoLayout: _AutoLayout.AutoLayout,
+    CopyAPIName: _CopyAPIName.CopyAPIName,
+    CyclomaticComplexity: _CyclomaticComplexity.CyclomaticComplexity,
+    DMLStatementInLoop: _DMLStatementInLoop.DMLStatementInLoop,
+    DuplicateDMLOperation: _DuplicateDMLOperation.DuplicateDMLOperation,
+    FlowDescription: _FlowDescription.FlowDescription,
+    FlowName: _FlowName.FlowName,
+    GetRecordAllFields: _GetRecordAllFields.GetRecordAllFields,
+    HardcodedId: _HardcodedId.HardcodedId,
+    HardcodedUrl: _HardcodedUrl.HardcodedUrl,
+    InactiveFlow: _InactiveFlow.InactiveFlow,
+    MissingFaultPath: _MissingFaultPath.MissingFaultPath,
+    MissingNullHandler: _MissingNullHandler.MissingNullHandler,
+    ProcessBuilder: _ProcessBuilder.ProcessBuilder,
+    RecursiveAfterUpdate: _RecursiveAfterUpdate.RecursiveAfterUpdate,
+    SameRecordFieldUpdates: _SameRecordFieldUpdates.SameRecordFieldUpdates,
+    SOQLQueryInLoop: _SOQLQueryInLoop.SOQLQueryInLoop,
+    TriggerOrder: _TriggerOrder.TriggerOrder,
+    UnconnectedElement: _UnconnectedElement.UnconnectedElement,
+    UnsafeRunningContext: _UnsafeRunningContext.UnsafeRunningContext,
+    UnusedVariable: _UnusedVariable.UnusedVariable
+};
+const BetaRuleStore = {
+    ActionCallsInLoop: _ActionCallsInLoop.ActionCallsInLoop
+};

package/package.json

@@ -0,0 +1,88 @@
+{
+  "name": "@flow-scanner/lightning-flow-scanner-core",
+  "description": "A purpose-built engine for Flow metadata in Node.js and browser environments. Assess and enhance Salesforce Flow automations for best practices, security, governor limits, and performance issues.",
+  "version": "6.0.3",
+  "main": "index.js",
+  "types": "index.d.ts",
+  "engines": {
+    "node": "^18 || ^20 || ^22 || ^23"
+  },
+  "scripts": {
+    "clean": "rm -rf out",
+    "build:js": "swc src --out-dir out --copy-files --strip-leading-paths --config-file .swcrc",
+    "build:types": "tsc -p tsconfig.types.json --declaration --emitDeclarationOnly --outDir out",
+    "copy:index": "cp out/main/index.js out/index.js || true",
+    "copy:media": "mkdir -p out/assets/media && cp -r assets/media/* out/assets/media/ || true",
+    "copy:root-files:out": "cp README.md LICENSE.md SECURITY.md CONTRIBUTING.md package.json out/ || true",
+    "copy:root-files:dist": "cp LICENSE.md dist/ || true",
+    "____main____": "__DEVELOPER COMMANDS__",
+    "build": "npm run clean && npm run build:js && npm run build:types && npm run copy:index && npm run copy:media && npm run copy:root-files:out",
+    "test": "jest",
+    "lint": "eslint src tests",
+    "link": "npm run build && npm link ./out",
+    "____pack____": "PACKAGING COMMANDS__",
+    "swc:sim:pack": "npm run build",
+    "vite:dist": "npm run build:js && vite build && npm run copy:root-files:dist",
+    "test:vite": "vitest",
+    "prepare": "husky",
+    "precommit": "lint-staged",
+    "prepush": "npm run build && npm test",
+    "stryker": "npm i -g @stryker-mutator/core @stryker-mutator/jest-runner && stryker run"
+  },
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Flow-Scanner/lightning-flow-scanner-core.git"
+  },
+  "dependencies": {
+    "fast-xml-parser": "^5.3.0"
+  },
+  "devDependencies": {
+    "@jest/types": "30.0.1",
+    "@swc-node/jest": "1.9.1",
+    "@swc/cli": "0.7.7",
+    "@swc/core": "1.13.5",
+    "@swc/helpers": "0.5.17",
+    "@types/jest": "29.5.14",
+    "@types/node": "22.15.30",
+    "@types/semantic-release": "20.0.6",
+    "eslint": "9.30.0",
+    "eslint-plugin-de-morgan": "1.3.0",
+    "eslint-plugin-github": "6.0.0",
+    "eslint-plugin-jest": "29.0.1",
+    "eslint-plugin-perfectionist": "4.15.0",
+    "eslint-plugin-sonarjs": "3.0.4",
+    "husky": "9.1.7",
+    "jest": "30.0.3",
+    "lint-staged": "^16.1.2",
+    "prettier": "3.6.2",
+    "ts-node": "10.9.2",
+    "typescript": "5.8.3",
+    "typescript-eslint": "8.35.0",
+    "vite": "6.4.1",
+    "vite-plugin-node-polyfills": "0.23.0",
+    "vitest": "3.2.4"
+  },
+  "homepage": "https://flow-scanner.github.io/lightning-flow-scanner-core",
+  "author": {
+    "name": "Ruben Halman",
+    "url": "https://github.com/RubenHalman"
+  },
+  "volta": {
+    "node": "20.13.1"
+  },
+  "keywords": [
+    "salesforce",
+    "flow",
+    "linter",
+    "salesforce-flow",
+    "flow-linter",
+    "flow-scanner",
+    "static-analysis",
+    "code-quality",
+    "security-scanner",
+    "flow-builder",
+    "salesforce-devops",
+    "best-practices"
+  ]
+}