@atlaskit/eslint-plugin-platform 2.8.0 → 2.9.0

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

@@ -2,7 +2,7 @@ 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 { realFileSystem } from '../shared/types';
@@ -531,6 +531,7 @@ function traceSymbolsToExports({
   const crossPackageGroups = new Map();
   const unmappedSymbols = [];
   for (const symbolName of symbolNames) {
+    var _findExportForSourceF, _findExportForSourceF2;
     const exportInfo = exportMap.get(symbolName);
     if (!exportInfo) {
       unmappedSymbols.push(symbolName);
@@ -554,10 +555,10 @@ function traceSymbolsToExports({
     }
 
     // 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 +614,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 +676,10 @@ function generateMockFixes({
   packageName,
   mockProperties,
   quote,
-  preambleStatements
+  preambleStatements,
+  propagateEsModuleFromOriginalMock,
+  oldBarrelImportPath,
+  symbolToNewImportPath
 }) {
   const mockCalls = [];
 
@@ -631,8 +688,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 +726,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 {
@@ -813,7 +881,8 @@ const ruleMeta = {
     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."
   }
 };
 
@@ -836,6 +905,122 @@ 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
+            });
+            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 +1068,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,
@@ -1028,22 +1214,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 +1301,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.

package/dist/es2019/rules/import/shared/package-resolution.js

@@ -1,6 +1,65 @@
-import { join } from 'path';
-import { readFileContent, resolveImportPath } from './file-system';
+import { dirname, join } from 'path';
+import * as ts from 'typescript';
+import { isRelativeImport, readFileContent, resolveImportPath } from './file-system';
 import { findPackageInRegistry } from './package-registry';
+const ENTRY_POINT_FOLDER_NAMES = new Set(['entry-points', 'entrypoints', 'entrypoint', 'entry-point']);
+function isInEntryPointsFolder(filePath) {
+  const parts = filePath.split(/[/\\]/);
+  return parts.some(part => ENTRY_POINT_FOLDER_NAMES.has(part));
+}
+/**
+ * Parse an entry-point wrapper file and resolve the source files it re-exports from,
+ * along with name mappings (source export name → entry-point export name).
+ */
+function resolveEntryPointReExports({
+  entryPointFilePath,
+  fs
+}) {
+  const content = readFileContent({
+    filePath: entryPointFilePath,
+    fs
+  });
+  if (!content) {
+    return [];
+  }
+  try {
+    const sourceFile = ts.createSourceFile(entryPointFilePath, content, ts.ScriptTarget.Latest, true);
+    const basedir = dirname(entryPointFilePath);
+    const results = [];
+    for (const statement of sourceFile.statements) {
+      if (ts.isExportDeclaration(statement) && statement.moduleSpecifier && ts.isStringLiteral(statement.moduleSpecifier)) {
+        const modulePath = statement.moduleSpecifier.text;
+        if (!isRelativeImport(modulePath)) {
+          continue;
+        }
+        const resolved = resolveImportPath({
+          basedir,
+          importPath: modulePath,
+          fs
+        });
+        if (!resolved) {
+          continue;
+        }
+        const nameMap = new Map();
+        if (statement.exportClause && ts.isNamedExports(statement.exportClause)) {
+          for (const element of statement.exportClause.elements) {
+            const exportedName = element.name.text;
+            const sourceName = element.propertyName ? element.propertyName.text : exportedName;
+            nameMap.set(sourceName, exportedName);
+          }
+        }
+        results.push({
+          sourcePath: resolved,
+          nameMap
+        });
+      }
+    }
+    return results;
+  } catch {
+    return [];
+  }
+}
+
 /**
  * Parse the package.json exports field and return a map of export paths to resolved file paths.
  */
@@ -76,18 +135,51 @@ export function parsePackageExports({
   });
   return exportsMap;
 }
-
 /**
  * Find a matching export entry for a given source file path.
  * Returns the export path (e.g., "./controllers/analytics") or null if not found.
+ *
+ * When `fs` is provided, also checks entry-point wrapper files. If an export resolves
+ * to a file inside a recognized entry-points folder (entry-points, entrypoints, etc.),
+ * the wrapper is parsed to see if it re-exports from `sourceFilePath`.
+ *
+ * `sourceExportName` is the name under which the symbol is exported from the source file
+ * (e.g. `'default'`). Used to look up the corresponding entry-point export name so the
+ * caller can generate the correct import style.
  */
 export function findExportForSourceFile({
   sourceFilePath,
-  exportsMap
+  exportsMap,
+  fs,
+  sourceExportName
 }) {
   for (const [exportPath, resolvedPath] of exportsMap) {
     if (resolvedPath === sourceFilePath) {
-      return exportPath;
+      return {
+        exportPath
+      };
+    }
+  }
+  if (fs) {
+    for (const [exportPath, resolvedPath] of exportsMap) {
+      if (isInEntryPointsFolder(resolvedPath)) {
+        const reExports = resolveEntryPointReExports({
+          entryPointFilePath: resolvedPath,
+          fs
+        });
+        for (const reExport of reExports) {
+          if (reExport.sourcePath === sourceFilePath) {
+            let entryPointExportName;
+            if (sourceExportName !== undefined && reExport.nameMap.has(sourceExportName)) {
+              entryPointExportName = reExport.nameMap.get(sourceExportName);
+            }
+            return {
+              exportPath,
+              entryPointExportName
+            };
+          }
+        }
+      }
     }
   }
   return null;