@atlaskit/eslint-plugin-platform 2.8.0 → 2.9.1

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

@@ -2,9 +2,9 @@ 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, findJestRequireMockCalls, isJestMockCall, isJestRequireActual, resolveNewPathForRequireMock } from '../shared/jest-utils';
+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 { findCrossPackageBridgeExportPath, findExportForSourceFile, parsePackageExports } from '../shared/package-resolution';
 import { realFileSystem } from '../shared/types';
 
 /**
@@ -525,12 +525,15 @@ function traceSymbolsToExports({
   exportMap,
   exportsMap,
   currentExportPath,
-  fs
+  fs,
+  barrelPackageName,
+  preferImportedPackageSubpath
 }) {
   const groupedByExport = new Map();
   const crossPackageGroups = new Map();
   const unmappedSymbols = [];
   for (const symbolName of symbolNames) {
+    var _findExportForSourceF, _findExportForSourceF2;
     const exportInfo = exportMap.get(symbolName);
     if (!exportInfo) {
       unmappedSymbols.push(symbolName);
@@ -539,25 +542,47 @@ function traceSymbolsToExports({
 
     // Check for cross-package source first
     if (exportInfo.crossPackageSource) {
-      const key = `${exportInfo.crossPackageSource.packageName}${exportInfo.crossPackageSource.exportPath === '.' ? '' : exportInfo.crossPackageSource.exportPath.slice(1)}`;
+      let key;
+      let tracedOriginalName = exportInfo.originalName;
+      let barrelBridgeExportPath;
+      if (preferImportedPackageSubpath) {
+        const bridge = findCrossPackageBridgeExportPath({
+          exportsMap,
+          crossPackageName: exportInfo.crossPackageSource.packageName,
+          exportedName: symbolName,
+          fs
+        });
+        if (bridge) {
+          key = `${barrelPackageName}${bridge.exportPath.slice(1)}`;
+          barrelBridgeExportPath = bridge.exportPath;
+          if (bridge.entryPointExportName !== undefined) {
+            tracedOriginalName = bridge.entryPointExportName === symbolName ? undefined : bridge.entryPointExportName;
+          }
+        } else {
+          key = `${exportInfo.crossPackageSource.packageName}${exportInfo.crossPackageSource.exportPath === '.' ? '' : exportInfo.crossPackageSource.exportPath.slice(1)}`;
+        }
+      } else {
+        key = `${exportInfo.crossPackageSource.packageName}${exportInfo.crossPackageSource.exportPath === '.' ? '' : exportInfo.crossPackageSource.exportPath.slice(1)}`;
+      }
       if (!crossPackageGroups.has(key)) {
         crossPackageGroups.set(key, []);
       }
       crossPackageGroups.get(key).push({
         symbolName,
-        originalName: exportInfo.originalName,
+        originalName: tracedOriginalName,
         sourceFilePath: exportInfo.path,
         isTypeOnly: exportInfo.isTypeOnly,
-        crossPackageSource: exportInfo.crossPackageSource
+        crossPackageSource: exportInfo.crossPackageSource,
+        barrelBridgeExportPath
       });
       continue;
     }
 
     // First try to find an export that directly exposes the source file
-    let targetExportPath = findExportForSourceFile({
+    let targetExportPath = (_findExportForSourceF = (_findExportForSourceF2 = findExportForSourceFile({
       sourceFilePath: exportInfo.path,
       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)
@@ -613,6 +638,59 @@ function escapeRegExp(str) {
   return str.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
 }
 
+/** Mock object keys that are module interop metadata, not package exports. */
+const 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({
+  lineText,
+  oldBarrelPath,
+  targetImportPathForThisMock,
+  mockImplementationTextForGroup,
+  symbolToNewImportPath
+}) {
+  const requireActualRe = /jest\.requireActual(?:<[^>]*>)?\((['"])([^'"]+)\1\)/;
+  const requireMatch = requireActualRe.exec(lineText);
+  if (!requireMatch || requireMatch[2] !== oldBarrelPath) {
+    return lineText;
+  }
+  const quote = requireMatch[1];
+  const bindingMatch = /^\s*(?:const|let)\s+(\w+)\s*=/m.exec(lineText);
+  if (!bindingMatch) {
+    return lineText;
+  }
+  const binding = bindingMatch[1];
+  const propAccessRe = new RegExp(`\\b${escapeRegExp(binding)}\\.(\\w+)`, 'g');
+  const accessedProps = new Set();
+  let propMatch;
+  while ((propMatch = propAccessRe.exec(mockImplementationTextForGroup)) !== null) {
+    accessedProps.add(propMatch[1]);
+  }
+  if (accessedProps.size === 0) {
+    return lineText;
+  }
+  const resolvedPaths = [];
+  for (const prop of accessedProps) {
+    const mapped = symbolToNewImportPath.get(prop);
+    if (mapped) {
+      resolvedPaths.push(mapped);
+    }
+  }
+  if (resolvedPaths.length === 0) {
+    return lineText;
+  }
+  const uniquePaths = new Set(resolvedPaths);
+  if (uniquePaths.size !== 1 || !uniquePaths.has(targetImportPathForThisMock)) {
+    return lineText;
+  }
+  return lineText.replace(`jest.requireActual(${quote}${oldBarrelPath}${quote})`, `jest.requireActual(${quote}${targetImportPathForThisMock}${quote})`);
+}
+
 /**
  * Generate fix text for multiple jest.mock calls
  */
@@ -622,7 +700,10 @@ function generateMockFixes({
   packageName,
   mockProperties,
   quote,
-  preambleStatements
+  preambleStatements,
+  propagateEsModuleFromOriginalMock,
+  oldBarrelImportPath,
+  symbolToNewImportPath
 }) {
   const mockCalls = [];
 
@@ -631,8 +712,8 @@ function generateMockFixes({
     const propTexts = [];
     propTexts.push(`...jest.requireActual(${quote}${fullImportPath}${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');
     }
     for (const propName of group.propertyNames) {
@@ -669,15 +750,26 @@ function generateMockFixes({
         }
       }
     }
+    const combinedGroupImplText = group.propertyNames.map(name => {
+      var _ref, _group$propertyTexts$, _mockProperties$get;
+      return (_ref = (_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 && _ref !== void 0 ? _ref : '';
+    }).join('\n');
 
     // Determine if we need preamble for this group
     const neededPreamble = getNeededPreamble({
       propertyTexts: propTexts,
       allPreamble: preambleStatements
     });
+    const rewrittenPreamble = neededPreamble.map(p => rewritePreambleLineBarrelRequireActual({
+      lineText: p.text,
+      oldBarrelPath: oldBarrelImportPath,
+      targetImportPathForThisMock: fullImportPath,
+      mockImplementationTextForGroup: combinedGroupImplText,
+      symbolToNewImportPath
+    }));
     if (neededPreamble.length > 0) {
       // Generate block body arrow function with preamble
-      const preambleLines = neededPreamble.map(p => `\t${p.text}`).join('\n');
+      const preambleLines = rewrittenPreamble.map(text => `\t${text}`).join('\n');
       const formattedProps = propTexts.map(p => `\t\t${p},`).join('\n');
       return `jest.mock(${quote}${fullImportPath}${quote}, () => {\n${preambleLines}\n\treturn {\n${formattedProps}\n\t};\n})`;
     } else {
@@ -808,12 +900,17 @@ const 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."
   }
 };
 
@@ -825,9 +922,10 @@ export function createRule(fs) {
   return {
     meta: ruleMeta,
     create(context) {
-      var _options$applyToImpor;
+      var _options$applyToImpor, _options$preferImport;
       const options = context.options[0] || {};
       const applyToImportsFrom = (_options$applyToImpor = options.applyToImportsFrom) !== null && _options$applyToImpor !== void 0 ? _options$applyToImpor : DEFAULT_TARGET_FOLDERS;
+      const preferImportedPackageSubpath = (_options$preferImport = options.preferImportedPackageSubpath) !== null && _options$preferImport !== void 0 ? _options$preferImport : false;
       const workspaceRoot = findWorkspaceRoot({
         startPath: dirname(context.filename),
         fs,
@@ -836,6 +934,124 @@ export function createRule(fs) {
       return {
         CallExpression(rawNode) {
           const 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)) {
+            const raImportPath = extractImportPath(node);
+            if (!raImportPath) {
+              return;
+            }
+            const raContext = resolveJestMockContext({
+              importPath: raImportPath,
+              workspaceRoot,
+              fs,
+              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.
+            let ancestor = node.parent;
+            while (ancestor) {
+              if (ancestor.type === 'CallExpression' && isJestMockCall(ancestor)) {
+                const ancestorPath = extractImportPath(ancestor);
+                if (ancestorPath) {
+                  const ancestorCtx = resolveJestMockContext({
+                    importPath: ancestorPath,
+                    workspaceRoot,
+                    fs,
+                    applyToImportsFrom
+                  });
+                  if (ancestorCtx && isBarrelFile({
+                    exportMap: ancestorCtx.exportMap,
+                    entryFilePath: ancestorCtx.entryFilePath
+                  })) {
+                    return;
+                  }
+                }
+              }
+              ancestor = ancestor.parent;
+            }
+
+            // Determine which symbols are accessed from the barrel
+            const parent = node.parent;
+            const 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') {
+              for (const prop of parent.id.properties) {
+                if (prop.type === 'Property' && prop.key.type === 'Identifier') {
+                  accessedSymbols.push(prop.key.name);
+                }
+              }
+            }
+            if (accessedSymbols.length === 0) {
+              context.report({
+                node: node,
+                messageId: 'barrelEntryRequireActual',
+                data: {
+                  path: raImportPath
+                }
+              });
+              return;
+            }
+            const {
+              groupedByExport,
+              crossPackageGroups
+            } = traceSymbolsToExports({
+              symbolNames: accessedSymbols,
+              exportMap: raContext.exportMap,
+              exportsMap: raContext.exportsMap,
+              currentExportPath: raContext.currentExportPath,
+              fs,
+              barrelPackageName: raContext.packageName,
+              preferImportedPackageSubpath
+            });
+            let newPath = null;
+            if (groupedByExport.size === 1 && crossPackageGroups.size === 0) {
+              const [exportPath] = groupedByExport.keys();
+              newPath = `${raContext.packageName}${exportPath.slice(1)}`;
+            } else if (crossPackageGroups.size === 1 && groupedByExport.size === 0) {
+              const [cpImportPath] = crossPackageGroups.keys();
+              newPath = cpImportPath;
+            }
+            const sourceCode = context.getSourceCode();
+            if (newPath) {
+              const resolvedNewPath = newPath;
+              context.report({
+                node: node,
+                messageId: 'barrelEntryRequireActual',
+                data: {
+                  path: raImportPath
+                },
+                fix(fixer) {
+                  const firstArg = node.arguments[0];
+                  const quote = sourceCode.getText(firstArg)[0];
+                  return fixer.replaceText(firstArg, `${quote}${resolvedNewPath}${quote}`);
+                }
+              });
+            } else {
+              context.report({
+                node: node,
+                messageId: 'barrelEntryRequireActual',
+                data: {
+                  path: raImportPath
+                }
+              });
+            }
+            return;
+          }
           if (!isJestMockCall(node)) {
             return;
           }
@@ -883,7 +1099,8 @@ export function createRule(fs) {
           if (mockProperties.size === 0) {
             return;
           }
-          const symbolNames = Array.from(mockProperties.keys());
+          const originalMockHadEsModule = mockProperties.has('__esModule');
+          const symbolNames = Array.from(mockProperties.keys()).filter(name => !ESM_INTEROP_MOCK_KEYS.has(name));
           const {
             groupedByExport,
             crossPackageGroups,
@@ -893,7 +1110,9 @@ export function createRule(fs) {
             exportMap: mockContext.exportMap,
             exportsMap: mockContext.exportsMap,
             currentExportPath: mockContext.currentExportPath,
-            fs
+            fs,
+            barrelPackageName: mockContext.packageName,
+            preferImportedPackageSubpath
           });
 
           // If no symbols can be mapped to specific exports or cross-package sources,
@@ -939,8 +1158,9 @@ export function createRule(fs) {
 
             // Get cross-package source info from the first symbol (all symbols in same group have same source)
             const crossPackageSource = symbols[0].crossPackageSource;
+            const bridgeExportPath = symbols[0].barrelBridgeExportPath;
             crossPackageMockGroups.push({
-              exportPath: crossPackageSource.exportPath,
+              exportPath: bridgeExportPath !== null && bridgeExportPath !== void 0 ? bridgeExportPath : crossPackageSource.exportPath,
               importPath,
               propertyNames: symbols.map(s => s.symbolName),
               propertyTexts: new Map(symbols.map(s => [s.symbolName, mockProperties.get(s.symbolName).text])),
@@ -1028,22 +1248,36 @@ export function createRule(fs) {
                   mergedGroups.push(group);
                 }
               }
-              const fixText = generateMockFixes({
+              const symbolToNewImportPath = new Map();
+              for (const group of [...mergedGroups, ...crossPackageMockGroups]) {
+                for (const propName of group.propertyNames) {
+                  symbolToNewImportPath.set(propName, group.importPath);
+                }
+              }
+              let fixText = generateMockFixes({
                 groups: mergedGroups,
                 crossPackageGroups: crossPackageMockGroups,
                 packageName: mockContext.packageName,
                 mockProperties,
                 quote,
-                preambleStatements
+                preambleStatements,
+                propagateEsModuleFromOriginalMock: originalMockHadEsModule,
+                oldBarrelImportPath: oldImportPath,
+                symbolToNewImportPath
               });
 
-              // Build a map of symbol name -> new import path for jest.requireMock() rewriting
-              const symbolToNewImportPath = new Map();
-              for (const group of [...mergedGroups, ...crossPackageMockGroups]) {
-                for (const propName of group.propertyNames) {
-                  symbolToNewImportPath.set(propName, group.importPath);
+              // 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, (match, _q, path, symbol) => {
+                if (path !== oldImportPath) {
+                  return match;
                 }
-              }
+                const newPath = symbolToNewImportPath.get(symbol);
+                if (newPath && newPath !== path) {
+                  return match.replace(path, newPath);
+                }
+                return match;
+              });
 
               // Sort nodes by position
               const sortedNodesToRemove = nodesToRemove.sort((a, b) => {
@@ -1101,6 +1335,34 @@ export function createRule(fs) {
                   fixes.push(fixer.replaceText(requireMockArg, `${quote}${newPath}${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).
+              const replacedRanges = sortedNodesToRemove.map(n => n.range);
+              const requireActualCalls = findJestRequireActualCalls({
+                ast,
+                matchPath: candidatePath => candidatePath === oldImportPath
+              });
+              for (const raNode of requireActualCalls) {
+                const raArg = raNode.arguments[0];
+                if (!raArg || !raNode.range) {
+                  continue;
+                }
+
+                // Skip calls inside any node being replaced (ranges overlap)
+                const insideReplacedNode = replacedRanges.some(([start, end]) => raNode.range[0] >= start && raNode.range[1] <= end);
+                if (insideReplacedNode) {
+                  continue;
+                }
+                const newPath = resolveNewPathForRequireMock({
+                  requireMockNode: raNode,
+                  symbolToNewPath: symbolToNewImportPath
+                });
+                if (newPath) {
+                  fixes.push(fixer.replaceText(raArg, `${quote}${newPath}${quote}`));
+                }
+              }
               return fixes;
             }
           });

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

@@ -152,6 +152,7 @@ function getImportPathForSourceFile({
   var _exportInfo$crossPack;
   const crossPackageName = exportInfo === null || exportInfo === void 0 ? void 0 : (_exportInfo$crossPack = exportInfo.crossPackageSource) === null || _exportInfo$crossPack === void 0 ? void 0 : _exportInfo$crossPack.packageName;
   if (crossPackageName) {
+    var _findExportForSourceF;
     const sourcePackageExportsMaps = getSourcePackageExportsMaps(fs);
     let exportsMap = sourcePackageExportsMaps.get(crossPackageName);
     if (!exportsMap) {
@@ -168,10 +169,10 @@ function getImportPathForSourceFile({
         sourcePackageExportsMaps.set(crossPackageName, exportsMap);
       }
     }
-    const targetExportPath = exportsMap ? findExportForSourceFile({
+    const targetExportPath = exportsMap ? (_findExportForSourceF = findExportForSourceFile({
       sourceFilePath,
       exportsMap
-    }) : null;
+    })) === null || _findExportForSourceF === void 0 ? void 0 : _findExportForSourceF.exportPath : null;
     return targetExportPath ? crossPackageName + targetExportPath.slice(1) : crossPackageName;
   }
   return getRelativeImportPath({

package/dist/es2019/rules/import/no-relative-barrel-file-imports/index.js

@@ -54,6 +54,7 @@ function getImportPathForSourceFile({
   var _exportInfo$crossPack;
   const crossPackageName = exportInfo === null || exportInfo === void 0 ? void 0 : (_exportInfo$crossPack = exportInfo.crossPackageSource) === null || _exportInfo$crossPack === void 0 ? void 0 : _exportInfo$crossPack.packageName;
   if (crossPackageName) {
+    var _findExportForSourceF;
     const sourcePackageExportsMaps = getSourcePackageExportsMaps(fs);
     let exportsMap = sourcePackageExportsMaps.get(crossPackageName);
     if (!exportsMap) {
@@ -70,10 +71,10 @@ function getImportPathForSourceFile({
         sourcePackageExportsMaps.set(crossPackageName, exportsMap);
       }
     }
-    const targetExportPath = exportsMap ? findExportForSourceFile({
+    const targetExportPath = exportsMap ? (_findExportForSourceF = findExportForSourceFile({
       sourceFilePath,
       exportsMap
-    }) : null;
+    })) === null || _findExportForSourceF === void 0 ? void 0 : _findExportForSourceF.exportPath : null;
     return targetExportPath ? crossPackageName + targetExportPath.slice(1) : crossPackageName;
   }
   return getRelativeImportPath({
@@ -437,10 +438,13 @@ function transformExportSpecifiers({
 }) {
   return specsWithOriginal.map(({
     originalName,
+    nameInSource,
     nameInLocal,
     kind
   }) => ({
-    nameInSource: originalName || 'default',
+    // Use originalName if available (means there was an alias in the barrel),
+    // otherwise use nameInSource (the direct export name from the barrel)
+    nameInSource: originalName !== null && originalName !== void 0 ? originalName : nameInSource,
     nameInLocal,
     kind
   }));

package/dist/es2019/rules/import/shared/jest-utils.js

@@ -112,6 +112,50 @@ export function findJestRequireMockCalls({
   return results;
 }
 
+/**
+ * Find all jest.requireActual() calls in the AST whose import path matches a given target.
+ * Works identically to findJestRequireMockCalls but for requireActual.
+ */
+export function findJestRequireActualCalls({
+  ast,
+  matchPath
+}) {
+  const results = [];
+  const visited = new WeakSet();
+  const skipKeys = new Set(['parent', 'loc', 'range', 'tokens', 'comments']);
+  function visit(node) {
+    if (visited.has(node)) {
+      return;
+    }
+    visited.add(node);
+    if (node.type === 'CallExpression' && isJestRequireActual(node)) {
+      const path = extractImportPath(node);
+      if (path && matchPath(path)) {
+        results.push(node);
+      }
+    }
+    for (const key in node) {
+      if (skipKeys.has(key)) {
+        continue;
+      }
+      const value = node[key];
+      if (value && typeof value === 'object') {
+        if (Array.isArray(value)) {
+          for (const child of value) {
+            if (child && typeof child === 'object' && 'type' in child) {
+              visit(child);
+            }
+          }
+        } else if ('type' in value) {
+          visit(value);
+        }
+      }
+    }
+  }
+  visit(ast);
+  return results;
+}
+
 /**
  * Determine the best new import path for a jest.requireMock() call by inspecting
  * the destructured symbols or property access at the call site.