@atlaskit/eslint-plugin-platform 2.7.1 → 2.8.0

package/dist/esm/rules/import/no-jest-mock-barrel-files/index.js

@@ -0,0 +1,1391 @@
+import _toConsumableArray from "@babel/runtime/helpers/toConsumableArray";
+import _typeof from "@babel/runtime/helpers/typeof";
+import _slicedToArray from "@babel/runtime/helpers/slicedToArray";
+function _createForOfIteratorHelper(r, e) { var t = "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (!t) { if (Array.isArray(r) || (t = _unsupportedIterableToArray(r)) || e && r && "number" == typeof r.length) { t && (r = t); var _n = 0, F = function F() {}; return { s: F, n: function n() { return _n >= r.length ? { done: !0 } : { done: !1, value: r[_n++] }; }, e: function e(r) { throw r; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var o, a = !0, u = !1; return { s: function s() { t = t.call(r); }, n: function n() { var r = t.next(); return a = r.done, r; }, e: function e(r) { u = !0, o = r; }, f: function f() { try { a || null == t.return || t.return(); } finally { if (u) throw o; } } }; }
+function _unsupportedIterableToArray(r, a) { if (r) { if ("string" == typeof r) return _arrayLikeToArray(r, a); var t = {}.toString.call(r).slice(8, -1); return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0; } }
+function _arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length); for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e]; return n; }
+import { dirname, relative } from 'path';
+import * as ts from 'typescript';
+import { hasReExportsFromOtherFiles, parseBarrelExports } from '../shared/barrel-parsing';
+import { findWorkspaceRoot, isRelativeImport, resolveImportPath } from '../shared/file-system';
+import { extractImportPath, findJestRequireMockCalls, isJestMockCall, isJestRequireActual, resolveNewPathForRequireMock } from '../shared/jest-utils';
+import { findPackageInRegistry } from '../shared/package-registry';
+import { findExportForSourceFile, parsePackageExports } from '../shared/package-resolution';
+import { realFileSystem } from '../shared/types';
+
+// Cache per source package name to avoid repeated exports parsing during a single lint run.
+// This is keyed by fs instance to avoid test pollution.
+var sourcePackageExportsMapsByFs = new WeakMap();
+function getSourcePackageExportsMaps(fs) {
+  var map = sourcePackageExportsMapsByFs.get(fs);
+  if (!map) {
+    map = new Map();
+    sourcePackageExportsMapsByFs.set(fs, map);
+  }
+  return map;
+}
+
+/**
+ * Information about a mock factory's preamble (statements before the return)
+ */
+
+/**
+ * Extract identifiers defined by a statement (e.g., variable declarations)
+ * Uses TypeScript AST to find declared identifiers.
+ */
+function extractDefinedIdentifiers(statementText) {
+  var identifiers = new Set();
+  try {
+    // Parse the statement as a mini source file
+    var sourceFile = ts.createSourceFile('temp.ts', statementText, ts.ScriptTarget.Latest, true);
+    var _visit = function visit(node) {
+      if (ts.isVariableStatement(node)) {
+        var _iterator = _createForOfIteratorHelper(node.declarationList.declarations),
+          _step;
+        try {
+          for (_iterator.s(); !(_step = _iterator.n()).done;) {
+            var decl = _step.value;
+            if (ts.isIdentifier(decl.name)) {
+              identifiers.add(decl.name.text);
+            } else if (ts.isObjectBindingPattern(decl.name)) {
+              // Handle destructuring: const { a, b } = ...
+              var _iterator2 = _createForOfIteratorHelper(decl.name.elements),
+                _step2;
+              try {
+                for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+                  var element = _step2.value;
+                  if (ts.isBindingElement(element) && ts.isIdentifier(element.name)) {
+                    identifiers.add(element.name.text);
+                  }
+                }
+              } catch (err) {
+                _iterator2.e(err);
+              } finally {
+                _iterator2.f();
+              }
+            } else if (ts.isArrayBindingPattern(decl.name)) {
+              // Handle array destructuring: const [a, b] = ...
+              var _iterator3 = _createForOfIteratorHelper(decl.name.elements),
+                _step3;
+              try {
+                for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
+                  var _element = _step3.value;
+                  if (ts.isBindingElement(_element) && ts.isIdentifier(_element.name)) {
+                    identifiers.add(_element.name.text);
+                  }
+                }
+              } catch (err) {
+                _iterator3.e(err);
+              } finally {
+                _iterator3.f();
+              }
+            }
+          }
+        } catch (err) {
+          _iterator.e(err);
+        } finally {
+          _iterator.f();
+        }
+      } else if (ts.isFunctionDeclaration(node) && node.name) {
+        identifiers.add(node.name.text);
+      } else if (ts.isClassDeclaration(node) && node.name) {
+        identifiers.add(node.name.text);
+      }
+      ts.forEachChild(node, _visit);
+    };
+    ts.forEachChild(sourceFile, _visit);
+  } catch (_unused) {
+    // Ignore parsing errors
+  }
+  return identifiers;
+}
+
+/**
+ * Find all identifiers used in a given text string.
+ * Uses a simple regex approach to find potential identifier references.
+ */
+function findUsedIdentifiers(text, potentialIdentifiers) {
+  var used = new Set();
+  var _iterator4 = _createForOfIteratorHelper(potentialIdentifiers),
+    _step4;
+  try {
+    for (_iterator4.s(); !(_step4 = _iterator4.n()).done;) {
+      var identifier = _step4.value;
+      // Use word boundary matching to find identifier usage
+      // This matches the identifier as a whole word (not part of another word)
+      var regex = new RegExp("\\b".concat(escapeRegExpForIdentifier(identifier), "\\b"));
+      if (regex.test(text)) {
+        used.add(identifier);
+      }
+    }
+  } catch (err) {
+    _iterator4.e(err);
+  } finally {
+    _iterator4.f();
+  }
+  return used;
+}
+
+/**
+ * Escape special regex characters for identifier matching
+ */
+function escapeRegExpForIdentifier(str) {
+  return str.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+
+/**
+ * Filter preamble statements to only include those whose defined identifiers
+ * are used in the given property texts.
+ */
+function filterPreambleForProperties(preamble, propertyTexts) {
+  if (!preamble.hasPreamble || preamble.statements.length === 0) {
+    return preamble;
+  }
+
+  // Collect all identifiers defined in the preamble
+  var allDefinedIdentifiers = new Set();
+  var _iterator5 = _createForOfIteratorHelper(preamble.statements),
+    _step5;
+  try {
+    for (_iterator5.s(); !(_step5 = _iterator5.n()).done;) {
+      var stmt = _step5.value;
+      var _iterator7 = _createForOfIteratorHelper(stmt.definedIdentifiers),
+        _step7;
+      try {
+        for (_iterator7.s(); !(_step7 = _iterator7.n()).done;) {
+          var id = _step7.value;
+          allDefinedIdentifiers.add(id);
+        }
+      } catch (err) {
+        _iterator7.e(err);
+      } finally {
+        _iterator7.f();
+      }
+    }
+
+    // Find which identifiers are used in the property texts
+  } catch (err) {
+    _iterator5.e(err);
+  } finally {
+    _iterator5.f();
+  }
+  var combinedPropertyText = propertyTexts.join('\n');
+  var usedIdentifiers = findUsedIdentifiers(combinedPropertyText, allDefinedIdentifiers);
+
+  // Filter statements to only those that define used identifiers
+  var filteredStatements = preamble.statements.filter(function (stmt) {
+    // Include statement if any of its defined identifiers are used
+    var _iterator6 = _createForOfIteratorHelper(stmt.definedIdentifiers),
+      _step6;
+    try {
+      for (_iterator6.s(); !(_step6 = _iterator6.n()).done;) {
+        var id = _step6.value;
+        if (usedIdentifiers.has(id)) {
+          return true;
+        }
+      }
+    } catch (err) {
+      _iterator6.e(err);
+    } finally {
+      _iterator6.f();
+    }
+    return false;
+  });
+  if (filteredStatements.length === 0) {
+    return {
+      text: '',
+      hasPreamble: false,
+      statements: []
+    };
+  }
+  return {
+    text: filteredStatements.map(function (s) {
+      return s.text;
+    }).join('\n\t'),
+    hasPreamble: true,
+    statements: filteredStatements
+  };
+}
+
+/**
+ * Convert absolute file path to an import path, handling cross-package resolution.
+ * If the export comes from a cross-package source, returns the package path (e.g., '@atlassian/package-b/utils').
+ * Otherwise, returns a relative path.
+ */
+function getImportPathForSourceFile(_ref) {
+  var _exportInfo$crossPack;
+  var sourceFilePath = _ref.sourceFilePath,
+    basedir = _ref.basedir,
+    originalImportPath = _ref.originalImportPath,
+    exportInfo = _ref.exportInfo,
+    workspaceRoot = _ref.workspaceRoot,
+    fs = _ref.fs;
+  var crossPackageName = exportInfo === null || exportInfo === void 0 || (_exportInfo$crossPack = exportInfo.crossPackageSource) === null || _exportInfo$crossPack === void 0 ? void 0 : _exportInfo$crossPack.packageName;
+  if (crossPackageName) {
+    var sourcePackageExportsMaps = getSourcePackageExportsMaps(fs);
+    var exportsMap = sourcePackageExportsMaps.get(crossPackageName);
+    if (!exportsMap) {
+      var pkgDir = findPackageInRegistry({
+        packageName: crossPackageName,
+        workspaceRoot: workspaceRoot,
+        fs: fs
+      });
+      if (pkgDir) {
+        exportsMap = parsePackageExports({
+          packageDir: pkgDir,
+          fs: fs
+        });
+        sourcePackageExportsMaps.set(crossPackageName, exportsMap);
+      }
+    }
+    var targetExportPath = exportsMap ? findExportForSourceFile({
+      sourceFilePath: sourceFilePath,
+      exportsMap: exportsMap
+    }) : null;
+    return targetExportPath ? crossPackageName + targetExportPath.slice(1) : crossPackageName;
+  }
+  return getRelativeImportPath({
+    basedir: basedir,
+    absolutePath: sourceFilePath,
+    originalImportPath: originalImportPath
+  });
+}
+
+/**
+ * Convert absolute file path back to relative import path
+ */
+function getRelativeImportPath(_ref2) {
+  var basedir = _ref2.basedir,
+    absolutePath = _ref2.absolutePath,
+    originalImportPath = _ref2.originalImportPath;
+  var relativePath = relative(basedir, absolutePath);
+  // Normalize to use forward slashes
+  relativePath = relativePath.replace(/\\/g, '/');
+
+  // Check for extension in original path
+  var extMatch = originalImportPath.match(/\.(js|jsx|ts|tsx|mjs|cjs)$/);
+  var originalExt = extMatch ? extMatch[0] : '';
+
+  // Get extension from the resolved absolute path
+  var targetExtMatch = absolutePath.match(/\.(js|jsx|ts|tsx|mjs|cjs)$/);
+  var targetExt = targetExtMatch ? targetExtMatch[0] : '';
+
+  // Remove file extension from the target path
+  relativePath = relativePath.replace(/\.(ts|tsx|js|jsx|mjs|cjs)$/, '');
+
+  // If original had extension, append it
+  if (originalExt) {
+    // If original was a TypeScript source extension, use the actual target extension
+    if (['.ts', '.tsx'].includes(originalExt) && targetExt) {
+      relativePath += targetExt;
+    } else {
+      relativePath += originalExt;
+    }
+  } else {
+    // Remove /index suffix only if no extension was present
+    if (relativePath.endsWith('/index')) {
+      relativePath = relativePath.slice(0, -6);
+    } else if (relativePath === 'index') {
+      relativePath = '.';
+    }
+  }
+
+  // Ensure it starts with .. or .
+  if (!relativePath.startsWith('.') && !relativePath.startsWith('/')) {
+    relativePath = './' + relativePath;
+  }
+  return relativePath;
+}
+
+/**
+ * Check if a node is an Object.assign call
+ */
+function isObjectAssignCall(node) {
+  if (node.type !== 'CallExpression') {
+    return false;
+  }
+  var callee = node.callee;
+  if (callee.type === 'MemberExpression') {
+    return callee.object.type === 'Identifier' && callee.object.name === 'Object' && callee.property.type === 'Identifier' && callee.property.name === 'assign';
+  }
+  return false;
+}
+
+/**
+ * Extract mock object from Object.assign pattern
+ * Pattern: Object.assign({}, jest.requireActual(...), { mockProps })
+ * Returns the properties object and whether it has requireActual
+ */
+function extractObjectAssignMock(node) {
+  var args = node.arguments;
+
+  // Object.assign typically has at least 2 arguments: target and source(s)
+  // Pattern: Object.assign({}, jest.requireActual(...), { mockProps })
+  // or: Object.assign({}, jest.requireActual(...), { mockProps1 }, { mockProps2 })
+  if (args.length < 2) {
+    return {
+      propertiesObject: null,
+      hasRequireActual: false
+    };
+  }
+  var hasRequireActual = false;
+  var lastObjectExpression = null;
+
+  // Scan through arguments to find jest.requireActual and the last object literal
+  var _iterator8 = _createForOfIteratorHelper(args),
+    _step8;
+  try {
+    for (_iterator8.s(); !(_step8 = _iterator8.n()).done;) {
+      var arg = _step8.value;
+      if (isJestRequireActual(arg)) {
+        hasRequireActual = true;
+      }
+      if (arg.type === 'ObjectExpression') {
+        // Skip empty objects (the first {} in Object.assign({}, ...))
+        if (arg.properties.length > 0) {
+          lastObjectExpression = arg;
+        }
+      }
+    }
+  } catch (err) {
+    _iterator8.e(err);
+  } finally {
+    _iterator8.f();
+  }
+  return {
+    propertiesObject: lastObjectExpression,
+    hasRequireActual: hasRequireActual
+  };
+}
+
+/**
+ * Extract mock object properties from jest.mock call
+ * Returns a map of property name -> { node, text } and whether there's a jest.requireActual spread
+ */
+function extractMockProperties(_ref3) {
+  var sourceCode = _ref3.sourceCode,
+    mockObjectNode = _ref3.mockObjectNode;
+  var properties = new Map();
+  var hasRequireActual = false;
+
+  // Handle Object.assign pattern: Object.assign({}, jest.requireActual(...), { props })
+  if (isObjectAssignCall(mockObjectNode)) {
+    var _extractObjectAssignM = extractObjectAssignMock(mockObjectNode),
+      propertiesObject = _extractObjectAssignM.propertiesObject,
+      objectAssignHasRequireActual = _extractObjectAssignM.hasRequireActual;
+    if (propertiesObject) {
+      // Recursively extract properties from the properties object
+      var result = extractMockProperties({
+        sourceCode: sourceCode,
+        mockObjectNode: propertiesObject
+      });
+      return {
+        properties: result.properties,
+        hasRequireActual: objectAssignHasRequireActual || result.hasRequireActual
+      };
+    }
+    return {
+      properties: properties,
+      hasRequireActual: objectAssignHasRequireActual
+    };
+  }
+  if (mockObjectNode.type === 'ObjectExpression') {
+    var _iterator9 = _createForOfIteratorHelper(mockObjectNode.properties),
+      _step9;
+    try {
+      for (_iterator9.s(); !(_step9 = _iterator9.n()).done;) {
+        var prop = _step9.value;
+        if (prop.type === 'SpreadElement') {
+          // Check if this is ...jest.requireActual(...)
+          if (isJestRequireActual(prop.argument)) {
+            hasRequireActual = true;
+          }
+        } else if (prop.type === 'Property') {
+          var keyName = void 0;
+          if (prop.key.type === 'Identifier') {
+            keyName = prop.key.name;
+          } else if (prop.key.type === 'Literal') {
+            keyName = String(prop.key.value);
+          } else {
+            continue;
+          }
+          var propText = sourceCode.getText(prop);
+          var valueText = sourceCode.getText(prop.value);
+          properties.set(keyName, {
+            node: prop,
+            text: propText,
+            valueText: valueText
+          });
+        }
+      }
+    } catch (err) {
+      _iterator9.e(err);
+    } finally {
+      _iterator9.f();
+    }
+  }
+  return {
+    properties: properties,
+    hasRequireActual: hasRequireActual
+  };
+}
+
+/**
+ * Validate and resolve a barrel file from an import path
+ * Returns null if not a valid relative barrel import
+ */
+export function validateAndResolveBarrelFile(_ref4) {
+  var importPath = _ref4.importPath,
+    basedir = _ref4.basedir,
+    workspaceRoot = _ref4.workspaceRoot,
+    fs = _ref4.fs;
+  if (!isRelativeImport(importPath)) {
+    return null;
+  }
+  var resolvedPath = resolveImportPath({
+    basedir: basedir,
+    importPath: importPath,
+    fs: fs
+  });
+  if (!resolvedPath) {
+    return null;
+  }
+  var exportMap = parseBarrelExports({
+    barrelFilePath: resolvedPath,
+    workspaceRoot: workspaceRoot,
+    fs: fs
+  });
+  if (exportMap.size === 0) {
+    return null;
+  }
+
+  // A file is considered a barrel file if it has re-exports from other files.
+  // This is the semantic check - we don't care about the filename.
+  if (!hasReExportsFromOtherFiles({
+    exportMap: exportMap,
+    sourceFilePath: resolvedPath
+  })) {
+    return null;
+  }
+  return {
+    resolvedPath: resolvedPath,
+    exportMap: exportMap
+  };
+}
+
+/**
+ * Extract the mock implementation object from the jest.mock call
+ */
+function extractMockImplementation(mockImpl) {
+  if (mockImpl.type === 'ArrowFunctionExpression') {
+    if (mockImpl.body.type === 'ObjectExpression') {
+      return mockImpl.body;
+    }
+    // Handle arrow functions that return a call expression directly (e.g., Object.assign)
+    if (mockImpl.body.type === 'CallExpression') {
+      return mockImpl.body;
+    }
+    if (mockImpl.body.type === 'BlockStatement') {
+      var returnStmt = mockImpl.body.body.find(function (s) {
+        return s.type === 'ReturnStatement';
+      });
+      if (returnStmt !== null && returnStmt !== void 0 && returnStmt.argument) {
+        return returnStmt.argument;
+      }
+    }
+  }
+  if (mockImpl.type === 'FunctionExpression' && mockImpl.body.type === 'BlockStatement') {
+    var _returnStmt = mockImpl.body.body.find(function (s) {
+      return s.type === 'ReturnStatement';
+    });
+    if (_returnStmt !== null && _returnStmt !== void 0 && _returnStmt.argument) {
+      return _returnStmt.argument;
+    }
+  }
+  return mockImpl;
+}
+
+/**
+ * Extract the preamble (statements before the return) from a mock factory function.
+ * This captures variable declarations, assignments, etc. that need to be preserved.
+ */
+function extractMockFactoryPreamble(_ref5) {
+  var mockImpl = _ref5.mockImpl,
+    sourceCode = _ref5.sourceCode;
+  var emptyPreamble = {
+    text: '',
+    hasPreamble: false,
+    statements: []
+  };
+
+  // Get the block statement body from the mock factory
+  var blockBody = null;
+  if ((mockImpl.type === 'ArrowFunctionExpression' || mockImpl.type === 'FunctionExpression') && mockImpl.body.type === 'BlockStatement') {
+    blockBody = mockImpl.body.body;
+  }
+  if (!blockBody) {
+    return emptyPreamble;
+  }
+
+  // Find the return statement index
+  var returnIndex = blockBody.findIndex(function (s) {
+    return s.type === 'ReturnStatement';
+  });
+  if (returnIndex <= 0) {
+    // No preamble (return is first statement or not found)
+    return emptyPreamble;
+  }
+
+  // Extract all statements before the return
+  var preambleStatements = blockBody.slice(0, returnIndex);
+  var statementsWithIdentifiers = preambleStatements.map(function (stmt) {
+    var text = sourceCode.getText(stmt);
+    var definedIdentifiers = extractDefinedIdentifiers(text);
+    return {
+      text: text,
+      definedIdentifiers: definedIdentifiers
+    };
+  });
+  var preambleTexts = statementsWithIdentifiers.map(function (s) {
+    return s.text;
+  });
+  return {
+    text: preambleTexts.join('\n\t'),
+    hasPreamble: true,
+    statements: statementsWithIdentifiers
+  };
+}
+
+/**
+ * Rewrite jest.requireActual paths in a text string from the original barrel path to a new path.
+ */
+function rewriteRequireActualPaths(_ref6) {
+  var text = _ref6.text,
+    originalPath = _ref6.originalPath,
+    newPath = _ref6.newPath,
+    quote = _ref6.quote;
+  // Match jest.requireActual('originalPath') or jest.requireActual("originalPath")
+  // Also handle the 'as Object' or 'as any' type assertions
+  var patterns = [
+  // With single quotes
+  new RegExp("jest\\.requireActual\\(\\s*'".concat(escapeRegExp(originalPath), "'\\s*\\)(?:\\s+as\\s+\\w+)?"), 'g'),
+  // With double quotes
+  new RegExp("jest\\.requireActual\\(\\s*\"".concat(escapeRegExp(originalPath), "\"\\s*\\)(?:\\s+as\\s+\\w+)?"), 'g')];
+  var result = text;
+  for (var _i = 0, _patterns = patterns; _i < _patterns.length; _i++) {
+    var pattern = _patterns[_i];
+    result = result.replace(pattern, "jest.requireActual(".concat(quote).concat(newPath).concat(quote, ")"));
+  }
+  return result;
+}
+
+/**
+ * Escape special regex characters in a string
+ */
+function escapeRegExp(str) {
+  return str.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+
+/**
+ * Group mocked properties by their source file
+ */
+function groupPropertiesBySource(_ref7) {
+  var mockProperties = _ref7.mockProperties,
+    exportMap = _ref7.exportMap;
+  var propertiesBySource = new Map();
+  var _iterator0 = _createForOfIteratorHelper(mockProperties),
+    _step0;
+  try {
+    for (_iterator0.s(); !(_step0 = _iterator0.n()).done;) {
+      var _step0$value = _slicedToArray(_step0.value, 1),
+        propName = _step0$value[0];
+      var exportInfo = exportMap.get(propName);
+      if (!exportInfo) {
+        continue;
+      }
+      if (!propertiesBySource.has(exportInfo.path)) {
+        propertiesBySource.set(exportInfo.path, []);
+      }
+      propertiesBySource.get(exportInfo.path).push(propName);
+    }
+  } catch (err) {
+    _iterator0.e(err);
+  } finally {
+    _iterator0.f();
+  }
+  return propertiesBySource;
+}
+
+/**
+ * Determine if we should report a barrel mock violation
+ */
+function shouldReportBarrelMock(_ref8) {
+  var propertiesBySource = _ref8.propertiesBySource,
+    barrelFilePath = _ref8.barrelFilePath;
+  // Report if any mocked property is a re-export (comes from a different file than the barrel)
+  // This catches both:
+  // 1. Properties from multiple source files
+  // 2. Properties from a single source file that isn't the barrel itself
+  var _iterator1 = _createForOfIteratorHelper(propertiesBySource.keys()),
+    _step1;
+  try {
+    for (_iterator1.s(); !(_step1 = _iterator1.n()).done;) {
+      var sourcePath = _step1.value;
+      if (sourcePath !== barrelFilePath) {
+        return true;
+      }
+    }
+  } catch (err) {
+    _iterator1.e(err);
+  } finally {
+    _iterator1.f();
+  }
+  return false;
+}
+
+/**
+ * Generate auto-fix for auto-mock case (no mock implementation)
+ */
+function generateAutoMockFix(_ref9) {
+  var exportMap = _ref9.exportMap,
+    basedir = _ref9.basedir,
+    importPath = _ref9.importPath,
+    quote = _ref9.quote,
+    workspaceRoot = _ref9.workspaceRoot,
+    fs = _ref9.fs;
+  // Group exports by source file, filtering out type-only source files
+  // Also track the ExportInfo for cross-package resolution
+  var sourceFilesWithInfo = new Map();
+  var _iterator10 = _createForOfIteratorHelper(exportMap),
+    _step10;
+  try {
+    for (_iterator10.s(); !(_step10 = _iterator10.n()).done;) {
+      var _step10$value = _slicedToArray(_step10.value, 2),
+        info = _step10$value[1];
+      if (!info.isTypeOnly && !sourceFilesWithInfo.has(info.path)) {
+        sourceFilesWithInfo.set(info.path, info);
+      }
+    }
+  } catch (err) {
+    _iterator10.e(err);
+  } finally {
+    _iterator10.f();
+  }
+  var sourceFileArray = Array.from(sourceFilesWithInfo.entries());
+  return sourceFileArray.map(function (_ref0) {
+    var _ref1 = _slicedToArray(_ref0, 2),
+      sourceFile = _ref1[0],
+      exportInfo = _ref1[1];
+    var mockPath = getImportPathForSourceFile({
+      sourceFilePath: sourceFile,
+      basedir: basedir,
+      originalImportPath: importPath,
+      exportInfo: exportInfo,
+      workspaceRoot: workspaceRoot,
+      fs: fs
+    });
+    return "jest.mock(".concat(quote).concat(mockPath).concat(quote, ")");
+  }).join(';\n');
+}
+
+/**
+ * Normalize a path for comparison (resolve to absolute path)
+ */
+function normalizePathForComparison(_ref10) {
+  var basedir = _ref10.basedir,
+    importPath = _ref10.importPath,
+    fs = _ref10.fs;
+  if (!isRelativeImport(importPath)) {
+    // For non-relative imports, just return as-is for comparison
+    return importPath;
+  }
+  var resolved = resolveImportPath({
+    basedir: basedir,
+    importPath: importPath,
+    fs: fs
+  });
+  return resolved || importPath;
+}
+
+/**
+ * Scan the entire file for all existing jest.mock calls
+ * Returns a map of normalized path -> { node, properties, hasRequireActual }
+ */
+function findAllJestMocksInFile(_ref11) {
+  var context = _ref11.context,
+    basedir = _ref11.basedir,
+    fs = _ref11.fs;
+  var allMocks = new Map();
+  var sourceCode = context.getSourceCode();
+  var ast = sourceCode.ast;
+
+  // Use a visited set to prevent infinite recursion
+  var visited = new Set();
+
+  // Properties to skip to avoid circular references
+  var skipKeys = new Set(['parent', 'loc', 'range', 'tokens', 'comments']);
+  function visitNode(node) {
+    // Prevent revisiting nodes
+    if (visited.has(node)) {
+      return;
+    }
+    visited.add(node);
+    if (node.type === 'CallExpression' && isJestMockCall(node)) {
+      var importPath = extractImportPath(node);
+      if (importPath) {
+        var normalizedPath = normalizePathForComparison({
+          basedir: basedir,
+          importPath: importPath,
+          fs: fs
+        });
+        var mockImpl = node.arguments[1];
+        if (mockImpl) {
+          var mockObjectNode = extractMockImplementation(mockImpl);
+          var _extractMockPropertie = extractMockProperties({
+              sourceCode: sourceCode,
+              mockObjectNode: mockObjectNode
+            }),
+            properties = _extractMockPropertie.properties,
+            hasRequireActual = _extractMockPropertie.hasRequireActual;
+          allMocks.set(normalizedPath, {
+            node: node,
+            importPath: importPath,
+            properties: properties,
+            hasRequireActual: hasRequireActual
+          });
+        }
+      }
+    }
+
+    // Recursively visit child nodes
+    for (var key in node) {
+      if (skipKeys.has(key)) {
+        continue;
+      }
+      var value = node[key];
+      if (value && _typeof(value) === 'object') {
+        if (Array.isArray(value)) {
+          value.forEach(function (child) {
+            if (child && _typeof(child) === 'object' && 'type' in child) {
+              visitNode(child);
+            }
+          });
+        } else if ('type' in value) {
+          visitNode(value);
+        }
+      }
+    }
+  }
+  visitNode(ast);
+  return allMocks;
+}
+
+/**
+ * Merge mock properties from multiple sources for the same file
+ */
+function mergeMockProperties(_ref12) {
+  var existingProperties = _ref12.existingProperties,
+    newProperties = _ref12.newProperties;
+  var merged = new Map(existingProperties);
+  var _iterator11 = _createForOfIteratorHelper(newProperties),
+    _step11;
+  try {
+    for (_iterator11.s(); !(_step11 = _iterator11.n()).done;) {
+      var _step11$value = _slicedToArray(_step11.value, 2),
+        key = _step11$value[0],
+        value = _step11$value[1];
+      merged.set(key, value);
+    }
+  } catch (err) {
+    _iterator11.e(err);
+  } finally {
+    _iterator11.f();
+  }
+  return merged;
+}
+
+/**
+ * Generate mock call text for a specific file with given properties
+ */
+function generateMockCallText(_ref13) {
+  var relativePath = _ref13.relativePath,
+    properties = _ref13.properties,
+    hasRequireActual = _ref13.hasRequireActual,
+    quote = _ref13.quote,
+    exportMap = _ref13.exportMap,
+    sourceFile = _ref13.sourceFile,
+    preamble = _ref13.preamble,
+    originalImportPath = _ref13.originalImportPath;
+  var propNames = Array.from(properties.keys());
+
+  // Separate props by whether they're from default exports
+  var defaultExportProps = [];
+  var namedExportProps = [];
+  var _loop = function _loop() {
+    var prop = _propNames[_i2];
+    var exportInfo = Array.from(exportMap.entries()).find(function (_ref14) {
+      var _ref15 = _slicedToArray(_ref14, 2),
+        exportName = _ref15[0],
+        info = _ref15[1];
+      return exportName === prop && info.path === sourceFile;
+    });
+    if (exportInfo && exportInfo[1].isDefaultExport) {
+      defaultExportProps.push(prop);
+    } else {
+      namedExportProps.push(prop);
+    }
+  };
+  for (var _i2 = 0, _propNames = propNames; _i2 < _propNames.length; _i2++) {
+    _loop();
+  }
+
+  // Collect all property texts for filtering the preamble
+  var allPropertyTexts = [];
+  for (var _i3 = 0, _namedExportProps = namedExportProps; _i3 < _namedExportProps.length; _i3++) {
+    var _properties$get;
+    var prop = _namedExportProps[_i3];
+    var propText = (_properties$get = properties.get(prop)) === null || _properties$get === void 0 ? void 0 : _properties$get.text;
+    if (propText) {
+      allPropertyTexts.push(propText);
+    }
+  }
+  for (var _i4 = 0, _defaultExportProps = defaultExportProps; _i4 < _defaultExportProps.length; _i4++) {
+    var _properties$get2;
+    var _prop = _defaultExportProps[_i4];
+    var _propText = (_properties$get2 = properties.get(_prop)) === null || _properties$get2 === void 0 ? void 0 : _properties$get2.valueText;
+    if (_propText) {
+      allPropertyTexts.push(_propText);
+    }
+  }
+
+  // Filter preamble to only include statements used by this mock's properties
+  var filteredPreamble = preamble ? filterPreambleForProperties(preamble, allPropertyTexts) : undefined;
+
+  // If we have a preamble, we need to use block body syntax with return statement
+  if (filteredPreamble !== null && filteredPreamble !== void 0 && filteredPreamble.hasPreamble) {
+    // Rewrite any jest.requireActual paths in the preamble
+    var preambleText = filteredPreamble.text;
+    if (originalImportPath) {
+      preambleText = rewriteRequireActualPaths({
+        text: preambleText,
+        originalPath: originalImportPath,
+        newPath: relativePath,
+        quote: quote
+      });
+    }
+
+    // Rewrite any jest.requireActual paths in property values
+    var rewrittenMockObjectProps = namedExportProps.map(function (p) {
+      var _properties$get3;
+      var propText = (_properties$get3 = properties.get(p)) === null || _properties$get3 === void 0 ? void 0 : _properties$get3.text;
+      if (propText && originalImportPath) {
+        propText = rewriteRequireActualPaths({
+          text: propText,
+          originalPath: originalImportPath,
+          newPath: relativePath,
+          quote: quote
+        });
+      }
+      return propText;
+    }).filter(function (p) {
+      return !!p;
+    });
+    var mockContentLines = [];
+    if (hasRequireActual) {
+      mockContentLines.push("...jest.requireActual(".concat(quote).concat(relativePath).concat(quote, ")"));
+    }
+    mockContentLines.push.apply(mockContentLines, _toConsumableArray(rewrittenMockObjectProps));
+    var formattedContent = mockContentLines.map(function (line) {
+      return "\t\t".concat(line, ",");
+    }).join('\n');
+    return "jest.mock(".concat(quote).concat(relativePath).concat(quote, ", () => {\n\t").concat(preambleText, "\n\treturn {\n").concat(formattedContent, "\n\t};\n})");
+  }
+
+  // Generate the mock (original logic for simple cases without preamble)
+  var mockCall;
+  if (defaultExportProps.length > 0 && namedExportProps.length === 0) {
+    // All props are from default export
+    if (defaultExportProps.length === 1) {
+      var _properties$get4;
+      // Single default export - use __esModule pattern
+      var mockText = ((_properties$get4 = properties.get(defaultExportProps[0])) === null || _properties$get4 === void 0 ? void 0 : _properties$get4.valueText) || '';
+      mockCall = "jest.mock(".concat(quote).concat(relativePath).concat(quote, ", () => ({\n\t__esModule: true,\n\tdefault: ").concat(mockText, "\n}))");
+    } else {
+      // Multiple props from same default - shouldn't happen, but handle it
+      var mockTexts = defaultExportProps.map(function (p) {
+        var _properties$get5;
+        return (_properties$get5 = properties.get(p)) === null || _properties$get5 === void 0 ? void 0 : _properties$get5.text;
+      }).join(',\n\t');
+      mockCall = "jest.mock(".concat(quote).concat(relativePath).concat(quote, ", () => ({\n\t").concat(mockTexts, "\n}))");
+    }
+  } else if (defaultExportProps.length === 0 && namedExportProps.length > 0) {
+    // All props are named exports
+    var mockObjectProps = namedExportProps.map(function (p) {
+      var _properties$get6;
+      return (_properties$get6 = properties.get(p)) === null || _properties$get6 === void 0 ? void 0 : _properties$get6.text;
+    }).filter(function (p) {
+      return !!p;
+    });
+    var _mockContentLines = [];
+    if (hasRequireActual) {
+      _mockContentLines.push("...jest.requireActual(".concat(quote).concat(relativePath).concat(quote, ")"));
+    }
+    _mockContentLines.push.apply(_mockContentLines, _toConsumableArray(mockObjectProps));
+    if (_mockContentLines.length === 1 && _mockContentLines[0].length < 60) {
+      mockCall = "jest.mock(".concat(quote).concat(relativePath).concat(quote, ", () => ({ ").concat(_mockContentLines[0], " }))");
+    } else {
+      var _formattedContent = _mockContentLines.map(function (line) {
+        return "\t".concat(line, ",");
+      }).join('\n');
+      mockCall = "jest.mock(".concat(quote).concat(relativePath).concat(quote, ", () => ({\n").concat(_formattedContent, "\n}))");
+    }
+  } else {
+    // Mixed: has both default and named exports
+    var defaultMock = defaultExportProps.map(function (p) {
+      var _properties$get7;
+      return (_properties$get7 = properties.get(p)) === null || _properties$get7 === void 0 ? void 0 : _properties$get7.valueText;
+    }).join(', ');
+    var namedMocks = namedExportProps.map(function (p) {
+      var _properties$get8;
+      return (_properties$get8 = properties.get(p)) === null || _properties$get8 === void 0 ? void 0 : _properties$get8.text;
+    }).filter(function (p) {
+      return !!p;
+    });
+    var _mockContentLines2 = ["__esModule: true", "default: ".concat(defaultMock)].concat(_toConsumableArray(namedMocks));
+    if (hasRequireActual) {
+      _mockContentLines2.unshift("...jest.requireActual(".concat(quote).concat(relativePath).concat(quote, ")"));
+    }
+    var _formattedContent2 = _mockContentLines2.map(function (line) {
+      return "\t".concat(line, ",");
+    }).join('\n');
+    mockCall = "jest.mock(".concat(quote).concat(relativePath).concat(quote, ", () => ({\n").concat(_formattedContent2, "\n}))");
+  }
+  return mockCall;
+}
+
+/**
+ * Generate auto-fix for mock with implementation
+ */
+function generateMockImplementationFix(_ref16) {
+  var propertiesBySource = _ref16.propertiesBySource,
+    mockProperties = _ref16.mockProperties,
+    hasRequireActual = _ref16.hasRequireActual,
+    basedir = _ref16.basedir,
+    importPath = _ref16.importPath,
+    quote = _ref16.quote,
+    exportMap = _ref16.exportMap,
+    context = _ref16.context,
+    currentNode = _ref16.currentNode,
+    preamble = _ref16.preamble,
+    workspaceRoot = _ref16.workspaceRoot,
+    fs = _ref16.fs;
+  var sourceFilesToMock = Array.from(propertiesBySource.entries());
+
+  // Find all existing jest.mock calls in the file
+  var allExistingMocks = findAllJestMocksInFile({
+    context: context,
+    basedir: basedir,
+    fs: fs
+  });
+
+  // Track which nodes we need to remove and what mock calls to generate
+  var nodesToRemove = new Set();
+  var mergedMocks = new Map();
+
+  // Always remove the current barrel mock node
+  nodesToRemove.add(currentNode);
+
+  // Process each source file we're creating mocks for
+  var _loop2 = function _loop2() {
+    var _sourceFilesToMock$_i = _slicedToArray(_sourceFilesToMock[_i5], 2),
+      sourceFile = _sourceFilesToMock$_i[0],
+      props = _sourceFilesToMock$_i[1];
+    // Find the ExportInfo for this source file to get cross-package info
+    var exportInfoForSource = Array.from(exportMap.values()).find(function (info) {
+      return info.path === sourceFile;
+    });
+    var mockPath = getImportPathForSourceFile({
+      sourceFilePath: sourceFile,
+      basedir: basedir,
+      originalImportPath: importPath,
+      exportInfo: exportInfoForSource !== null && exportInfoForSource !== void 0 ? exportInfoForSource : null,
+      workspaceRoot: workspaceRoot,
+      fs: fs
+    });
+    var normalizedPath = normalizePathForComparison({
+      basedir: basedir,
+      importPath: mockPath,
+      fs: fs
+    });
+
+    // Get properties for this source file from the barrel mock
+    var newProperties = new Map();
+    var _iterator12 = _createForOfIteratorHelper(props),
+      _step12;
+    try {
+      for (_iterator12.s(); !(_step12 = _iterator12.n()).done;) {
+        var prop = _step12.value;
+        var propInfo = mockProperties.get(prop);
+        if (propInfo) {
+          newProperties.set(prop, propInfo);
+        }
+      }
+
+      // Check if there's already a mock for this path
+    } catch (err) {
+      _iterator12.e(err);
+    } finally {
+      _iterator12.f();
+    }
+    var existingMock = allExistingMocks.get(normalizedPath);
+    if (existingMock && existingMock.node !== currentNode) {
+      // Merge properties from existing mock with new properties
+      var mergedProperties = mergeMockProperties({
+        existingProperties: existingMock.properties,
+        newProperties: newProperties
+      });
+      mergedMocks.set(normalizedPath, {
+        mockPath: mockPath,
+        properties: mergedProperties,
+        hasRequireActual: existingMock.hasRequireActual || hasRequireActual
+      });
+      // Mark the existing mock node for removal
+      nodesToRemove.add(existingMock.node);
+    } else {
+      // No existing mock, just use the new properties
+      // For newly created mocks from barrel file splits, always include jest.requireActual.
+      // This ensures that any properties not explicitly mocked will still be included from the original module.
+      mergedMocks.set(normalizedPath, {
+        mockPath: mockPath,
+        properties: newProperties,
+        hasRequireActual: true
+      });
+    }
+  };
+  for (var _i5 = 0, _sourceFilesToMock = sourceFilesToMock; _i5 < _sourceFilesToMock.length; _i5++) {
+    _loop2();
+  }
+
+  // Generate mock calls for all merged mocks
+  var replacementParts = [];
+  var _iterator13 = _createForOfIteratorHelper(mergedMocks),
+    _step13;
+  try {
+    for (_iterator13.s(); !(_step13 = _iterator13.n()).done;) {
+      var _step13$value = _slicedToArray(_step13.value, 2),
+        mockInfo = _step13$value[1];
+      // Find the source file for this mock path (may be relative or cross-package)
+      // For cross-package paths (starting with @), we don't need to resolve
+      var isCrossPackagePath = mockInfo.mockPath.startsWith('@');
+      var absolutePath = isCrossPackagePath ? null : resolveImportPath({
+        basedir: basedir,
+        importPath: mockInfo.mockPath,
+        fs: fs
+      });
+      if (!isCrossPackagePath && !absolutePath) {
+        continue;
+      }
+      var mockCall = generateMockCallText({
+        relativePath: mockInfo.mockPath,
+        properties: mockInfo.properties,
+        hasRequireActual: mockInfo.hasRequireActual,
+        quote: quote,
+        exportMap: exportMap,
+        sourceFile: absolutePath !== null && absolutePath !== void 0 ? absolutePath : mockInfo.mockPath,
+        preamble: preamble,
+        originalImportPath: importPath
+      });
+      replacementParts.push(mockCall);
+    }
+  } catch (err) {
+    _iterator13.e(err);
+  } finally {
+    _iterator13.f();
+  }
+  var replacementText = replacementParts.join(';\n');
+
+  // Build a map of symbol name -> new mock path for jest.requireMock() rewriting
+  var symbolToNewMockPath = new Map();
+  var _iterator14 = _createForOfIteratorHelper(mergedMocks),
+    _step14;
+  try {
+    for (_iterator14.s(); !(_step14 = _iterator14.n()).done;) {
+      var _step14$value = _slicedToArray(_step14.value, 2),
+        _mockInfo = _step14$value[1];
+      var _iterator16 = _createForOfIteratorHelper(_mockInfo.properties.keys()),
+        _step16;
+      try {
+        for (_iterator16.s(); !(_step16 = _iterator16.n()).done;) {
+          var propName = _step16.value;
+          symbolToNewMockPath.set(propName, _mockInfo.mockPath);
+        }
+      } catch (err) {
+        _iterator16.e(err);
+      } finally {
+        _iterator16.f();
+      }
+    }
+
+    // Create fixes: remove all nodes except the first, replace the first with merged mocks
+  } catch (err) {
+    _iterator14.e(err);
+  } finally {
+    _iterator14.f();
+  }
+  var fixes = [];
+  var sortedNodesToRemove = Array.from(nodesToRemove).sort(function (a, b) {
+    var _a$range$, _a$range, _b$range$, _b$range;
+    return ((_a$range$ = (_a$range = a.range) === null || _a$range === void 0 ? void 0 : _a$range[0]) !== null && _a$range$ !== void 0 ? _a$range$ : 0) - ((_b$range$ = (_b$range = b.range) === null || _b$range === void 0 ? void 0 : _b$range[0]) !== null && _b$range$ !== void 0 ? _b$range$ : 0);
+  });
+  if (sortedNodesToRemove.length > 0) {
+    // Replace the first node with all the merged mocks
+    var firstNode = sortedNodesToRemove[0];
+    fixes.push({
+      range: firstNode.range,
+      text: replacementText
+    });
+
+    // Remove all other nodes (subsequent duplicates)
+    for (var i = 1; i < sortedNodesToRemove.length; i++) {
+      var nodeToRemove = sortedNodesToRemove[i];
+      // Find the statement that contains this node to remove the entire line
+      var sourceCode = context.getSourceCode();
+      var tokenAfter = sourceCode.getTokenAfter(nodeToRemove);
+
+      // Try to remove the entire statement including semicolon and newline
+      var startPos = nodeToRemove.range[0];
+      var endPos = nodeToRemove.range[1];
+
+      // Include trailing semicolon if present
+      if (tokenAfter && tokenAfter.type === 'Punctuator' && tokenAfter.value === ';') {
+        endPos = tokenAfter.range[1];
+      }
+
+      // Include trailing/leading whitespace and newlines
+      var text = sourceCode.getText();
+      while (endPos < text.length && /[\s\n]/.test(text[endPos])) {
+        endPos++;
+      }
+      fixes.push({
+        range: [startPos, endPos],
+        text: ''
+      });
+    }
+  }
+
+  // Fix jest.requireMock() calls that reference the old barrel path.
+  // When we split a jest.mock('./barrel') into jest.mock('./specific-file'),
+  // any jest.requireMock('./barrel') calls also need to be updated.
+  var ast = context.getSourceCode().ast;
+  var normalizedTarget = normalizePathForComparison({
+    basedir: basedir,
+    importPath: importPath,
+    fs: fs
+  });
+  var requireMockCalls = findJestRequireMockCalls({
+    ast: ast,
+    matchPath: function matchPath(candidatePath) {
+      return normalizePathForComparison({
+        basedir: basedir,
+        importPath: candidatePath,
+        fs: fs
+      }) === normalizedTarget;
+    }
+  });
+  var _iterator15 = _createForOfIteratorHelper(requireMockCalls),
+    _step15;
+  try {
+    for (_iterator15.s(); !(_step15 = _iterator15.n()).done;) {
+      var requireMockNode = _step15.value;
+      var requireMockArg = requireMockNode.arguments[0];
+      if (!requireMockArg) {
+        continue;
+      }
+      var newPath = resolveNewPathForRequireMock({
+        requireMockNode: requireMockNode,
+        symbolToNewPath: symbolToNewMockPath
+      });
+      if (newPath) {
+        fixes.push({
+          range: requireMockArg.range,
+          text: "".concat(quote).concat(newPath).concat(quote)
+        });
+      }
+    }
+  } catch (err) {
+    _iterator15.e(err);
+  } finally {
+    _iterator15.f();
+  }
+  return fixes;
+}
+
+/**
+ * Metadata for the ESLint rule
+ */
+var ruleMeta = {
+  type: 'problem',
+  docs: {
+    description: 'Warn when jest.mock is used on a relative import path from a barrel file, and provide an auto-fix to split mocks by source file.',
+    category: 'Best Practices',
+    recommended: false
+  },
+  fixable: 'code',
+  messages: {
+    barrelMock: "jest.mock('{{path}}') is mocking a barrel file. This should be split into separate mocks for each source file to improve performance. Use auto-fix to resolve."
+  }
+};
+
+/**
+ * Factory function to create the ESLint rule with a given file system.
+ * This enables testing with mock file systems.
+ */
+export function createRule(fs) {
+  return {
+    meta: ruleMeta,
+    create: function create(context) {
+      return {
+        CallExpression: function CallExpression(rawNode) {
+          var node = rawNode;
+
+          // Step 1: Validate this is a jest.mock call
+          if (!isJestMockCall(node)) {
+            return;
+          }
+
+          // Step 2: Extract the import path
+          var importPath = extractImportPath(node);
+          if (!importPath) {
+            return;
+          }
+
+          // Step 3: Validate and resolve barrel file
+          var basedir = dirname(context.filename);
+          var workspaceRoot = findWorkspaceRoot({
+            startPath: basedir,
+            fs: fs
+          });
+          var barrelInfo = validateAndResolveBarrelFile({
+            importPath: importPath,
+            basedir: basedir,
+            workspaceRoot: workspaceRoot,
+            fs: fs
+          });
+          if (!barrelInfo) {
+            return;
+          }
+          var exportMap = barrelInfo.exportMap,
+            barrelFilePath = barrelInfo.resolvedPath;
+          var sourceCode = context.getSourceCode();
+          var firstArg = node.arguments[0];
+
+          // Step 4: Handle auto-mock case (no mock implementation)
+          var mockImpl = node.arguments[1];
+          if (!mockImpl) {
+            // Group exports by source file, filtering out type-only source files
+            var sourceFilesWithNonTypeExports = new Set();
+            var _iterator17 = _createForOfIteratorHelper(exportMap),
+              _step17;
+            try {
+              for (_iterator17.s(); !(_step17 = _iterator17.n()).done;) {
+                var _step17$value = _slicedToArray(_step17.value, 2),
+                  info = _step17$value[1];
+                if (!info.isTypeOnly) {
+                  sourceFilesWithNonTypeExports.add(info.path);
+                }
+              }
+            } catch (err) {
+              _iterator17.e(err);
+            } finally {
+              _iterator17.f();
+            }
+            if (sourceFilesWithNonTypeExports.size === 0) {
+              return;
+            }
+            context.report({
+              node: node,
+              messageId: 'barrelMock',
+              data: {
+                path: importPath
+              },
+              fix: function fix(fixer) {
+                var quote = sourceCode.getText(firstArg)[0];
+                var replacement = generateAutoMockFix({
+                  exportMap: exportMap,
+                  basedir: basedir,
+                  importPath: importPath,
+                  quote: quote,
+                  workspaceRoot: workspaceRoot,
+                  fs: fs
+                });
+                return fixer.replaceText(node, replacement);
+              }
+            });
+            return;
+          }
+
+          // Step 5: Extract mock implementation and properties
+          var mockObjectNode = extractMockImplementation(mockImpl);
+          var _extractMockPropertie2 = extractMockProperties({
+              sourceCode: sourceCode,
+              mockObjectNode: mockObjectNode
+            }),
+            mockProperties = _extractMockPropertie2.properties,
+            hasRequireActual = _extractMockPropertie2.hasRequireActual;
+
+          // Extract preamble (variable declarations, etc.) from the mock factory
+          var preamble = extractMockFactoryPreamble({
+            mockImpl: mockImpl,
+            sourceCode: sourceCode
+          });
+          if (mockProperties.size === 0) {
+            return;
+          }
+
+          // Step 6: Group properties by their source files
+          var propertiesBySource = groupPropertiesBySource({
+            mockProperties: mockProperties,
+            exportMap: exportMap
+          });
+
+          // Step 7: Determine if we should report
+          if (!shouldReportBarrelMock({
+            propertiesBySource: propertiesBySource,
+            barrelFilePath: barrelFilePath
+          })) {
+            return;
+          }
+
+          // Step 8: Report with auto-fix
+          context.report({
+            node: node,
+            messageId: 'barrelMock',
+            data: {
+              path: importPath
+            },
+            fix: function fix(_fixer) {
+              var quote = sourceCode.getText(firstArg)[0];
+              var fixes = generateMockImplementationFix({
+                propertiesBySource: propertiesBySource,
+                mockProperties: mockProperties,
+                hasRequireActual: hasRequireActual,
+                basedir: basedir,
+                importPath: importPath,
+                quote: quote,
+                exportMap: exportMap,
+                context: context,
+                currentNode: node,
+                preamble: preamble,
+                workspaceRoot: workspaceRoot,
+                fs: fs
+              });
+              return fixes;
+            }
+          });
+        }
+      };
+    }
+  };
+}
+var rule = createRule(realFileSystem);
+export default rule;