x-fidelity 3.13.0 → 3.14.0

package/CHANGELOG.md

@@ -1,3 +1,23 @@
+# [3.14.0](https://github.com/zotoio/x-fidelity/compare/v3.13.1...v3.14.0) (2025-03-11)
+
+
+### Bug Fixes
+
+* **demo:** config speed improvement ([a1be883](https://github.com/zotoio/x-fidelity/commit/a1be88367a606187b90d27af09aebb725753ed77))
+
+
+### Features
+
+* add React patterns plugin with hook dependency and cleanup analysis ([7cfd38d](https://github.com/zotoio/x-fidelity/commit/7cfd38d86596ba97536aa0c2028ee054103630dd))
+* enhance function complexity analysis with additional metrics ([a3d61dc](https://github.com/zotoio/x-fidelity/commit/a3d61dc4cd0d5382ffa13a9565cd909782aa9aa4))
+
+## [3.13.1](https://github.com/zotoio/x-fidelity/compare/v3.13.0...v3.13.1) (2025-03-11)
+
+
+### Bug Fixes
+
+* **exemptions:** trace logging ([343744c](https://github.com/zotoio/x-fidelity/commit/343744c161d2756d9fa5e419426d0b4f1a37d1d4))
+
 # [3.13.0](https://github.com/zotoio/x-fidelity/compare/v3.12.1...v3.13.0) (2025-03-10)
 
 

package/dist/core/configManager.test.js

@@ -118,7 +118,8 @@ jest.mock('../utils/logger', () => ({
         debug: jest.fn(),
         error: jest.fn(),
         info: jest.fn(),
-        warn: jest.fn()
+        warn: jest.fn(),
+        trace: jest.fn()
     },
     setLogPrefix: jest.fn()
 }));

package/dist/core/engine/engineRunner.js

@@ -43,7 +43,7 @@ function runEngineOnFiles(params) {
             try {
                 const { results } = yield engine.run(facts);
                 for (const result of results) {
-                    logger_1.logger.debug(JSON.stringify(result));
+                    logger_1.logger.trace(JSON.stringify(result));
                     if (result.result) {
                         fileFailures.push({
                             ruleFailure: result.name,

package/dist/core/engine/engineRunner.test.js

@@ -19,6 +19,7 @@ jest.mock('../../utils/logger', () => ({
         debug: jest.fn(),
         error: jest.fn(),
         warn: jest.fn(),
+        trace: jest.fn()
     },
 }));
 describe('runEngineOnFiles', () => {

package/dist/core/pluginRegistry.test.js

@@ -8,6 +8,7 @@ jest.mock('../utils/logger', () => ({
         warn: jest.fn(),
         error: jest.fn(),
         debug: jest.fn(),
+        trace: jest.fn()
     },
 }));
 describe('XFiPluginRegistry', () => {

package/dist/demoConfig/node-fullstack-exemptions/project1-node-fullstack-exemptions.json

@@ -1,8 +1,8 @@
 [
     {
       "repoUrl": "git@github.com:zotoio/x-fidelity.git",
-      "rule": "outdatedFramework-global",
-      "expirationDate": "2023-12-31",
+      "rule": "noDatabases-iterative",
+      "expirationDate": "2026-01-04",
       "reason": "Upgrading dependencies is scheduled for Q4 2024"
     },
     {

package/dist/demoConfig/rules/functionComplexity-iterative-rule.json

@@ -12,17 +12,17 @@
                 "fact": "functionComplexity",
                 "params": {
                     "resultFact": "complexityResult",
-                    "minimumComplexityLogged": 8
+                    "minimumComplexityLogged": 25
                 },
                 "operator": "astComplexity",
-                "value": 10
+                "value": 40
             }
         ]
     },
     "event": {
         "type": "warning",
         "params": {
-            "message": "Functions detected with high cyclomatic complexity (10+). Consider refactoring.",
+            "message": "Functions detected with high cyclomatic complexity (40+). Consider refactoring.",
             "details": {
                 "fact": "complexityResult"
             }

package/dist/demoConfig/rules/functionCount-iterative-rule.json

@@ -14,14 +14,14 @@
                     "resultFact": "functionCountResult"
                 },
                 "operator": "functionCount",
-                "value": 20
+                "value": 30
             }
         ]
     },
     "event": {
         "type": "warning",
         "params": {
-            "message": "File contains too many functions (>20). Consider splitting into multiple files.",
+            "message": "File contains too many functions (>30). Consider splitting into multiple files.",
             "details": {
                 "fact": "functionCountResult"
             }

package/dist/facts/globalFileAnalysisFacts.test.js

@@ -17,6 +17,7 @@ jest.mock('../utils/logger', () => ({
         error: jest.fn(),
         info: jest.fn(),
         warn: jest.fn(),
+        trace: jest.fn()
     },
 }));
 describe('globalFileAnalysis', () => {

package/dist/facts/index.test.js

@@ -27,7 +27,9 @@ jest.mock('../utils/logger', () => ({
     logger: {
         info: jest.fn(),
         debug: jest.fn(),
-        warn: jest.fn()
+        warn: jest.fn(),
+        trace: jest.fn(),
+        error: jest.fn()
     }
 }));
 describe('loadFacts', () => {

package/dist/facts/openaiAnalysisFacts.test.js

@@ -22,6 +22,7 @@ jest.mock('../utils/logger', () => ({
         error: jest.fn(),
         info: jest.fn(),
         warn: jest.fn(),
+        trace: jest.fn()
     },
 }));
 jest.mock('openai', () => {

package/dist/index.js

@@ -112,8 +112,12 @@ function main() {
                         localConfigPath: cli_1.options.localConfigPath,
                         executionLogPrefix
                     });
-                    const resultString = JSON.stringify(resultMetadata);
-                    const prettyResult = prettyjson_1.default.render(resultMetadata.XFI_RESULT);
+                    logger_1.logger.info(`PERFORMANCE: Rule executions took ${resultMetadata.XFI_RESULT.durationSeconds} seconds`);
+                    const reportGenerationStartTime = new Date().getTime();
+                    let resultString = JSON.stringify(resultMetadata);
+                    let prettyResult = prettyjson_1.default.render(resultMetadata.XFI_RESULT);
+                    const reportGenerationdurationSeconds = ((new Date().getTime()) - reportGenerationStartTime) / 1000;
+                    logger_1.logger.info(`PERFORMANCE: Report generation took ${reportGenerationdurationSeconds} seconds`);
                     // Add debug logging before notification check
                     logger_1.logger.debug({
                         notificationsEnabled: process.env.NOTIFICATIONS_ENABLED,
@@ -122,13 +126,28 @@ function main() {
                     }, 'Checking notification status');
                     // Send notifications if enabled
                     if (notificationConfig.enabled) {
+                        const notificationStartTime = new Date().getTime();
                         logger_1.logger.debug('Notifications are enabled, preparing to send report');
                         logger_1.logger.debug({
                             affectedFilesCount: resultMetadata.XFI_RESULT.issueDetails.length
                         }, 'Preparing notification data');
                         // Pass the repo config to the notification manager
                         yield notificationManager.sendReport(resultMetadata);
+                        const notificationDurationSeconds = ((new Date().getTime()) - notificationStartTime) / 1000;
+                        logger_1.logger.info(`PERFORMANCE: Notifications took ${notificationDurationSeconds} seconds`);
                     }
+                    // update overall duration and end time in XFI_RESULT
+                    const endTime = new Date().getTime();
+                    resultMetadata.XFI_RESULT.durationSeconds = (endTime - resultMetadata.XFI_RESULT.startTime) / 1000;
+                    resultMetadata.XFI_RESULT.finishTime = endTime;
+                    // change the finishTime value in the resultString to be endTimestamp
+                    const resultStringWithEndTimestamp = resultString.replace(/("finishTime"):([\s]+)*([\d\.]+)/g, `$1:${endTime}`);
+                    // change the durationSeconds value in the resultString to be the overall duration
+                    resultString = resultStringWithEndTimestamp.replace(/("durationSeconds"):([\s]+)*([\d\.]+)/g, `$1:${resultMetadata.XFI_RESULT.durationSeconds}`);
+                    // change the finishTime value in the prettyResult to be endTimestamp
+                    const prettyResultWithEndTimestamp = prettyResult.replace(/(.*startTime.*34m)(\d*)(.*)/g, `$1$${endTime}$3`);
+                    // change the durationSeconds value in the prettyResult to be the overall duration
+                    prettyResult = prettyResultWithEndTimestamp.replace(/(.*durationSeconds.*34m)(\d*)(.*)/g, `$1${resultMetadata.XFI_RESULT.durationSeconds}$3`);
                     // if results are found, there were issues found in the codebase
                     if (resultMetadata.XFI_RESULT.totalIssues > 0) {
                         logger_1.logger.warn(`WARNING: lo-fi attributes detected in codebase. ${resultMetadata.XFI_RESULT.warningCount} are warnings, ${resultMetadata.XFI_RESULT.fatalityCount} are fatal.`);

package/dist/notifications/notificationManager.js

@@ -250,7 +250,7 @@ class NotificationManager {
             try {
                 // Failure template
                 fileDetails = results.XFI_RESULT.issueDetails.map(issue => {
-                    logger_1.logger.debug(issue, `generating report content for issue: ${issue.filePath}`);
+                    logger_1.logger.trace(issue, `generating report content for issue: ${issue.filePath}`);
                     // Remove local path prefix from file paths
                     const relativePath = issue.filePath.replace(results.XFI_RESULT.repoPath + '/', '');
                     const fileIssues = issue.errors;
@@ -280,7 +280,7 @@ class NotificationManager {
                         }).join('');
                         return output + errorDetails + '</ul></li>';
                     }).join('');
-                    logger_1.logger.debug(`fileDetails: ${output + ruleDetails}</ul></li>`);
+                    logger_1.logger.trace(`fileDetails: ${output + ruleDetails}</ul></li>`);
                     return output + ruleDetails + '</ul></li>';
                 }).join('');
             }

package/dist/operators/fileContains.test.js

@@ -5,7 +5,10 @@ const fileContains_1 = require("./fileContains");
 jest.mock('../utils/logger', () => ({
     logger: {
         debug: jest.fn(),
-        error: jest.fn()
+        error: jest.fn(),
+        trace: jest.fn(),
+        info: jest.fn(),
+        warn: jest.fn()
     },
 }));
 describe('fileContains', () => {

package/dist/operators/globalPatternCount.js

@@ -6,7 +6,7 @@ const globalPatternCount = {
     'name': 'globalPatternCount',
     'fn': (analysisResult, threshold) => {
         try {
-            logger_1.logger.debug(`globalPatternCount: processing ${JSON.stringify(analysisResult)}`);
+            logger_1.logger.trace(`globalPatternCount: processing ${JSON.stringify(analysisResult)}`);
             if (!analysisResult || !analysisResult.summary) {
                 logger_1.logger.debug('globalPatternCount: no analysis result available');
                 return false;

package/dist/operators/globalPatternCount.test.js

@@ -6,6 +6,8 @@ jest.mock('../utils/logger', () => ({
         debug: jest.fn(),
         error: jest.fn(),
         info: jest.fn(),
+        trace: jest.fn(),
+        warn: jest.fn()
     },
 }));
 describe('globalPatternCount', () => {

package/dist/operators/globalPatternRatio.js

@@ -6,7 +6,7 @@ const globalPatternRatio = {
     'name': 'globalPatternRatio',
     'fn': (analysisResult, threshold) => {
         try {
-            logger_1.logger.debug(`globalPatternRatio: processing ${JSON.stringify(analysisResult)}`);
+            logger_1.logger.trace(`globalPatternRatio: processing ${JSON.stringify(analysisResult)}`);
             if (!analysisResult || !analysisResult.summary) {
                 logger_1.logger.debug('globalPatternRatio: no analysis result available');
                 return false;

package/dist/operators/globalPatternRatio.test.js

@@ -6,6 +6,8 @@ jest.mock('../utils/logger', () => ({
         debug: jest.fn(),
         error: jest.fn(),
         info: jest.fn(),
+        trace: jest.fn(),
+        warn: jest.fn()
     },
 }));
 describe('globalPatternRatio', () => {

package/dist/operators/openaiAnalysisHighSeverity.test.js

@@ -7,6 +7,8 @@ jest.mock('../utils/logger', () => ({
         error: jest.fn(),
         debug: jest.fn(),
         info: jest.fn(),
+        trace: jest.fn(),
+        warn: jest.fn()
     },
 }));
 describe('openaiAnalysisHighSeverity', () => {

package/dist/operators/regexMatch.test.js

@@ -5,7 +5,10 @@ const logger_1 = require("../utils/logger");
 jest.mock('../utils/logger', () => ({
     logger: {
         debug: jest.fn(),
-        error: jest.fn()
+        error: jest.fn(),
+        trace: jest.fn(),
+        info: jest.fn(),
+        warn: jest.fn()
     },
 }));
 describe('regexMatch', () => {

package/dist/plugins/xfiPluginAst/facts/functionComplexityFact.js

@@ -83,8 +83,18 @@ exports.functionComplexityFact = {
                 }))
             }, 'Completed complexity analysis');
             const result = {
-                complexities,
-                maxComplexity
+                complexities: complexities.map(c => (Object.assign(Object.assign({}, c), { metrics: {
+                        cyclomaticComplexity: c.complexity,
+                        parameterCount: c.metrics.parameterCount,
+                        returnCount: c.metrics.returnCount,
+                        nestingDepth: c.metrics.nestingDepth,
+                        cognitiveComplexity: c.metrics.cognitiveComplexity
+                    } }))),
+                maxComplexity,
+                maxNestingDepth: Math.max(...complexities.map(c => c.metrics.nestingDepth)),
+                maxParameterCount: Math.max(...complexities.map(c => c.metrics.parameterCount)),
+                maxReturnCount: Math.max(...complexities.map(c => c.metrics.returnCount)),
+                maxCognitiveComplexity: Math.max(...complexities.map(c => c.metrics.cognitiveComplexity))
             };
             if (params === null || params === void 0 ? void 0 : params.resultFact) {
                 logger_1.logger.debug({ resultFact: params.resultFact }, 'Adding complexity results to almanac');
@@ -99,33 +109,62 @@ exports.functionComplexityFact = {
     })
 };
 function analyzeFunctionComplexity(node) {
-    let complexity = 1; // Base complexity
-    // Walk the AST and count:
-    // - Conditional statements (if, else, switch cases)
-    // - Loops (for, while, do-while)
-    // - Logical operators (&&, ||)
-    // - Try/catch blocks
-    function visit(node) {
+    let cyclomaticComplexity = 1;
+    let parameterCount = 0;
+    let returnCount = 0;
+    let maxNestingDepth = 0;
+    let cognitiveComplexity = 0;
+    let currentNestingDepth = 0;
+    // Count parameters
+    const parameterList = node.descendantsOfType('formal_parameters')[0];
+    if (parameterList) {
+        parameterCount = parameterList.namedChildCount;
+    }
+    function visit(node, depth = 0) {
+        currentNestingDepth = depth;
+        maxNestingDepth = Math.max(maxNestingDepth, depth);
         switch (node.type) {
             case 'if_statement':
             case 'switch_case':
+                cyclomaticComplexity++;
+                cognitiveComplexity += depth + 1;
+                break;
             case 'for_statement':
             case 'while_statement':
             case 'do_statement':
+                cyclomaticComplexity++;
+                cognitiveComplexity += depth + 2; // Loops are more complex
+                break;
             case 'try_statement':
-                complexity++;
+                cyclomaticComplexity++;
+                cognitiveComplexity += 1;
                 break;
             case '&&':
             case '||':
-                complexity += 0.5;
+                cyclomaticComplexity += 0.5;
+                cognitiveComplexity += 1;
+                break;
+            case 'return_statement':
+                returnCount++;
                 break;
         }
+        // Visit children with increased depth for control structures
+        const increaseDepthFor = [
+            'if_statement', 'for_statement', 'while_statement',
+            'do_statement', 'try_statement', 'switch_case'
+        ];
         for (let child of node.children || []) {
-            visit(child);
+            visit(child, increaseDepthFor.includes(node.type) ? depth + 1 : depth);
         }
     }
     visit(node);
-    return complexity;
+    return {
+        cyclomaticComplexity,
+        parameterCount,
+        returnCount,
+        nestingDepth: maxNestingDepth,
+        cognitiveComplexity
+    };
 }
 function getFunctionName(node) {
     if (node.type === 'function_declaration') {

package/dist/plugins/xfiPluginReactPatterns/facts/effectCleanupFact.d.ts

@@ -0,0 +1,2 @@
+import { FactDefn } from '../../../types/typeDefs';
+export declare const effectCleanupFact: FactDefn;

package/dist/plugins/xfiPluginReactPatterns/facts/effectCleanupFact.js

@@ -0,0 +1,99 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.effectCleanupFact = void 0;
+const logger_1 = require("../../../utils/logger");
+const astUtils_1 = require("../../../utils/astUtils");
+exports.effectCleanupFact = {
+    name: 'effectCleanup',
+    fn: (params, almanac) => __awaiter(void 0, void 0, void 0, function* () {
+        try {
+            const fileData = yield almanac.factValue('fileData');
+            const { tree } = (0, astUtils_1.generateAst)(fileData);
+            if (!tree)
+                return { issues: [] };
+            const issues = [];
+            function visit(node) {
+                var _a, _b, _c, _d, _e;
+                if (node.type === 'call_expression' &&
+                    ((_b = (_a = node.children) === null || _a === void 0 ? void 0 : _a[0]) === null || _b === void 0 ? void 0 : _b.type) === 'identifier' &&
+                    node.children[0].text === 'useEffect') {
+                    const effectBody = (_e = (_d = (_c = node.children) === null || _c === void 0 ? void 0 : _c[1]) === null || _d === void 0 ? void 0 : _d.children) === null || _e === void 0 ? void 0 : _e[0];
+                    if (!effectBody)
+                        return;
+                    // Check if effect returns a cleanup function
+                    const hasCleanup = hasReturnFunction(effectBody);
+                    // Look for patterns that typically need cleanup
+                    const needsCleanup = checkNeedsCleanup(effectBody);
+                    if (needsCleanup && !hasCleanup) {
+                        issues.push({
+                            type: 'missingCleanup',
+                            line: node.startPosition.row + 1,
+                            message: 'useEffect may need cleanup for subscriptions/listeners/timers'
+                        });
+                    }
+                }
+                for (const child of node.children || []) {
+                    visit(child);
+                }
+            }
+            visit(tree.rootNode);
+            const result = {
+                issues,
+                fileInfo: {
+                    path: fileData.filePath,
+                    issueCount: issues.length
+                }
+            };
+            if (params === null || params === void 0 ? void 0 : params.resultFact) {
+                almanac.addRuntimeFact(params.resultFact, result);
+            }
+            return result;
+        }
+        catch (error) {
+            logger_1.logger.error(`Error in effectCleanup fact: ${error}`);
+            return { issues: [] };
+        }
+    })
+};
+function hasReturnFunction(node) {
+    if (node.type === 'return_statement') {
+        const returnValue = node.children[0];
+        return (returnValue === null || returnValue === void 0 ? void 0 : returnValue.type) === 'function' ||
+            (returnValue === null || returnValue === void 0 ? void 0 : returnValue.type) === 'arrow_function';
+    }
+    for (const child of node.children || []) {
+        if (hasReturnFunction(child))
+            return true;
+    }
+    return false;
+}
+function checkNeedsCleanup(node) {
+    const cleanupPatterns = [
+        'addEventListener',
+        'setTimeout',
+        'setInterval',
+        'subscribe',
+        'observe'
+    ];
+    if (node.type === 'call_expression') {
+        const callee = node.children[0];
+        if ((callee === null || callee === void 0 ? void 0 : callee.type) === 'identifier' &&
+            cleanupPatterns.some(p => callee.text.includes(p))) {
+            return true;
+        }
+    }
+    for (const child of node.children || []) {
+        if (checkNeedsCleanup(child))
+            return true;
+    }
+    return false;
+}

package/dist/plugins/xfiPluginReactPatterns/facts/hookDependencyFact.d.ts

@@ -0,0 +1,2 @@
+import { FactDefn } from '../../../types/typeDefs';
+export declare const hookDependencyFact: FactDefn;

package/dist/plugins/xfiPluginReactPatterns/facts/hookDependencyFact.js

@@ -0,0 +1,102 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hookDependencyFact = void 0;
+const logger_1 = require("../../../utils/logger");
+const astUtils_1 = require("../../../utils/astUtils");
+exports.hookDependencyFact = {
+    name: 'hookDependency',
+    fn: (params, almanac) => __awaiter(void 0, void 0, void 0, function* () {
+        try {
+            const fileData = yield almanac.factValue('fileData');
+            const { tree } = (0, astUtils_1.generateAst)(fileData);
+            if (!tree)
+                return { issues: [] };
+            const issues = [];
+            // Find all useEffect calls
+            function visit(node) {
+                var _a, _b, _c, _d;
+                if (node.type === 'call_expression' &&
+                    ((_b = (_a = node.children) === null || _a === void 0 ? void 0 : _a[0]) === null || _b === void 0 ? void 0 : _b.type) === 'identifier' &&
+                    node.children[0].text === 'useEffect') {
+                    // Get the dependency array argument
+                    const args = node.children.filter((n) => n.type === 'arguments')[0];
+                    const depArray = (_c = args === null || args === void 0 ? void 0 : args.children) === null || _c === void 0 ? void 0 : _c[1]; // Second argument should be dep array
+                    // Check for missing dependency array
+                    if (!depArray) {
+                        issues.push({
+                            type: 'missingDeps',
+                            line: node.startPosition.row + 1,
+                            message: 'useEffect missing dependency array'
+                        });
+                        return;
+                    }
+                    // Check for empty dependency array when effect uses external values
+                    const effectBody = args.children[0];
+                    const externalRefs = findExternalReferences(effectBody);
+                    const deps = ((_d = depArray.children) === null || _d === void 0 ? void 0 : _d.map((n) => n.text)) || [];
+                    const missingDeps = externalRefs.filter(ref => !deps.includes(ref));
+                    if (missingDeps.length > 0) {
+                        issues.push({
+                            type: 'incompleteDeps',
+                            line: node.startPosition.row + 1,
+                            message: `useEffect has missing dependencies: ${missingDeps.join(', ')}`
+                        });
+                    }
+                }
+                for (const child of node.children || []) {
+                    visit(child);
+                }
+            }
+            visit(tree.rootNode);
+            const result = {
+                issues,
+                fileInfo: {
+                    path: fileData.filePath,
+                    issueCount: issues.length
+                }
+            };
+            if (params === null || params === void 0 ? void 0 : params.resultFact) {
+                almanac.addRuntimeFact(params.resultFact, result);
+            }
+            return result;
+        }
+        catch (error) {
+            logger_1.logger.error(`Error in hookDependency fact: ${error}`);
+            return { issues: [] };
+        }
+    })
+};
+function findExternalReferences(node) {
+    const refs = new Set();
+    function visit(node, scope) {
+        if (node.type === 'identifier') {
+            if (!scope.has(node.text)) {
+                refs.add(node.text);
+            }
+        }
+        else if (node.type === 'variable_declaration') {
+            // Add declared variables to scope
+            const declarators = node.children.filter((n) => n.type === 'variable_declarator');
+            declarators.forEach((d) => {
+                var _a;
+                const name = (_a = d.children[0]) === null || _a === void 0 ? void 0 : _a.text;
+                if (name)
+                    scope.add(name);
+            });
+        }
+        for (const child of node.children || []) {
+            visit(child, scope);
+        }
+    }
+    visit(node, new Set());
+    return Array.from(refs);
+}

package/dist/plugins/xfiPluginReactPatterns/index.d.ts

@@ -0,0 +1 @@
+export { plugin } from './xfiPluginReactPatterns';

package/dist/plugins/xfiPluginReactPatterns/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.plugin = void 0;
+var xfiPluginReactPatterns_1 = require("./xfiPluginReactPatterns");
+Object.defineProperty(exports, "plugin", { enumerable: true, get: function () { return xfiPluginReactPatterns_1.plugin; } });

package/dist/plugins/xfiPluginReactPatterns/xfiPluginReactPatterns.d.ts

@@ -0,0 +1,3 @@
+import { XFiPlugin } from '../../types/typeDefs';
+declare const plugin: XFiPlugin;
+export { plugin };

package/dist/plugins/xfiPluginReactPatterns/xfiPluginReactPatterns.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.plugin = void 0;
+const hookDependencyFact_1 = require("./facts/hookDependencyFact");
+const effectCleanupFact_1 = require("./facts/effectCleanupFact");
+const plugin = {
+    name: 'xfiPluginReactPatterns',
+    version: '1.0.0',
+    facts: [hookDependencyFact_1.hookDependencyFact, effectCleanupFact_1.effectCleanupFact],
+    onError: (error) => ({
+        message: `React patterns analysis error: ${error.message}`,
+        level: 'warning',
+        details: error.stack
+    })
+};
+exports.plugin = plugin;

package/dist/plugins/xfiPluginRemoteStringValidator/facts/remoteSubstringValidation.test.js

@@ -16,6 +16,8 @@ jest.mock('../../../utils/logger', () => ({
         debug: jest.fn(),
         error: jest.fn(),
         info: jest.fn(),
+        trace: jest.fn(),
+        warn: jest.fn()
     },
 }));
 describe('remoteSubstringValidation', () => {

package/dist/plugins/xfiPluginRemoteStringValidator/operators/invalidRemoteValidation.test.js

@@ -6,6 +6,8 @@ jest.mock('../../../utils/logger', () => ({
         debug: jest.fn(),
         error: jest.fn(),
         info: jest.fn(),
+        trace: jest.fn(),
+        warn: jest.fn()
     },
 }));
 describe('invalidRemoteValidation', () => {