@atlaskit/eslint-plugin-platform 2.7.2 → 2.9.0

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

@@ -0,0 +1,1650 @@
+import _typeof from "@babel/runtime/helpers/typeof";
+import _slicedToArray from "@babel/runtime/helpers/slicedToArray";
+import _toConsumableArray from "@babel/runtime/helpers/toConsumableArray";
+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 } from 'path';
+import * as ts from 'typescript';
+import { hasReExportsFromOtherFiles, parseBarrelExports } from '../shared/barrel-parsing';
+import { DEFAULT_TARGET_FOLDERS, findWorkspaceRoot, isRelativeImport, readFileContent, resolveImportPath } from '../shared/file-system';
+import { extractImportPath, findJestRequireActualCalls, findJestRequireMockCalls, isJestMockCall, isJestRequireActual, resolveNewPathForRequireMock } from '../shared/jest-utils';
+import { findPackageInRegistry, isPackageInApplyToImportsFrom } from '../shared/package-registry';
+import { findExportForSourceFile, parsePackageExports } from '../shared/package-resolution';
+import { realFileSystem } from '../shared/types';
+
+/**
+ * Options for the no-barrel-entry-jest-mock rule.
+ */
+
+/**
+ * Result of tracing a symbol through barrel files to its source.
+ */
+
+/**
+ * Grouped mock properties by their target export path.
+ */
+
+/**
+ * Trace the re-export chain for a symbol from a barrel file.
+ * Returns an array of file paths representing the chain from the barrel to the source.
+ * For example: [barrel.ts, intermediate.ts, source.ts]
+ */
+function traceReExportChain(_ref) {
+  var barrelFilePath = _ref.barrelFilePath,
+    symbolName = _ref.symbolName,
+    fs = _ref.fs,
+    _ref$visited = _ref.visited,
+    visited = _ref$visited === void 0 ? new Set() : _ref$visited;
+  if (visited.has(barrelFilePath)) {
+    return [];
+  }
+  visited.add(barrelFilePath);
+  var content = readFileContent({
+    filePath: barrelFilePath,
+    fs: fs
+  });
+  if (!content) {
+    return [barrelFilePath];
+  }
+  var sourceFile;
+  try {
+    sourceFile = ts.createSourceFile(barrelFilePath, content, ts.ScriptTarget.Latest, true);
+  } catch (_unused) {
+    return [barrelFilePath];
+  }
+  var barrelDir = dirname(barrelFilePath);
+  var _iterator = _createForOfIteratorHelper(sourceFile.statements),
+    _step;
+  try {
+    for (_iterator.s(); !(_step = _iterator.n()).done;) {
+      var statement = _step.value;
+      if (!ts.isExportDeclaration(statement) || !statement.moduleSpecifier) {
+        continue;
+      }
+      if (!ts.isStringLiteral(statement.moduleSpecifier)) {
+        continue;
+      }
+      var modulePath = statement.moduleSpecifier.text;
+      if (!isRelativeImport(modulePath)) {
+        continue;
+      }
+
+      // Check if this export statement includes our symbol
+      var includesSymbol = false;
+      if (statement.exportClause) {
+        if (ts.isNamedExports(statement.exportClause)) {
+          var _iterator2 = _createForOfIteratorHelper(statement.exportClause.elements),
+            _step2;
+          try {
+            for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+              var element = _step2.value;
+              var exportedName = element.name.text;
+              if (exportedName === symbolName) {
+                includesSymbol = true;
+                break;
+              }
+            }
+          } catch (err) {
+            _iterator2.e(err);
+          } finally {
+            _iterator2.f();
+          }
+        }
+      } else {
+        // Star export - might include the symbol
+        includesSymbol = true;
+      }
+      if (includesSymbol) {
+        var resolvedSource = resolveImportPath({
+          basedir: barrelDir,
+          importPath: modulePath,
+          fs: fs
+        });
+        if (resolvedSource) {
+          // Recursively trace from the resolved source
+          var restOfChain = traceReExportChain({
+            barrelFilePath: resolvedSource,
+            symbolName: symbolName,
+            fs: fs,
+            visited: visited
+          });
+          return [barrelFilePath].concat(_toConsumableArray(restOfChain));
+        }
+      }
+    }
+
+    // Symbol is defined in this file (not re-exported)
+  } catch (err) {
+    _iterator.e(err);
+  } finally {
+    _iterator.f();
+  }
+  return [barrelFilePath];
+}
+
+/**
+ * Find a package.json export that can provide a given symbol.
+ *
+ * This function traces the re-export chain from the current barrel to the symbol's source,
+ * and returns an export if its entry file is on that chain (i.e., it's an intermediate barrel
+ * that the main barrel imports from for this symbol).
+ *
+ * This prevents suggesting unrelated barrel files that happen to re-export the same symbol
+ * through a different path.
+ */
+function findExportForSymbol(_ref2) {
+  var symbolName = _ref2.symbolName,
+    symbolSourcePath = _ref2.symbolSourcePath,
+    exportsMap = _ref2.exportsMap,
+    currentExportPath = _ref2.currentExportPath,
+    fs = _ref2.fs;
+  var currentEntryFilePath = exportsMap.get(currentExportPath);
+  if (!currentEntryFilePath) {
+    return null;
+  }
+
+  // Trace the re-export chain from the current barrel to the source
+  var reExportChain = traceReExportChain({
+    barrelFilePath: currentEntryFilePath,
+    symbolName: symbolName,
+    fs: fs
+  });
+
+  // Convert chain to a Set for O(1) lookup
+  var chainSet = new Set(reExportChain);
+
+  // Check each package.json export entry (except the current one)
+  var _iterator3 = _createForOfIteratorHelper(exportsMap),
+    _step3;
+  try {
+    for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
+      var _step3$value = _slicedToArray(_step3.value, 2),
+        exportPath = _step3$value[0],
+        entryFilePath = _step3$value[1];
+      if (exportPath === currentExportPath) {
+        continue;
+      }
+
+      // Skip exports that resolve to the same file as the current export path
+      if (entryFilePath === currentEntryFilePath) {
+        continue;
+      }
+
+      // Only return this export if its entry file is on the re-export chain
+      // (meaning it's an intermediate barrel the main barrel imports from for this symbol)
+      // or if it directly points to the source file
+      if (chainSet.has(entryFilePath) || entryFilePath === symbolSourcePath) {
+        // Verify the symbol is actually exported from this entry file
+        var entryExports = parseBarrelExports({
+          barrelFilePath: entryFilePath,
+          depth: 0,
+          fs: fs
+        });
+        if (entryExports.has(symbolName)) {
+          return exportPath;
+        }
+      }
+    }
+  } catch (err) {
+    _iterator3.e(err);
+  } finally {
+    _iterator3.f();
+  }
+  return null;
+}
+
+/**
+ * Preamble statement extracted from a mock factory function.
+ */
+
+/**
+ * Collect all identifier names used in a node (recursively).
+ * Avoids circular references by skipping parent-related properties.
+ */
+function collectUsedIdentifiers(_ref3) {
+  var node = _ref3.node;
+  var identifiers = new Set();
+  var visited = new WeakSet();
+
+  // Properties to skip to avoid circular references
+  var skipProperties = new Set(['parent', 'tokens', 'comments', 'loc', 'range']);
+  function traverse(n) {
+    if (visited.has(n)) {
+      return;
+    }
+    visited.add(n);
+    if (n.type === 'Identifier') {
+      identifiers.add(n.name);
+    }
+    for (var _i = 0, _Object$keys = Object.keys(n); _i < _Object$keys.length; _i++) {
+      var key = _Object$keys[_i];
+      if (skipProperties.has(key)) {
+        continue;
+      }
+      var child = n[key];
+      if (child && _typeof(child) === 'object') {
+        if (Array.isArray(child)) {
+          var _iterator4 = _createForOfIteratorHelper(child),
+            _step4;
+          try {
+            for (_iterator4.s(); !(_step4 = _iterator4.n()).done;) {
+              var item = _step4.value;
+              if (item && _typeof(item) === 'object' && 'type' in item) {
+                traverse(item);
+              }
+            }
+          } catch (err) {
+            _iterator4.e(err);
+          } finally {
+            _iterator4.f();
+          }
+        } else if ('type' in child) {
+          traverse(child);
+        }
+      }
+    }
+  }
+  traverse(node);
+  return identifiers;
+}
+
+/**
+ * Extract preamble statements (variable declarations) from a block body.
+ */
+function extractPreambleStatements(_ref4) {
+  var mockImpl = _ref4.mockImpl,
+    sourceCode = _ref4.sourceCode;
+  var preamble = [];
+  var body = null;
+  if (mockImpl.type === 'ArrowFunctionExpression' && mockImpl.body.type === 'BlockStatement') {
+    body = mockImpl.body.body;
+  } else if (mockImpl.type === 'FunctionExpression' && mockImpl.body.type === 'BlockStatement') {
+    body = mockImpl.body.body;
+  }
+  if (!body) {
+    return preamble;
+  }
+  var _iterator5 = _createForOfIteratorHelper(body),
+    _step5;
+  try {
+    for (_iterator5.s(); !(_step5 = _iterator5.n()).done;) {
+      var stmt = _step5.value;
+      if (stmt.type === 'ReturnStatement') {
+        break; // Stop at return
+      }
+      if (stmt.type === 'VariableDeclaration') {
+        var declaredNames = [];
+        var usedIdentifiers = new Set();
+        var _iterator6 = _createForOfIteratorHelper(stmt.declarations),
+          _step6;
+        try {
+          for (_iterator6.s(); !(_step6 = _iterator6.n()).done;) {
+            var decl = _step6.value;
+            if (decl.id.type === 'Identifier') {
+              declaredNames.push(decl.id.name);
+            }
+            if (decl.init) {
+              var used = collectUsedIdentifiers({
+                node: decl.init
+              });
+              var _iterator7 = _createForOfIteratorHelper(used),
+                _step7;
+              try {
+                for (_iterator7.s(); !(_step7 = _iterator7.n()).done;) {
+                  var id = _step7.value;
+                  usedIdentifiers.add(id);
+                }
+              } catch (err) {
+                _iterator7.e(err);
+              } finally {
+                _iterator7.f();
+              }
+            }
+          }
+
+          // Remove declared names from used identifiers
+        } catch (err) {
+          _iterator6.e(err);
+        } finally {
+          _iterator6.f();
+        }
+        for (var _i2 = 0, _declaredNames = declaredNames; _i2 < _declaredNames.length; _i2++) {
+          var name = _declaredNames[_i2];
+          usedIdentifiers.delete(name);
+        }
+        preamble.push({
+          declaredNames: declaredNames,
+          text: sourceCode.getText(stmt),
+          usedIdentifiers: usedIdentifiers
+        });
+      }
+    }
+  } catch (err) {
+    _iterator5.e(err);
+  } finally {
+    _iterator5.f();
+  }
+  return preamble;
+}
+
+/**
+ * Determine which preamble statements are needed for a set of property texts.
+ * Returns the preamble statements in order, including any transitively needed ones.
+ */
+function getNeededPreamble(_ref5) {
+  var propertyTexts = _ref5.propertyTexts,
+    allPreamble = _ref5.allPreamble;
+  // Collect all identifiers used in the property texts
+  var neededIdentifiers = new Set();
+  var _iterator8 = _createForOfIteratorHelper(propertyTexts),
+    _step8;
+  try {
+    for (_iterator8.s(); !(_step8 = _iterator8.n()).done;) {
+      var text = _step8.value;
+      // Simple regex to find identifiers in the text
+      // This is a basic approach; handles most common cases
+      var identifierPattern = /\b([a-zA-Z_$][a-zA-Z0-9_$]*)\b/g;
+      var match = void 0;
+      while ((match = identifierPattern.exec(text)) !== null) {
+        neededIdentifiers.add(match[1]);
+      }
+    }
+
+    // Build dependency graph and find needed preamble
+  } catch (err) {
+    _iterator8.e(err);
+  } finally {
+    _iterator8.f();
+  }
+  var neededPreamble = [];
+  var includedNames = new Set();
+  var changed = true;
+  while (changed) {
+    changed = false;
+    var _iterator9 = _createForOfIteratorHelper(allPreamble),
+      _step9;
+    try {
+      for (_iterator9.s(); !(_step9 = _iterator9.n()).done;) {
+        var stmt = _step9.value;
+        // Check if any declared name is needed
+        var isNeeded = stmt.declaredNames.some(function (name) {
+          return neededIdentifiers.has(name);
+        });
+        var alreadyIncluded = stmt.declaredNames.some(function (name) {
+          return includedNames.has(name);
+        });
+        if (isNeeded && !alreadyIncluded) {
+          neededPreamble.push(stmt);
+          var _iterator0 = _createForOfIteratorHelper(stmt.declaredNames),
+            _step0;
+          try {
+            for (_iterator0.s(); !(_step0 = _iterator0.n()).done;) {
+              var name = _step0.value;
+              includedNames.add(name);
+            }
+            // Add any identifiers this statement uses to needed set
+          } catch (err) {
+            _iterator0.e(err);
+          } finally {
+            _iterator0.f();
+          }
+          var _iterator1 = _createForOfIteratorHelper(stmt.usedIdentifiers),
+            _step1;
+          try {
+            for (_iterator1.s(); !(_step1 = _iterator1.n()).done;) {
+              var id = _step1.value;
+              if (!neededIdentifiers.has(id)) {
+                neededIdentifiers.add(id);
+                changed = true;
+              }
+            }
+          } catch (err) {
+            _iterator1.e(err);
+          } finally {
+            _iterator1.f();
+          }
+        }
+      }
+    } catch (err) {
+      _iterator9.e(err);
+    } finally {
+      _iterator9.f();
+    }
+  }
+
+  // Return in original order
+  return allPreamble.filter(function (stmt) {
+    return neededPreamble.includes(stmt);
+  });
+}
+
+/**
+ * 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(_ref6) {
+  var sourceCode = _ref6.sourceCode,
+    mockObjectNode = _ref6.mockObjectNode;
+  var properties = new Map();
+  var hasRequireActual = false;
+  if (mockObjectNode.type === 'ObjectExpression') {
+    var _iterator10 = _createForOfIteratorHelper(mockObjectNode.properties),
+      _step10;
+    try {
+      for (_iterator10.s(); !(_step10 = _iterator10.n()).done;) {
+        var prop = _step10.value;
+        if (prop.type === 'SpreadElement') {
+          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);
+          properties.set(keyName, {
+            node: prop,
+            text: propText
+          });
+        }
+      }
+    } catch (err) {
+      _iterator10.e(err);
+    } finally {
+      _iterator10.f();
+    }
+  }
+  return {
+    properties: properties,
+    hasRequireActual: hasRequireActual
+  };
+}
+
+/**
+ * Information about an existing jest.mock call in the file
+ */
+
+/**
+ * Find all jest.mock calls in the current file
+ */
+function findAllJestMocksInFile(_ref7) {
+  var context = _ref7.context;
+  var allMocks = new Map();
+  var sourceCode = context.getSourceCode();
+  var ast = sourceCode.ast;
+
+  // Use a visited set to prevent infinite recursion
+  var visited = new WeakSet();
+
+  // 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 mockImpl = node.arguments[1];
+        if (mockImpl) {
+          var mockObjectNode = extractMockImplementation({
+            mockImpl: mockImpl
+          });
+          var _extractMockPropertie = extractMockProperties({
+              sourceCode: sourceCode,
+              mockObjectNode: mockObjectNode
+            }),
+            properties = _extractMockPropertie.properties,
+            hasRequireActual = _extractMockPropertie.hasRequireActual;
+          allMocks.set(importPath, {
+            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)) {
+          var _iterator11 = _createForOfIteratorHelper(value),
+            _step11;
+          try {
+            for (_iterator11.s(); !(_step11 = _iterator11.n()).done;) {
+              var child = _step11.value;
+              if (child && _typeof(child) === 'object' && 'type' in child) {
+                visitNode(child);
+              }
+            }
+          } catch (err) {
+            _iterator11.e(err);
+          } finally {
+            _iterator11.f();
+          }
+        } else if ('type' in value) {
+          visitNode(value);
+        }
+      }
+    }
+  }
+  visitNode(ast);
+  return allMocks;
+}
+
+/**
+ * Merge mock properties from multiple sources for the same file
+ */
+function mergeMockProperties(_ref8) {
+  var existingProperties = _ref8.existingProperties,
+    newProperties = _ref8.newProperties;
+  var merged = new Map(existingProperties);
+  var _iterator12 = _createForOfIteratorHelper(newProperties),
+    _step12;
+  try {
+    for (_iterator12.s(); !(_step12 = _iterator12.n()).done;) {
+      var _step12$value = _slicedToArray(_step12.value, 2),
+        key = _step12$value[0],
+        value = _step12$value[1];
+      merged.set(key, value);
+    }
+  } catch (err) {
+    _iterator12.e(err);
+  } finally {
+    _iterator12.f();
+  }
+  return merged;
+}
+
+/**
+ * Check if a node is an Object.assign call
+ */
+function isObjectAssignCall(_ref9) {
+  var node = _ref9.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 the object expression containing mock properties from an Object.assign call.
+ * Pattern: Object.assign({}, jest.requireActual(...), { props... })
+ * Returns the last ObjectExpression argument, or null if not found.
+ */
+function extractObjectFromAssign(_ref0) {
+  var callExpr = _ref0.callExpr;
+  // Look for ObjectExpression arguments that are not the target (first arg)
+  // The pattern is typically: Object.assign({}, jest.requireActual(...), { actual props })
+  // We want the last ObjectExpression that contains the actual mock properties
+  for (var i = callExpr.arguments.length - 1; i >= 0; i--) {
+    var arg = callExpr.arguments[i];
+    if (arg.type === 'ObjectExpression' && arg.properties.length > 0) {
+      return arg;
+    }
+  }
+  return null;
+}
+
+/**
+ * Extract the mock implementation object from the jest.mock call.
+ * Handles arrow functions, function expressions, and Object.assign patterns.
+ */
+function extractMockImplementation(_ref1) {
+  var mockImpl = _ref1.mockImpl;
+  // Helper to unwrap Object.assign if present
+  var unwrapObjectAssign = function unwrapObjectAssign(node) {
+    if (node.type === 'CallExpression' && isObjectAssignCall({
+      node: node
+    })) {
+      var extracted = extractObjectFromAssign({
+        callExpr: node
+      });
+      if (extracted) {
+        return extracted;
+      }
+    }
+    return node;
+  };
+  if (mockImpl.type === 'ArrowFunctionExpression') {
+    if (mockImpl.body.type === 'ObjectExpression') {
+      return mockImpl.body;
+    }
+    // Handle arrow function returning Object.assign
+    if (mockImpl.body.type === 'CallExpression' && isObjectAssignCall({
+      node: mockImpl.body
+    })) {
+      return unwrapObjectAssign(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 unwrapObjectAssign(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 unwrapObjectAssign(_returnStmt.argument);
+    }
+  }
+  return mockImpl;
+}
+
+/**
+ * Trace mocked symbols to their source files and group by package.json exports.
+ */
+function traceSymbolsToExports(_ref10) {
+  var symbolNames = _ref10.symbolNames,
+    exportMap = _ref10.exportMap,
+    exportsMap = _ref10.exportsMap,
+    currentExportPath = _ref10.currentExportPath,
+    fs = _ref10.fs;
+  var groupedByExport = new Map();
+  var crossPackageGroups = new Map();
+  var unmappedSymbols = [];
+  var _iterator13 = _createForOfIteratorHelper(symbolNames),
+    _step13;
+  try {
+    for (_iterator13.s(); !(_step13 = _iterator13.n()).done;) {
+      var _findExportForSourceF, _findExportForSourceF2;
+      var symbolName = _step13.value;
+      var exportInfo = exportMap.get(symbolName);
+      if (!exportInfo) {
+        unmappedSymbols.push(symbolName);
+        continue;
+      }
+
+      // Check for cross-package source first
+      if (exportInfo.crossPackageSource) {
+        var key = "".concat(exportInfo.crossPackageSource.packageName).concat(exportInfo.crossPackageSource.exportPath === '.' ? '' : exportInfo.crossPackageSource.exportPath.slice(1));
+        if (!crossPackageGroups.has(key)) {
+          crossPackageGroups.set(key, []);
+        }
+        crossPackageGroups.get(key).push({
+          symbolName: symbolName,
+          originalName: exportInfo.originalName,
+          sourceFilePath: exportInfo.path,
+          isTypeOnly: exportInfo.isTypeOnly,
+          crossPackageSource: exportInfo.crossPackageSource
+        });
+        continue;
+      }
+
+      // First try to find an export that directly exposes the source file
+      var targetExportPath = (_findExportForSourceF = (_findExportForSourceF2 = findExportForSourceFile({
+        sourceFilePath: exportInfo.path,
+        exportsMap: exportsMap
+      })) === null || _findExportForSourceF2 === void 0 ? void 0 : _findExportForSourceF2.exportPath) !== null && _findExportForSourceF !== void 0 ? _findExportForSourceF : null;
+
+      // If no direct match, check which export can provide this symbol
+      // (handles nested barrels where the symbol is re-exported through intermediate files)
+      if (!targetExportPath) {
+        targetExportPath = findExportForSymbol({
+          symbolName: symbolName,
+          symbolSourcePath: exportInfo.path,
+          exportsMap: exportsMap,
+          currentExportPath: currentExportPath,
+          fs: fs
+        });
+      }
+      if (targetExportPath && targetExportPath !== currentExportPath) {
+        if (!groupedByExport.has(targetExportPath)) {
+          groupedByExport.set(targetExportPath, []);
+        }
+        groupedByExport.get(targetExportPath).push({
+          symbolName: symbolName,
+          originalName: exportInfo.originalName,
+          sourceFilePath: exportInfo.path,
+          isTypeOnly: exportInfo.isTypeOnly
+        });
+      } else {
+        unmappedSymbols.push(symbolName);
+      }
+    }
+  } catch (err) {
+    _iterator13.e(err);
+  } finally {
+    _iterator13.f();
+  }
+  return {
+    groupedByExport: groupedByExport,
+    crossPackageGroups: crossPackageGroups,
+    unmappedSymbols: unmappedSymbols
+  };
+}
+
+/**
+ * Replace the property key in property text when the export is aliased.
+ * For example, if the original text is "renamedFunction: jest.fn()" and
+ * the original name is "originalFunction", returns "originalFunction: jest.fn()".
+ */
+function replacePropertyKey(_ref11) {
+  var propText = _ref11.propText,
+    mockName = _ref11.mockName,
+    originalName = _ref11.originalName;
+  // Match the property key at the start (handles both quoted and unquoted keys)
+  var keyPattern = new RegExp("^(['\"]?)".concat(escapeRegExp(mockName), "\\1\\s*:"));
+  return propText.replace(keyPattern, "".concat(originalName, ":"));
+}
+
+/**
+ * Escape special regex characters in a string.
+ */
+function escapeRegExp(str) {
+  return str.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+
+/** Mock object keys that are module interop metadata, not package exports. */
+var ESM_INTEROP_MOCK_KEYS = new Set(['__esModule']);
+
+/**
+ * If a preamble line is `const|let actual = jest.requireActual('<barrel>')`, rewrite the specifier to
+ * `targetImportPathForThisMock` when every `binding.<prop>` read in this split mock's implementation
+ * resolves to that same path via `symbolToNewImportPath`. Otherwise leave unchanged (e.g. mixed paths
+ * still need the barrel module).
+ */
+function rewritePreambleLineBarrelRequireActual(_ref12) {
+  var lineText = _ref12.lineText,
+    oldBarrelPath = _ref12.oldBarrelPath,
+    targetImportPathForThisMock = _ref12.targetImportPathForThisMock,
+    mockImplementationTextForGroup = _ref12.mockImplementationTextForGroup,
+    symbolToNewImportPath = _ref12.symbolToNewImportPath;
+  var requireActualRe = /jest\.requireActual(?:<[^>]*>)?\((['"])([^'"]+)\1\)/;
+  var requireMatch = requireActualRe.exec(lineText);
+  if (!requireMatch || requireMatch[2] !== oldBarrelPath) {
+    return lineText;
+  }
+  var quote = requireMatch[1];
+  var bindingMatch = /^\s*(?:const|let)\s+(\w+)\s*=/m.exec(lineText);
+  if (!bindingMatch) {
+    return lineText;
+  }
+  var binding = bindingMatch[1];
+  var propAccessRe = new RegExp("\\b".concat(escapeRegExp(binding), "\\.(\\w+)"), 'g');
+  var accessedProps = new Set();
+  var propMatch;
+  while ((propMatch = propAccessRe.exec(mockImplementationTextForGroup)) !== null) {
+    accessedProps.add(propMatch[1]);
+  }
+  if (accessedProps.size === 0) {
+    return lineText;
+  }
+  var resolvedPaths = [];
+  var _iterator14 = _createForOfIteratorHelper(accessedProps),
+    _step14;
+  try {
+    for (_iterator14.s(); !(_step14 = _iterator14.n()).done;) {
+      var prop = _step14.value;
+      var mapped = symbolToNewImportPath.get(prop);
+      if (mapped) {
+        resolvedPaths.push(mapped);
+      }
+    }
+  } catch (err) {
+    _iterator14.e(err);
+  } finally {
+    _iterator14.f();
+  }
+  if (resolvedPaths.length === 0) {
+    return lineText;
+  }
+  var uniquePaths = new Set(resolvedPaths);
+  if (uniquePaths.size !== 1 || !uniquePaths.has(targetImportPathForThisMock)) {
+    return lineText;
+  }
+  return lineText.replace("jest.requireActual(".concat(quote).concat(oldBarrelPath).concat(quote, ")"), "jest.requireActual(".concat(quote).concat(targetImportPathForThisMock).concat(quote, ")"));
+}
+
+/**
+ * Generate fix text for multiple jest.mock calls
+ */
+function generateMockFixes(_ref13) {
+  var groups = _ref13.groups,
+    crossPackageGroups = _ref13.crossPackageGroups,
+    packageName = _ref13.packageName,
+    mockProperties = _ref13.mockProperties,
+    quote = _ref13.quote,
+    preambleStatements = _ref13.preambleStatements,
+    propagateEsModuleFromOriginalMock = _ref13.propagateEsModuleFromOriginalMock,
+    oldBarrelImportPath = _ref13.oldBarrelImportPath,
+    symbolToNewImportPath = _ref13.symbolToNewImportPath;
+  var mockCalls = [];
+
+  // Helper to generate a single mock call
+  var generateMockCall = function generateMockCall(group, fullImportPath) {
+    var propTexts = [];
+    propTexts.push("...jest.requireActual(".concat(quote).concat(fullImportPath).concat(quote, ")"));
+
+    // Add __esModule: true when mocking default exports, or when the original mock already used __esModule (apply to every split).
+    if (group.hasDefaultExport || propagateEsModuleFromOriginalMock) {
+      propTexts.push('__esModule: true');
+    }
+    var _iterator15 = _createForOfIteratorHelper(group.propertyNames),
+      _step15;
+    try {
+      for (_iterator15.s(); !(_step15 = _iterator15.n()).done;) {
+        var propName = _step15.value;
+        // First try to get from group's propertyTexts (used for merged mocks)
+        var groupPropText = group.propertyTexts.get(propName);
+        if (groupPropText) {
+          // Check if this property needs to be renamed (aliased export)
+          var originalName = group.nameMapping.get(propName);
+          if (originalName && originalName !== propName) {
+            var renamedText = replacePropertyKey({
+              propText: groupPropText,
+              mockName: propName,
+              originalName: originalName
+            });
+            propTexts.push(renamedText);
+          } else {
+            propTexts.push(groupPropText);
+          }
+        } else {
+          // Fallback to mockProperties (shouldn't happen with properly constructed groups)
+          var propInfo = mockProperties.get(propName);
+          if (propInfo) {
+            var _originalName = group.nameMapping.get(propName);
+            if (_originalName && _originalName !== propName) {
+              var _renamedText = replacePropertyKey({
+                propText: propInfo.text,
+                mockName: propName,
+                originalName: _originalName
+              });
+              propTexts.push(_renamedText);
+            } else {
+              propTexts.push(propInfo.text);
+            }
+          }
+        }
+      }
+    } catch (err) {
+      _iterator15.e(err);
+    } finally {
+      _iterator15.f();
+    }
+    var combinedGroupImplText = group.propertyNames.map(function (name) {
+      var _ref14, _group$propertyTexts$, _mockProperties$get;
+      return (_ref14 = (_group$propertyTexts$ = group.propertyTexts.get(name)) !== null && _group$propertyTexts$ !== void 0 ? _group$propertyTexts$ : (_mockProperties$get = mockProperties.get(name)) === null || _mockProperties$get === void 0 ? void 0 : _mockProperties$get.text) !== null && _ref14 !== void 0 ? _ref14 : '';
+    }).join('\n');
+
+    // Determine if we need preamble for this group
+    var neededPreamble = getNeededPreamble({
+      propertyTexts: propTexts,
+      allPreamble: preambleStatements
+    });
+    var rewrittenPreamble = neededPreamble.map(function (p) {
+      return rewritePreambleLineBarrelRequireActual({
+        lineText: p.text,
+        oldBarrelPath: oldBarrelImportPath,
+        targetImportPathForThisMock: fullImportPath,
+        mockImplementationTextForGroup: combinedGroupImplText,
+        symbolToNewImportPath: symbolToNewImportPath
+      });
+    });
+    if (neededPreamble.length > 0) {
+      // Generate block body arrow function with preamble
+      var preambleLines = rewrittenPreamble.map(function (text) {
+        return "\t".concat(text);
+      }).join('\n');
+      var formattedProps = propTexts.map(function (p) {
+        return "\t\t".concat(p, ",");
+      }).join('\n');
+      return "jest.mock(".concat(quote).concat(fullImportPath).concat(quote, ", () => {\n").concat(preambleLines, "\n\treturn {\n").concat(formattedProps, "\n\t};\n})");
+    } else {
+      // Always use multi-line format for consistency
+      var _formattedProps = propTexts.map(function (p) {
+        return "\t".concat(p, ",");
+      }).join('\n');
+      return "jest.mock(".concat(quote).concat(fullImportPath).concat(quote, ", () => ({\n").concat(_formattedProps, "\n}))");
+    }
+  };
+
+  // Generate mocks for cross-package groups first
+  var _iterator16 = _createForOfIteratorHelper(crossPackageGroups),
+    _step16;
+  try {
+    for (_iterator16.s(); !(_step16 = _iterator16.n()).done;) {
+      var group = _step16.value;
+      mockCalls.push(generateMockCall(group, group.importPath));
+    }
+
+    // Generate mocks for same-package groups
+  } catch (err) {
+    _iterator16.e(err);
+  } finally {
+    _iterator16.f();
+  }
+  var _iterator17 = _createForOfIteratorHelper(groups),
+    _step17;
+  try {
+    for (_iterator17.s(); !(_step17 = _iterator17.n()).done;) {
+      var _group = _step17.value;
+      var fullImportPath = "".concat(packageName).concat(_group.exportPath.slice(1));
+      mockCalls.push(generateMockCall(_group, fullImportPath));
+    }
+
+    // Join with semicolons but don't add trailing semicolon
+  } catch (err) {
+    _iterator17.e(err);
+  } finally {
+    _iterator17.f();
+  }
+  return mockCalls.join(';\n');
+}
+
+/**
+ * Context resolved for a jest.mock that may be mocking a barrel file.
+ */
+
+/**
+ * Resolves jest.mock context for barrel file analysis.
+ * Returns null if the mock should not be processed.
+ */
+function resolveJestMockContext(_ref15) {
+  var importPath = _ref15.importPath,
+    workspaceRoot = _ref15.workspaceRoot,
+    fs = _ref15.fs,
+    applyToImportsFrom = _ref15.applyToImportsFrom;
+  if (isRelativeImport(importPath)) {
+    return null;
+  }
+  var packageNameMatch = importPath.match(/^(@[^/]+\/[^/]+)/);
+  if (!packageNameMatch) {
+    return null;
+  }
+  var packageName = packageNameMatch[1];
+  var subPath = importPath.slice(packageName.length);
+
+  // Find the package (resolution is not constrained by applyToImportsFrom)
+  var packageDir = findPackageInRegistry({
+    packageName: packageName,
+    workspaceRoot: workspaceRoot,
+    fs: fs
+  });
+  if (!packageDir) {
+    return null;
+  }
+
+  // Only check mocks from packages in our applyToImportsFrom folders
+  if (!isPackageInApplyToImportsFrom({
+    packageDir: packageDir,
+    workspaceRoot: workspaceRoot,
+    applyToImportsFrom: applyToImportsFrom
+  })) {
+    return null;
+  }
+  var exportsMap = parsePackageExports({
+    packageDir: packageDir,
+    fs: fs
+  });
+  if (exportsMap.size === 0) {
+    return null;
+  }
+  var currentExportPath = subPath ? '.' + subPath : '.';
+  var entryFilePath = exportsMap.get(currentExportPath);
+  if (!entryFilePath) {
+    return null;
+  }
+  var exportMap = parseBarrelExports({
+    barrelFilePath: entryFilePath,
+    fs: fs,
+    workspaceRoot: workspaceRoot
+  });
+  if (exportMap.size === 0) {
+    return null;
+  }
+  return {
+    importPath: importPath,
+    packageName: packageName,
+    packageDir: packageDir,
+    currentExportPath: currentExportPath,
+    exportsMap: exportsMap,
+    exportMap: exportMap,
+    entryFilePath: entryFilePath
+  };
+}
+
+/**
+ * Check if the entry file is a barrel file (re-exports from other files)
+ */
+function isBarrelFile(_ref16) {
+  var exportMap = _ref16.exportMap,
+    entryFilePath = _ref16.entryFilePath;
+  return hasReExportsFromOtherFiles({
+    exportMap: exportMap,
+    sourceFilePath: entryFilePath
+  });
+}
+
+/**
+ * Metadata for the ESLint rule
+ */
+var ruleMeta = {
+  type: 'problem',
+  docs: {
+    description: 'Disallow jest.mock calls on barrel file entry points. Mock source files directly using package.json exports.',
+    category: 'Best Practices',
+    recommended: false
+  },
+  fixable: 'code',
+  schema: [{
+    type: 'object',
+    properties: {
+      applyToImportsFrom: {
+        type: 'array',
+        items: {
+          type: 'string'
+        },
+        description: 'The folder paths (relative to workspace root) containing packages whose imports will be checked and autofixed.'
+      }
+    },
+    additionalProperties: false
+  }],
+  messages: {
+    barrelEntryMock: "jest.mock('{{path}}') is mocking a barrel file entry point. Split into separate mocks for each source file using package.json exports.",
+    barrelEntryRequireActual: "jest.requireActual('{{path}}') references a barrel file entry point. Use a specific package.json export path instead."
+  }
+};
+
+/**
+ * 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) {
+      var _options$applyToImpor;
+      var options = context.options[0] || {};
+      var applyToImportsFrom = (_options$applyToImpor = options.applyToImportsFrom) !== null && _options$applyToImpor !== void 0 ? _options$applyToImpor : DEFAULT_TARGET_FOLDERS;
+      var workspaceRoot = findWorkspaceRoot({
+        startPath: dirname(context.filename),
+        fs: fs,
+        applyToImportsFrom: applyToImportsFrom
+      });
+      return {
+        CallExpression: function CallExpression(rawNode) {
+          var node = rawNode;
+
+          // Handle standalone jest.requireActual() calls that reference barrel entries.
+          // e.g. jest.requireActual('@atlaskit/pkg').Foo or const { Foo } = jest.requireActual('@atlaskit/pkg')
+          if (isJestRequireActual(node)) {
+            var raImportPath = extractImportPath(node);
+            if (!raImportPath) {
+              return;
+            }
+            var raContext = resolveJestMockContext({
+              importPath: raImportPath,
+              workspaceRoot: workspaceRoot,
+              fs: fs,
+              applyToImportsFrom: applyToImportsFrom
+            });
+            if (!raContext) {
+              return;
+            }
+            if (!isBarrelFile({
+              exportMap: raContext.exportMap,
+              entryFilePath: raContext.entryFilePath
+            })) {
+              return;
+            }
+
+            // `jest.requireActual('<barrel>')` inside `jest.mock('<barrel>')` is handled by the mock
+            // rule's fix (preamble retargeting + `jest.requireActual('barrel').x` rewriting), including
+            // `const actual = jest.requireActual('<barrel>')` with no member access on the call.
+            // Skip standalone handling here to avoid duplicate diagnostics.
+            var ancestor = node.parent;
+            while (ancestor) {
+              if (ancestor.type === 'CallExpression' && isJestMockCall(ancestor)) {
+                var ancestorPath = extractImportPath(ancestor);
+                if (ancestorPath) {
+                  var ancestorCtx = resolveJestMockContext({
+                    importPath: ancestorPath,
+                    workspaceRoot: workspaceRoot,
+                    fs: fs,
+                    applyToImportsFrom: applyToImportsFrom
+                  });
+                  if (ancestorCtx && isBarrelFile({
+                    exportMap: ancestorCtx.exportMap,
+                    entryFilePath: ancestorCtx.entryFilePath
+                  })) {
+                    return;
+                  }
+                }
+              }
+              ancestor = ancestor.parent;
+            }
+
+            // Determine which symbols are accessed from the barrel
+            var parent = node.parent;
+            var accessedSymbols = [];
+            if ((parent === null || parent === void 0 ? void 0 : parent.type) === 'MemberExpression' && parent.property.type === 'Identifier') {
+              accessedSymbols.push(parent.property.name);
+            } else if ((parent === null || parent === void 0 ? void 0 : parent.type) === 'VariableDeclarator' && parent.id.type === 'ObjectPattern') {
+              var _iterator18 = _createForOfIteratorHelper(parent.id.properties),
+                _step18;
+              try {
+                for (_iterator18.s(); !(_step18 = _iterator18.n()).done;) {
+                  var prop = _step18.value;
+                  if (prop.type === 'Property' && prop.key.type === 'Identifier') {
+                    accessedSymbols.push(prop.key.name);
+                  }
+                }
+              } catch (err) {
+                _iterator18.e(err);
+              } finally {
+                _iterator18.f();
+              }
+            }
+            if (accessedSymbols.length === 0) {
+              context.report({
+                node: node,
+                messageId: 'barrelEntryRequireActual',
+                data: {
+                  path: raImportPath
+                }
+              });
+              return;
+            }
+            var _traceSymbolsToExport = traceSymbolsToExports({
+                symbolNames: accessedSymbols,
+                exportMap: raContext.exportMap,
+                exportsMap: raContext.exportsMap,
+                currentExportPath: raContext.currentExportPath,
+                fs: fs
+              }),
+              _groupedByExport = _traceSymbolsToExport.groupedByExport,
+              _crossPackageGroups = _traceSymbolsToExport.crossPackageGroups;
+            var newPath = null;
+            if (_groupedByExport.size === 1 && _crossPackageGroups.size === 0) {
+              var _groupedByExport$keys = _groupedByExport.keys(),
+                _groupedByExport$keys2 = _slicedToArray(_groupedByExport$keys, 1),
+                exportPath = _groupedByExport$keys2[0];
+              newPath = "".concat(raContext.packageName).concat(exportPath.slice(1));
+            } else if (_crossPackageGroups.size === 1 && _groupedByExport.size === 0) {
+              var _crossPackageGroups$k = _crossPackageGroups.keys(),
+                _crossPackageGroups$k2 = _slicedToArray(_crossPackageGroups$k, 1),
+                cpImportPath = _crossPackageGroups$k2[0];
+              newPath = cpImportPath;
+            }
+            var _sourceCode = context.getSourceCode();
+            if (newPath) {
+              var resolvedNewPath = newPath;
+              context.report({
+                node: node,
+                messageId: 'barrelEntryRequireActual',
+                data: {
+                  path: raImportPath
+                },
+                fix: function fix(fixer) {
+                  var firstArg = node.arguments[0];
+                  var quote = _sourceCode.getText(firstArg)[0];
+                  return fixer.replaceText(firstArg, "".concat(quote).concat(resolvedNewPath).concat(quote));
+                }
+              });
+            } else {
+              context.report({
+                node: node,
+                messageId: 'barrelEntryRequireActual',
+                data: {
+                  path: raImportPath
+                }
+              });
+            }
+            return;
+          }
+          if (!isJestMockCall(node)) {
+            return;
+          }
+          var importPath = extractImportPath(node);
+          if (!importPath) {
+            return;
+          }
+          var mockContext = resolveJestMockContext({
+            importPath: importPath,
+            workspaceRoot: workspaceRoot,
+            fs: fs,
+            applyToImportsFrom: applyToImportsFrom
+          });
+          if (!mockContext) {
+            return;
+          }
+          if (!isBarrelFile({
+            exportMap: mockContext.exportMap,
+            entryFilePath: mockContext.entryFilePath
+          })) {
+            return;
+          }
+          var mockImpl = node.arguments[1];
+          // Ignore auto-mocks (jest.mock with only the import string and no second argument)
+          // These are intentionally excluded from barrel file checks as they auto-mock all exports
+          if (!mockImpl) {
+            return;
+          }
+          var mockObjectNode = extractMockImplementation({
+            mockImpl: mockImpl
+          });
+          var sourceCode = context.getSourceCode();
+          var _extractMockPropertie2 = extractMockProperties({
+              sourceCode: sourceCode,
+              mockObjectNode: mockObjectNode
+            }),
+            mockProperties = _extractMockPropertie2.properties;
+
+          // Extract preamble statements (variable declarations before return)
+          var preambleStatements = extractPreambleStatements({
+            mockImpl: mockImpl,
+            sourceCode: sourceCode
+          });
+          if (mockProperties.size === 0) {
+            return;
+          }
+          var originalMockHadEsModule = mockProperties.has('__esModule');
+          var symbolNames = Array.from(mockProperties.keys()).filter(function (name) {
+            return !ESM_INTEROP_MOCK_KEYS.has(name);
+          });
+          var _traceSymbolsToExport2 = traceSymbolsToExports({
+              symbolNames: symbolNames,
+              exportMap: mockContext.exportMap,
+              exportsMap: mockContext.exportsMap,
+              currentExportPath: mockContext.currentExportPath,
+              fs: fs
+            }),
+            groupedByExport = _traceSymbolsToExport2.groupedByExport,
+            crossPackageGroups = _traceSymbolsToExport2.crossPackageGroups,
+            unmappedSymbols = _traceSymbolsToExport2.unmappedSymbols;
+
+          // If no symbols can be mapped to specific exports or cross-package sources,
+          // there's nothing to fix so don't report an error
+          if (groupedByExport.size === 0 && crossPackageGroups.size === 0) {
+            return;
+          }
+          var groups = [];
+          var _iterator19 = _createForOfIteratorHelper(groupedByExport),
+            _step19;
+          try {
+            for (_iterator19.s(); !(_step19 = _iterator19.n()).done;) {
+              var _step19$value = _slicedToArray(_step19.value, 2),
+                _exportPath = _step19$value[0],
+                symbols = _step19$value[1];
+              // Build name mapping for aliased exports
+              var nameMapping = new Map();
+              var _iterator25 = _createForOfIteratorHelper(symbols),
+                _step25;
+              try {
+                for (_iterator25.s(); !(_step25 = _iterator25.n()).done;) {
+                  var s = _step25.value;
+                  if (s.originalName) {
+                    nameMapping.set(s.symbolName, s.originalName);
+                  }
+                }
+
+                // Check if any symbol in this group is a default export
+              } catch (err) {
+                _iterator25.e(err);
+              } finally {
+                _iterator25.f();
+              }
+              var hasDefaultExport = symbols.some(function (s) {
+                return s.originalName === 'default';
+              });
+              groups.push({
+                exportPath: _exportPath,
+                importPath: "".concat(mockContext.packageName).concat(_exportPath.slice(1)),
+                propertyNames: symbols.map(function (s) {
+                  return s.symbolName;
+                }),
+                propertyTexts: new Map(symbols.map(function (s) {
+                  return [s.symbolName, mockProperties.get(s.symbolName).text];
+                })),
+                nameMapping: nameMapping,
+                hasDefaultExport: hasDefaultExport
+              });
+            }
+
+            // Build cross-package groups
+          } catch (err) {
+            _iterator19.e(err);
+          } finally {
+            _iterator19.f();
+          }
+          var crossPackageMockGroups = [];
+          var _iterator20 = _createForOfIteratorHelper(crossPackageGroups),
+            _step20;
+          try {
+            for (_iterator20.s(); !(_step20 = _iterator20.n()).done;) {
+              var _step20$value = _slicedToArray(_step20.value, 2),
+                _importPath = _step20$value[0],
+                _symbols = _step20$value[1];
+              // Build name mapping for aliased exports
+              var _nameMapping = new Map();
+              var _iterator26 = _createForOfIteratorHelper(_symbols),
+                _step26;
+              try {
+                for (_iterator26.s(); !(_step26 = _iterator26.n()).done;) {
+                  var _s = _step26.value;
+                  if (_s.originalName) {
+                    _nameMapping.set(_s.symbolName, _s.originalName);
+                  }
+                }
+
+                // Check if any symbol in this group is a default export
+              } catch (err) {
+                _iterator26.e(err);
+              } finally {
+                _iterator26.f();
+              }
+              var _hasDefaultExport = _symbols.some(function (s) {
+                return s.originalName === 'default';
+              });
+
+              // Get cross-package source info from the first symbol (all symbols in same group have same source)
+              var crossPackageSource = _symbols[0].crossPackageSource;
+              crossPackageMockGroups.push({
+                exportPath: crossPackageSource.exportPath,
+                importPath: _importPath,
+                propertyNames: _symbols.map(function (s) {
+                  return s.symbolName;
+                }),
+                propertyTexts: new Map(_symbols.map(function (s) {
+                  return [s.symbolName, mockProperties.get(s.symbolName).text];
+                })),
+                nameMapping: _nameMapping,
+                hasDefaultExport: _hasDefaultExport
+              });
+            }
+          } catch (err) {
+            _iterator20.e(err);
+          } finally {
+            _iterator20.f();
+          }
+          if (unmappedSymbols.length > 0) {
+            groups.push({
+              exportPath: mockContext.currentExportPath,
+              importPath: mockContext.importPath,
+              propertyNames: unmappedSymbols,
+              propertyTexts: new Map(unmappedSymbols.map(function (s) {
+                return [s, mockProperties.get(s).text];
+              })),
+              nameMapping: new Map(),
+              hasDefaultExport: false
+            });
+          }
+          context.report({
+            node: node,
+            messageId: 'barrelEntryMock',
+            data: {
+              path: importPath
+            },
+            fix: function fix(fixer) {
+              var firstArg = node.arguments[0];
+              var quote = sourceCode.getText(firstArg)[0];
+
+              // Build a mapping from old import path to new import paths (with their symbols)
+              // so we can update jest.requireMock() calls later
+              var oldImportPath = importPath;
+
+              // Find all existing jest.mock calls in the file
+              var allExistingMocks = findAllJestMocksInFile({
+                context: context
+              });
+
+              // Track nodes to remove and merged mock info
+              var nodesToRemove = [node];
+              var mergedGroups = [];
+              for (var _i3 = 0, _groups = groups; _i3 < _groups.length; _i3++) {
+                var group = _groups[_i3];
+                var existingMock = allExistingMocks.get(group.importPath);
+                if (existingMock && existingMock.node !== node) {
+                  // Merge properties from existing mock with new properties
+                  var newPropertiesMap = new Map();
+                  var _iterator21 = _createForOfIteratorHelper(group.propertyNames),
+                    _step21;
+                  try {
+                    for (_iterator21.s(); !(_step21 = _iterator21.n()).done;) {
+                      var propName = _step21.value;
+                      var propInfo = mockProperties.get(propName);
+                      if (propInfo) {
+                        // Check if this property needs to be renamed (aliased export)
+                        var originalName = group.nameMapping.get(propName);
+                        if (originalName && originalName !== propName) {
+                          var renamedText = replacePropertyKey({
+                            propText: propInfo.text,
+                            mockName: propName,
+                            originalName: originalName
+                          });
+                          newPropertiesMap.set(originalName, {
+                            node: propInfo.node,
+                            text: renamedText
+                          });
+                        } else {
+                          newPropertiesMap.set(propName, propInfo);
+                        }
+                      }
+                    }
+                  } catch (err) {
+                    _iterator21.e(err);
+                  } finally {
+                    _iterator21.f();
+                  }
+                  var mergedProperties = mergeMockProperties({
+                    existingProperties: existingMock.properties,
+                    newProperties: newPropertiesMap
+                  });
+
+                  // Create merged group with all properties
+                  mergedGroups.push({
+                    exportPath: group.exportPath,
+                    importPath: group.importPath,
+                    propertyNames: Array.from(mergedProperties.keys()),
+                    propertyTexts: new Map(Array.from(mergedProperties.entries()).map(function (_ref17) {
+                      var _ref18 = _slicedToArray(_ref17, 2),
+                        k = _ref18[0],
+                        v = _ref18[1];
+                      return [k, v.text];
+                    })),
+                    nameMapping: new Map(),
+                    // Already applied above
+                    hasDefaultExport: group.hasDefaultExport
+                  });
+
+                  // Mark existing mock for removal
+                  nodesToRemove.push(existingMock.node);
+                } else {
+                  // No existing mock, use the group as-is
+                  mergedGroups.push(group);
+                }
+              }
+              var symbolToNewImportPath = new Map();
+              for (var _i4 = 0, _arr = [].concat(mergedGroups, crossPackageMockGroups); _i4 < _arr.length; _i4++) {
+                var _group2 = _arr[_i4];
+                var _iterator22 = _createForOfIteratorHelper(_group2.propertyNames),
+                  _step22;
+                try {
+                  for (_iterator22.s(); !(_step22 = _iterator22.n()).done;) {
+                    var _propName = _step22.value;
+                    symbolToNewImportPath.set(_propName, _group2.importPath);
+                  }
+                } catch (err) {
+                  _iterator22.e(err);
+                } finally {
+                  _iterator22.f();
+                }
+              }
+              var fixText = generateMockFixes({
+                groups: mergedGroups,
+                crossPackageGroups: crossPackageMockGroups,
+                packageName: mockContext.packageName,
+                mockProperties: mockProperties,
+                quote: quote,
+                preambleStatements: preambleStatements,
+                propagateEsModuleFromOriginalMock: originalMockHadEsModule,
+                oldBarrelImportPath: oldImportPath,
+                symbolToNewImportPath: symbolToNewImportPath
+              });
+
+              // Post-process fixText to update jest.requireActual('barrel').Symbol
+              // references embedded in property texts (e.g. inside jest.fn callbacks)
+              fixText = fixText.replace(/jest\.requireActual(?:<[^>]*>)?\((['"])([^'"]+)\1\)\.(\w+)/g, function (match, _q, path, symbol) {
+                if (path !== oldImportPath) {
+                  return match;
+                }
+                var newPath = symbolToNewImportPath.get(symbol);
+                if (newPath && newPath !== path) {
+                  return match.replace(path, newPath);
+                }
+                return match;
+              });
+
+              // Sort nodes by position
+              var sortedNodesToRemove = 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);
+              });
+              var fixes = [];
+              if (sortedNodesToRemove.length === 1) {
+                // Simple case: just replace the current node
+                fixes.push(fixer.replaceText(node, fixText));
+              } else {
+                // Complex case: replace first node, remove others
+                // Replace the first node with the merged mocks
+                fixes.push(fixer.replaceText(sortedNodesToRemove[0], fixText));
+
+                // Remove remaining nodes
+                for (var i = 1; i < sortedNodesToRemove.length; i++) {
+                  var nodeToRemove = sortedNodesToRemove[i];
+                  var tokenAfter = sourceCode.getTokenAfter(nodeToRemove);
+                  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 whitespace and newlines
+                  var text = sourceCode.getText();
+                  while (endPos < text.length && /[\s\n]/.test(text[endPos])) {
+                    endPos++;
+                  }
+                  fixes.push(fixer.removeRange([startPos, endPos]));
+                }
+              }
+
+              // Fix jest.requireMock() calls that reference the old barrel path.
+              // When we split a jest.mock('pkg/barrel') into jest.mock('pkg/subpath'),
+              // any jest.requireMock('pkg/barrel') calls also need to be updated.
+              var ast = sourceCode.ast;
+              var requireMockCalls = findJestRequireMockCalls({
+                ast: ast,
+                matchPath: function matchPath(candidatePath) {
+                  return candidatePath === oldImportPath;
+                }
+              });
+              var _iterator23 = _createForOfIteratorHelper(requireMockCalls),
+                _step23;
+              try {
+                for (_iterator23.s(); !(_step23 = _iterator23.n()).done;) {
+                  var requireMockNode = _step23.value;
+                  var requireMockArg = requireMockNode.arguments[0];
+                  if (!requireMockArg) {
+                    continue;
+                  }
+                  var _newPath = resolveNewPathForRequireMock({
+                    requireMockNode: requireMockNode,
+                    symbolToNewPath: symbolToNewImportPath
+                  });
+                  if (_newPath) {
+                    fixes.push(fixer.replaceText(requireMockArg, "".concat(quote).concat(_newPath).concat(quote)));
+                  }
+                }
+
+                // Fix jest.requireActual() calls that reference the old barrel path.
+                // Only fix calls OUTSIDE the replaced jest.mock node range
+                // (calls inside it are handled via fixText string replacement below).
+              } catch (err) {
+                _iterator23.e(err);
+              } finally {
+                _iterator23.f();
+              }
+              var replacedRanges = sortedNodesToRemove.map(function (n) {
+                return n.range;
+              });
+              var requireActualCalls = findJestRequireActualCalls({
+                ast: ast,
+                matchPath: function matchPath(candidatePath) {
+                  return candidatePath === oldImportPath;
+                }
+              });
+              var _iterator24 = _createForOfIteratorHelper(requireActualCalls),
+                _step24;
+              try {
+                var _loop = function _loop() {
+                    var raNode = _step24.value;
+                    var raArg = raNode.arguments[0];
+                    if (!raArg || !raNode.range) {
+                      return 0; // continue
+                    }
+
+                    // Skip calls inside any node being replaced (ranges overlap)
+                    var insideReplacedNode = replacedRanges.some(function (_ref19) {
+                      var _ref20 = _slicedToArray(_ref19, 2),
+                        start = _ref20[0],
+                        end = _ref20[1];
+                      return raNode.range[0] >= start && raNode.range[1] <= end;
+                    });
+                    if (insideReplacedNode) {
+                      return 0; // continue
+                    }
+                    var newPath = resolveNewPathForRequireMock({
+                      requireMockNode: raNode,
+                      symbolToNewPath: symbolToNewImportPath
+                    });
+                    if (newPath) {
+                      fixes.push(fixer.replaceText(raArg, "".concat(quote).concat(newPath).concat(quote)));
+                    }
+                  },
+                  _ret;
+                for (_iterator24.s(); !(_step24 = _iterator24.n()).done;) {
+                  _ret = _loop();
+                  if (_ret === 0) continue;
+                }
+              } catch (err) {
+                _iterator24.e(err);
+              } finally {
+                _iterator24.f();
+              }
+              return fixes;
+            }
+          });
+        }
+      };
+    }
+  };
+}
+var rule = createRule(realFileSystem);
+export default rule;