@atlaskit/eslint-plugin-platform 2.8.0 → 2.9.1

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

@@ -671,7 +671,9 @@ function traceSymbolsToExports(_ref10) {
     exportMap = _ref10.exportMap,
     exportsMap = _ref10.exportsMap,
     currentExportPath = _ref10.currentExportPath,
-    fs = _ref10.fs;
+    fs = _ref10.fs,
+    barrelPackageName = _ref10.barrelPackageName,
+    preferImportedPackageSubpath = _ref10.preferImportedPackageSubpath;
   var groupedByExport = new Map();
   var crossPackageGroups = new Map();
   var unmappedSymbols = [];
@@ -679,6 +681,7 @@ function traceSymbolsToExports(_ref10) {
     _step13;
   try {
     for (_iterator13.s(); !(_step13 = _iterator13.n()).done;) {
+      var _findExportForSourceF, _findExportForSourceF2;
       var symbolName = _step13.value;
       var exportInfo = exportMap.get(symbolName);
       if (!exportInfo) {
@@ -688,25 +691,47 @@ function traceSymbolsToExports(_ref10) {
 
       // Check for cross-package source first
       if (exportInfo.crossPackageSource) {
-        var key = "".concat(exportInfo.crossPackageSource.packageName).concat(exportInfo.crossPackageSource.exportPath === '.' ? '' : exportInfo.crossPackageSource.exportPath.slice(1));
+        var key = void 0;
+        var tracedOriginalName = exportInfo.originalName;
+        var barrelBridgeExportPath = void 0;
+        if (preferImportedPackageSubpath) {
+          var bridge = (0, _packageResolution.findCrossPackageBridgeExportPath)({
+            exportsMap: exportsMap,
+            crossPackageName: exportInfo.crossPackageSource.packageName,
+            exportedName: symbolName,
+            fs: fs
+          });
+          if (bridge) {
+            key = "".concat(barrelPackageName).concat(bridge.exportPath.slice(1));
+            barrelBridgeExportPath = bridge.exportPath;
+            if (bridge.entryPointExportName !== undefined) {
+              tracedOriginalName = bridge.entryPointExportName === symbolName ? undefined : bridge.entryPointExportName;
+            }
+          } else {
+            key = "".concat(exportInfo.crossPackageSource.packageName).concat(exportInfo.crossPackageSource.exportPath === '.' ? '' : exportInfo.crossPackageSource.exportPath.slice(1));
+          }
+        } else {
+          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,
+          originalName: tracedOriginalName,
           sourceFilePath: exportInfo.path,
           isTypeOnly: exportInfo.isTypeOnly,
-          crossPackageSource: exportInfo.crossPackageSource
+          crossPackageSource: exportInfo.crossPackageSource,
+          barrelBridgeExportPath: barrelBridgeExportPath
         });
         continue;
       }
 
       // First try to find an export that directly exposes the source file
-      var targetExportPath = (0, _packageResolution.findExportForSourceFile)({
+      var targetExportPath = (_findExportForSourceF = (_findExportForSourceF2 = (0, _packageResolution.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)
@@ -766,16 +791,80 @@ 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(_ref12) {
-  var groups = _ref12.groups,
-    crossPackageGroups = _ref12.crossPackageGroups,
-    packageName = _ref12.packageName,
-    mockProperties = _ref12.mockProperties,
-    quote = _ref12.quote,
-    preambleStatements = _ref12.preambleStatements;
+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
@@ -783,15 +872,15 @@ function generateMockFixes(_ref12) {
     var propTexts = [];
     propTexts.push("...jest.requireActual(".concat(quote).concat(fullImportPath).concat(quote, ")"));
 
-    // Add __esModule: true when mocking default exports
-    if (group.hasDefaultExport) {
+    // 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 _iterator14 = _createForOfIteratorHelper(group.propertyNames),
-      _step14;
+    var _iterator15 = _createForOfIteratorHelper(group.propertyNames),
+      _step15;
     try {
-      for (_iterator14.s(); !(_step14 = _iterator14.n()).done;) {
-        var propName = _step14.value;
+      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) {
@@ -825,21 +914,34 @@ function generateMockFixes(_ref12) {
           }
         }
       }
-
-      // Determine if we need preamble for this group
     } catch (err) {
-      _iterator14.e(err);
+      _iterator15.e(err);
     } finally {
-      _iterator14.f();
+      _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 = neededPreamble.map(function (p) {
-        return "\t".concat(p.text);
+      var preambleLines = rewrittenPreamble.map(function (text) {
+        return "\t".concat(text);
       }).join('\n');
       var formattedProps = propTexts.map(function (p) {
         return "\t\t".concat(p, ",");
@@ -855,34 +957,34 @@ function generateMockFixes(_ref12) {
   };
 
   // Generate mocks for cross-package groups first
-  var _iterator15 = _createForOfIteratorHelper(crossPackageGroups),
-    _step15;
+  var _iterator16 = _createForOfIteratorHelper(crossPackageGroups),
+    _step16;
   try {
-    for (_iterator15.s(); !(_step15 = _iterator15.n()).done;) {
-      var group = _step15.value;
+    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) {
-    _iterator15.e(err);
+    _iterator16.e(err);
   } finally {
-    _iterator15.f();
+    _iterator16.f();
   }
-  var _iterator16 = _createForOfIteratorHelper(groups),
-    _step16;
+  var _iterator17 = _createForOfIteratorHelper(groups),
+    _step17;
   try {
-    for (_iterator16.s(); !(_step16 = _iterator16.n()).done;) {
-      var _group = _step16.value;
+    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) {
-    _iterator16.e(err);
+    _iterator17.e(err);
   } finally {
-    _iterator16.f();
+    _iterator17.f();
   }
   return mockCalls.join(';\n');
 }
@@ -895,11 +997,11 @@ function generateMockFixes(_ref12) {
  * Resolves jest.mock context for barrel file analysis.
  * Returns null if the mock should not be processed.
  */
-function resolveJestMockContext(_ref13) {
-  var importPath = _ref13.importPath,
-    workspaceRoot = _ref13.workspaceRoot,
-    fs = _ref13.fs,
-    applyToImportsFrom = _ref13.applyToImportsFrom;
+function resolveJestMockContext(_ref15) {
+  var importPath = _ref15.importPath,
+    workspaceRoot = _ref15.workspaceRoot,
+    fs = _ref15.fs,
+    applyToImportsFrom = _ref15.applyToImportsFrom;
   if ((0, _fileSystem.isRelativeImport)(importPath)) {
     return null;
   }
@@ -962,9 +1064,9 @@ function resolveJestMockContext(_ref13) {
 /**
  * Check if the entry file is a barrel file (re-exports from other files)
  */
-function isBarrelFile(_ref14) {
-  var exportMap = _ref14.exportMap,
-    entryFilePath = _ref14.entryFilePath;
+function isBarrelFile(_ref16) {
+  var exportMap = _ref16.exportMap,
+    entryFilePath = _ref16.entryFilePath;
   return (0, _barrelParsing.hasReExportsFromOtherFiles)({
     exportMap: exportMap,
     sourceFilePath: entryFilePath
@@ -991,12 +1093,17 @@ var ruleMeta = {
           type: 'string'
         },
         description: 'The folder paths (relative to workspace root) containing packages whose imports will be checked and autofixed.'
+      },
+      preferImportedPackageSubpath: {
+        type: 'boolean',
+        description: 'Prefer subpaths on the mocked barrel package when they bridge to the dependency.'
       }
     },
     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."
+    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."
   }
 };
 
@@ -1008,9 +1115,10 @@ function createRule(fs) {
   return {
     meta: ruleMeta,
     create: function create(context) {
-      var _options$applyToImpor;
+      var _options$applyToImpor, _options$preferImport;
       var options = context.options[0] || {};
       var applyToImportsFrom = (_options$applyToImpor = options.applyToImportsFrom) !== null && _options$applyToImpor !== void 0 ? _options$applyToImpor : _fileSystem.DEFAULT_TARGET_FOLDERS;
+      var preferImportedPackageSubpath = (_options$preferImport = options.preferImportedPackageSubpath) !== null && _options$preferImport !== void 0 ? _options$preferImport : false;
       var workspaceRoot = (0, _fileSystem.findWorkspaceRoot)({
         startPath: (0, _path.dirname)(context.filename),
         fs: fs,
@@ -1019,6 +1127,136 @@ function createRule(fs) {
       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 ((0, _jestUtils.isJestRequireActual)(node)) {
+            var raImportPath = (0, _jestUtils.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' && (0, _jestUtils.isJestMockCall)(ancestor)) {
+                var ancestorPath = (0, _jestUtils.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,
+                barrelPackageName: raContext.packageName,
+                preferImportedPackageSubpath: preferImportedPackageSubpath
+              }),
+              _groupedByExport = _traceSymbolsToExport.groupedByExport,
+              _crossPackageGroups = _traceSymbolsToExport.crossPackageGroups;
+            var newPath = null;
+            if (_groupedByExport.size === 1 && _crossPackageGroups.size === 0) {
+              var _groupedByExport$keys = _groupedByExport.keys(),
+                _groupedByExport$keys2 = (0, _slicedToArray2.default)(_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 = (0, _slicedToArray2.default)(_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 (!(0, _jestUtils.isJestMockCall)(node)) {
             return;
           }
@@ -1065,17 +1303,22 @@ function createRule(fs) {
           if (mockProperties.size === 0) {
             return;
           }
-          var symbolNames = Array.from(mockProperties.keys());
-          var _traceSymbolsToExport = traceSymbolsToExports({
+          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
+              fs: fs,
+              barrelPackageName: mockContext.packageName,
+              preferImportedPackageSubpath: preferImportedPackageSubpath
             }),
-            groupedByExport = _traceSymbolsToExport.groupedByExport,
-            crossPackageGroups = _traceSymbolsToExport.crossPackageGroups,
-            unmappedSymbols = _traceSymbolsToExport.unmappedSymbols;
+            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
@@ -1083,20 +1326,20 @@ function createRule(fs) {
             return;
           }
           var groups = [];
-          var _iterator17 = _createForOfIteratorHelper(groupedByExport),
-            _step17;
+          var _iterator19 = _createForOfIteratorHelper(groupedByExport),
+            _step19;
           try {
-            for (_iterator17.s(); !(_step17 = _iterator17.n()).done;) {
-              var _step17$value = (0, _slicedToArray2.default)(_step17.value, 2),
-                exportPath = _step17$value[0],
-                symbols = _step17$value[1];
+            for (_iterator19.s(); !(_step19 = _iterator19.n()).done;) {
+              var _step19$value = (0, _slicedToArray2.default)(_step19.value, 2),
+                _exportPath = _step19$value[0],
+                symbols = _step19$value[1];
               // Build name mapping for aliased exports
               var nameMapping = new Map();
-              var _iterator22 = _createForOfIteratorHelper(symbols),
-                _step22;
+              var _iterator25 = _createForOfIteratorHelper(symbols),
+                _step25;
               try {
-                for (_iterator22.s(); !(_step22 = _iterator22.n()).done;) {
-                  var s = _step22.value;
+                for (_iterator25.s(); !(_step25 = _iterator25.n()).done;) {
+                  var s = _step25.value;
                   if (s.originalName) {
                     nameMapping.set(s.symbolName, s.originalName);
                   }
@@ -1104,16 +1347,16 @@ function createRule(fs) {
 
                 // Check if any symbol in this group is a default export
               } catch (err) {
-                _iterator22.e(err);
+                _iterator25.e(err);
               } finally {
-                _iterator22.f();
+                _iterator25.f();
               }
               var hasDefaultExport = symbols.some(function (s) {
                 return s.originalName === 'default';
               });
               groups.push({
-                exportPath: exportPath,
-                importPath: "".concat(mockContext.packageName).concat(exportPath.slice(1)),
+                exportPath: _exportPath,
+                importPath: "".concat(mockContext.packageName).concat(_exportPath.slice(1)),
                 propertyNames: symbols.map(function (s) {
                   return s.symbolName;
                 }),
@@ -1127,25 +1370,25 @@ function createRule(fs) {
 
             // Build cross-package groups
           } catch (err) {
-            _iterator17.e(err);
+            _iterator19.e(err);
           } finally {
-            _iterator17.f();
+            _iterator19.f();
           }
           var crossPackageMockGroups = [];
-          var _iterator18 = _createForOfIteratorHelper(crossPackageGroups),
-            _step18;
+          var _iterator20 = _createForOfIteratorHelper(crossPackageGroups),
+            _step20;
           try {
-            for (_iterator18.s(); !(_step18 = _iterator18.n()).done;) {
-              var _step18$value = (0, _slicedToArray2.default)(_step18.value, 2),
-                _importPath = _step18$value[0],
-                _symbols = _step18$value[1];
+            for (_iterator20.s(); !(_step20 = _iterator20.n()).done;) {
+              var _step20$value = (0, _slicedToArray2.default)(_step20.value, 2),
+                _importPath = _step20$value[0],
+                _symbols = _step20$value[1];
               // Build name mapping for aliased exports
               var _nameMapping = new Map();
-              var _iterator23 = _createForOfIteratorHelper(_symbols),
-                _step23;
+              var _iterator26 = _createForOfIteratorHelper(_symbols),
+                _step26;
               try {
-                for (_iterator23.s(); !(_step23 = _iterator23.n()).done;) {
-                  var _s = _step23.value;
+                for (_iterator26.s(); !(_step26 = _iterator26.n()).done;) {
+                  var _s = _step26.value;
                   if (_s.originalName) {
                     _nameMapping.set(_s.symbolName, _s.originalName);
                   }
@@ -1153,9 +1396,9 @@ function createRule(fs) {
 
                 // Check if any symbol in this group is a default export
               } catch (err) {
-                _iterator23.e(err);
+                _iterator26.e(err);
               } finally {
-                _iterator23.f();
+                _iterator26.f();
               }
               var _hasDefaultExport = _symbols.some(function (s) {
                 return s.originalName === 'default';
@@ -1163,8 +1406,9 @@ function createRule(fs) {
 
               // Get cross-package source info from the first symbol (all symbols in same group have same source)
               var crossPackageSource = _symbols[0].crossPackageSource;
+              var bridgeExportPath = _symbols[0].barrelBridgeExportPath;
               crossPackageMockGroups.push({
-                exportPath: crossPackageSource.exportPath,
+                exportPath: bridgeExportPath !== null && bridgeExportPath !== void 0 ? bridgeExportPath : crossPackageSource.exportPath,
                 importPath: _importPath,
                 propertyNames: _symbols.map(function (s) {
                   return s.symbolName;
@@ -1177,9 +1421,9 @@ function createRule(fs) {
               });
             }
           } catch (err) {
-            _iterator18.e(err);
+            _iterator20.e(err);
           } finally {
-            _iterator18.f();
+            _iterator20.f();
           }
           if (unmappedSymbols.length > 0) {
             groups.push({
@@ -1221,11 +1465,11 @@ function createRule(fs) {
                 if (existingMock && existingMock.node !== node) {
                   // Merge properties from existing mock with new properties
                   var newPropertiesMap = new Map();
-                  var _iterator19 = _createForOfIteratorHelper(group.propertyNames),
-                    _step19;
+                  var _iterator21 = _createForOfIteratorHelper(group.propertyNames),
+                    _step21;
                   try {
-                    for (_iterator19.s(); !(_step19 = _iterator19.n()).done;) {
-                      var propName = _step19.value;
+                    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)
@@ -1246,9 +1490,9 @@ function createRule(fs) {
                       }
                     }
                   } catch (err) {
-                    _iterator19.e(err);
+                    _iterator21.e(err);
                   } finally {
-                    _iterator19.f();
+                    _iterator21.f();
                   }
                   var mergedProperties = mergeMockProperties({
                     existingProperties: existingMock.properties,
@@ -1260,10 +1504,10 @@ function createRule(fs) {
                     exportPath: group.exportPath,
                     importPath: group.importPath,
                     propertyNames: Array.from(mergedProperties.keys()),
-                    propertyTexts: new Map(Array.from(mergedProperties.entries()).map(function (_ref15) {
-                      var _ref16 = (0, _slicedToArray2.default)(_ref15, 2),
-                        k = _ref16[0],
-                        v = _ref16[1];
+                    propertyTexts: new Map(Array.from(mergedProperties.entries()).map(function (_ref17) {
+                      var _ref18 = (0, _slicedToArray2.default)(_ref17, 2),
+                        k = _ref18[0],
+                        v = _ref18[1];
                       return [k, v.text];
                     })),
                     nameMapping: new Map(),
@@ -1278,32 +1522,46 @@ function createRule(fs) {
                   mergedGroups.push(group);
                 }
               }
-              var fixText = generateMockFixes({
-                groups: mergedGroups,
-                crossPackageGroups: crossPackageMockGroups,
-                packageName: mockContext.packageName,
-                mockProperties: mockProperties,
-                quote: quote,
-                preambleStatements: preambleStatements
-              });
-
-              // Build a map of symbol name -> new import path for jest.requireMock() rewriting
               var symbolToNewImportPath = new Map();
               for (var _i4 = 0, _arr = [].concat(mergedGroups, crossPackageMockGroups); _i4 < _arr.length; _i4++) {
                 var _group2 = _arr[_i4];
-                var _iterator20 = _createForOfIteratorHelper(_group2.propertyNames),
-                  _step20;
+                var _iterator22 = _createForOfIteratorHelper(_group2.propertyNames),
+                  _step22;
                 try {
-                  for (_iterator20.s(); !(_step20 = _iterator20.n()).done;) {
-                    var _propName = _step20.value;
+                  for (_iterator22.s(); !(_step22 = _iterator22.n()).done;) {
+                    var _propName = _step22.value;
                     symbolToNewImportPath.set(_propName, _group2.importPath);
                   }
                 } catch (err) {
-                  _iterator20.e(err);
+                  _iterator22.e(err);
                 } finally {
-                  _iterator20.f();
+                  _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) {
@@ -1350,27 +1608,78 @@ function createRule(fs) {
                   return candidatePath === oldImportPath;
                 }
               });
-              var _iterator21 = _createForOfIteratorHelper(requireMockCalls),
-                _step21;
+              var _iterator23 = _createForOfIteratorHelper(requireMockCalls),
+                _step23;
               try {
-                for (_iterator21.s(); !(_step21 = _iterator21.n()).done;) {
-                  var requireMockNode = _step21.value;
+                for (_iterator23.s(); !(_step23 = _iterator23.n()).done;) {
+                  var requireMockNode = _step23.value;
                   var requireMockArg = requireMockNode.arguments[0];
                   if (!requireMockArg) {
                     continue;
                   }
-                  var newPath = (0, _jestUtils.resolveNewPathForRequireMock)({
+                  var _newPath = (0, _jestUtils.resolveNewPathForRequireMock)({
                     requireMockNode: requireMockNode,
                     symbolToNewPath: symbolToNewImportPath
                   });
-                  if (newPath) {
-                    fixes.push(fixer.replaceText(requireMockArg, "".concat(quote).concat(newPath).concat(quote)));
+                  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 = (0, _jestUtils.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 = (0, _slicedToArray2.default)(_ref19, 2),
+                        start = _ref20[0],
+                        end = _ref20[1];
+                      return raNode.range[0] >= start && raNode.range[1] <= end;
+                    });
+                    if (insideReplacedNode) {
+                      return 0; // continue
+                    }
+                    var newPath = (0, _jestUtils.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) {
-                _iterator21.e(err);
+                _iterator24.e(err);
               } finally {
-                _iterator21.f();
+                _iterator24.f();
               }
               return fixes;
             }