@atlaskit/eslint-plugin-platform 2.8.0 → 2.9.0

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

@@ -110,20 +110,15 @@ function buildImportStatement({
  */
 
 /**
- * Resolves import context for barrel file analysis.
+ * Resolves import context for barrel file analysis from a module specifier string.
  * Returns null if the import should not be processed (relative import, not in target folder, etc.)
  */
-function resolveImportContext({
-  node,
+function resolveImportContextFromModulePath({
+  importPath,
   workspaceRoot,
   fs,
   applyToImportsFrom
 }) {
-  if (!node.source || typeof node.source.value !== 'string') {
-    return null;
-  }
-  const importPath = node.source.value;
-
   // Skip relative imports - this rule is for cross-package imports
   if (isRelativeImport(importPath)) {
     return null;
@@ -197,6 +192,27 @@ function resolveImportContext({
   };
 }
 
+/**
+ * Resolves import context for barrel file analysis.
+ * Returns null if the import should not be processed (relative import, not in target folder, etc.)
+ */
+function resolveImportContext({
+  node,
+  workspaceRoot,
+  fs,
+  applyToImportsFrom
+}) {
+  if (!node.source || typeof node.source.value !== 'string') {
+    return null;
+  }
+  return resolveImportContextFromModulePath({
+    importPath: node.source.value,
+    workspaceRoot,
+    fs,
+    applyToImportsFrom
+  });
+}
+
 /**
  * Classifies import specifiers by their target export paths.
  * Groups specifiers that can be remapped to more specific exports.
@@ -238,7 +254,7 @@ function classifySpecifiers({
     }
     const exportInfo = exportMap.get(nameInSource);
     if (exportInfo) {
-      var _exportInfo$crossPack;
+      var _exportInfo$crossPack, _exportInfo$originalN2, _matchResult$exportPa2;
       const effectiveKind = kind === 'type' || exportInfo.isTypeOnly ? 'type' : 'value';
 
       // Check if this is a cross-package re-export
@@ -264,11 +280,20 @@ function classifySpecifiers({
 
         // Find the best export path in the source package
         let targetExportPath = null;
+        let resolvedOriginalName = exportInfo.originalName;
         if (sourcePackageExportsMap) {
-          targetExportPath = findExportForSourceFile({
+          var _exportInfo$originalN, _matchResult$exportPa;
+          const sourceExportName = (_exportInfo$originalN = exportInfo.originalName) !== null && _exportInfo$originalN !== void 0 ? _exportInfo$originalN : nameInSource;
+          const matchResult = findExportForSourceFile({
             sourceFilePath: exportInfo.path,
-            exportsMap: sourcePackageExportsMap
+            exportsMap: sourcePackageExportsMap,
+            fs,
+            sourceExportName
           });
+          targetExportPath = (_matchResult$exportPa = matchResult === null || matchResult === void 0 ? void 0 : matchResult.exportPath) !== null && _matchResult$exportPa !== void 0 ? _matchResult$exportPa : null;
+          if ((matchResult === null || matchResult === void 0 ? void 0 : matchResult.entryPointExportName) !== undefined) {
+            resolvedOriginalName = matchResult.entryPointExportName === nameInSource ? undefined : matchResult.entryPointExportName;
+          }
         }
 
         // Build the full import path: @package/subpath or just @package if no subpath found
@@ -282,7 +307,7 @@ function classifySpecifiers({
             ...spec,
             importKind: effectiveKind
           },
-          originalName: exportInfo.originalName,
+          originalName: resolvedOriginalName,
           targetExportPath: targetKey,
           kind: effectiveKind,
           sourcePackageName
@@ -291,10 +316,18 @@ function classifySpecifiers({
       }
 
       // Find if there's a package.json export that points to this source file
-      const targetExportPath = findExportForSourceFile({
+      const sourceExportName = (_exportInfo$originalN2 = exportInfo.originalName) !== null && _exportInfo$originalN2 !== void 0 ? _exportInfo$originalN2 : nameInSource;
+      const matchResult = findExportForSourceFile({
         sourceFilePath: exportInfo.path,
-        exportsMap
+        exportsMap,
+        fs,
+        sourceExportName
       });
+      const targetExportPath = (_matchResult$exportPa2 = matchResult === null || matchResult === void 0 ? void 0 : matchResult.exportPath) !== null && _matchResult$exportPa2 !== void 0 ? _matchResult$exportPa2 : null;
+      let resolvedOriginalName2 = exportInfo.originalName;
+      if ((matchResult === null || matchResult === void 0 ? void 0 : matchResult.entryPointExportName) !== undefined) {
+        resolvedOriginalName2 = matchResult.entryPointExportName === nameInSource ? undefined : matchResult.entryPointExportName;
+      }
 
       // Get the file that the current export path resolves to
       const currentExportResolvedFile = exportsMap.get(currentExportPath);
@@ -314,7 +347,7 @@ function classifySpecifiers({
             ...spec,
             importKind: effectiveKind
           },
-          originalName: exportInfo.originalName,
+          originalName: resolvedOriginalName2,
           targetExportPath,
           kind: effectiveKind
         });
@@ -686,6 +719,312 @@ function createBarrelImportFix({
   }
   return fixes;
 }
+function isPlainRequireCall(node) {
+  if (node.callee.type !== 'Identifier' || node.callee.name !== 'require') {
+    return false;
+  }
+  if (node.arguments.length !== 1) {
+    return false;
+  }
+  const arg = node.arguments[0];
+  return arg.type === 'Literal' && typeof arg.value === 'string';
+}
+function unwrapToRequireCall(expr) {
+  let e = expr;
+  for (;;) {
+    const wrapped = e;
+    if (wrapped.type !== 'ParenthesizedExpression' || !wrapped.expression) {
+      break;
+    }
+    e = wrapped.expression;
+  }
+  if (e.type !== 'CallExpression' || !isPlainRequireCall(e)) {
+    return null;
+  }
+  return e;
+}
+function buildSyntheticImportFromRequireAccess(exportPropertyName, modulePath) {
+  const specifiers = exportPropertyName === 'default' ? [{
+    type: 'ImportDefaultSpecifier',
+    local: {
+      type: 'Identifier',
+      name: '_r'
+    }
+  }] : [{
+    type: 'ImportSpecifier',
+    imported: {
+      type: 'Identifier',
+      name: exportPropertyName
+    },
+    local: {
+      type: 'Identifier',
+      name: exportPropertyName
+    }
+  }];
+  return {
+    type: 'ImportDeclaration',
+    source: {
+      type: 'Literal',
+      value: modulePath,
+      raw: `'${modulePath}'`
+    },
+    specifiers,
+    importKind: 'value'
+  };
+}
+function fullNewImportPathForTarget(targetKey, specsWithTarget, packageName) {
+  const isCrossPackage = specsWithTarget.some(s => s.sourcePackageName);
+  return isCrossPackage ? targetKey : packageName + targetKey.slice(1);
+}
+function getRhsPropertyAfterTransform(spec) {
+  if (spec.type === 'ImportDefaultSpecifier') {
+    return 'default';
+  }
+  return getImportedName(spec);
+}
+function appendAutomockFixesForPathMigration({
+  fixer,
+  sourceCode,
+  oldBarrelPath,
+  newPaths
+}) {
+  const automocks = findMatchingAutomocks({
+    sourceCode,
+    importPath: oldBarrelPath
+  });
+  if (automocks.length === 0 || newPaths.length === 0) {
+    return [];
+  }
+  const fixes = [];
+  for (const automock of automocks) {
+    const newAutomockStatements = newPaths.map(path => buildAutomockStatement({
+      path,
+      quoteChar: automock.quoteChar
+    }));
+    fixes.push(fixer.replaceTextRange(automock.statementNode.range, newAutomockStatements.join('\n')));
+  }
+  return fixes;
+}
+
+/**
+ * `require('barrel').default` or `require('barrel').namedExport`
+ */
+function handleRequireMemberExpression({
+  node,
+  context,
+  workspaceRoot,
+  fs,
+  applyToImportsFrom
+}) {
+  if (node.computed || node.property.type !== 'Identifier') {
+    return;
+  }
+  const reqCall = unwrapToRequireCall(node.object);
+  if (!reqCall) {
+    return;
+  }
+  const modulePath = reqCall.arguments[0].value;
+  const importContext = resolveImportContextFromModulePath({
+    importPath: modulePath,
+    workspaceRoot,
+    fs,
+    applyToImportsFrom
+  });
+  if (!importContext) {
+    return;
+  }
+  const exportPropertyName = node.property.name;
+  const synthetic = buildSyntheticImportFromRequireAccess(exportPropertyName, modulePath);
+  const {
+    specifiersByTarget,
+    hasNamespaceImport
+  } = classifySpecifiers({
+    node: synthetic,
+    importContext,
+    workspaceRoot,
+    fs
+  });
+  if (hasNamespaceImport || specifiersByTarget.size === 0) {
+    return;
+  }
+  const entries = [...specifiersByTarget.entries()];
+  if (entries.length !== 1) {
+    return;
+  }
+  const [targetKey, specsWithTarget] = entries[0];
+  if (specsWithTarget.length !== 1) {
+    return;
+  }
+  const st = specsWithTarget[0];
+  const newImportPath = fullNewImportPathForTarget(targetKey, specsWithTarget, importContext.packageName);
+  const transformed = transformSpecifierForExport({
+    spec: st.spec,
+    originalName: st.originalName,
+    kind: st.kind
+  });
+  const newRhs = getRhsPropertyAfterTransform(transformed);
+  const sourceCode = context.getSourceCode();
+  const quote = sourceCode.getText(reqCall.arguments[0])[0];
+  context.report({
+    node: node,
+    messageId: 'barrelEntryImport',
+    data: {
+      path: importContext.importPath
+    },
+    fix(fixer) {
+      const fixes = [];
+      fixes.push(fixer.replaceText(node, `require(${quote}${newImportPath}${quote}).${newRhs}`));
+      if (st.kind === 'value') {
+        fixes.push(...appendAutomockFixesForPathMigration({
+          fixer,
+          sourceCode,
+          oldBarrelPath: modulePath,
+          newPaths: [newImportPath]
+        }));
+      }
+      return fixes;
+    }
+  });
+}
+
+/**
+ * `const { a, b } = require('barrel')`
+ */
+function handleRequireDestructuringDeclarator({
+  node,
+  context,
+  workspaceRoot,
+  fs,
+  applyToImportsFrom
+}) {
+  if (node.id.type !== 'ObjectPattern' || !node.init || node.init.type !== 'CallExpression') {
+    return;
+  }
+  const initCall = node.init;
+  if (!isPlainRequireCall(initCall)) {
+    return;
+  }
+  const modulePath = initCall.arguments[0].value;
+  const importContext = resolveImportContextFromModulePath({
+    importPath: modulePath,
+    workspaceRoot,
+    fs,
+    applyToImportsFrom
+  });
+  if (!importContext) {
+    return;
+  }
+  const specifiers = [];
+  for (const prop of node.id.properties) {
+    if (prop.type !== 'Property' || prop.computed) {
+      continue;
+    }
+    if (prop.key.type !== 'Identifier' || prop.value.type !== 'Identifier') {
+      continue;
+    }
+    const importedName = prop.key.name;
+    const localName = prop.value.name;
+    specifiers.push({
+      type: 'ImportSpecifier',
+      imported: {
+        type: 'Identifier',
+        name: importedName
+      },
+      local: {
+        type: 'Identifier',
+        name: localName
+      }
+    });
+  }
+  if (specifiers.length === 0) {
+    return;
+  }
+  const synthetic = {
+    type: 'ImportDeclaration',
+    source: {
+      type: 'Literal',
+      value: modulePath,
+      raw: `'${modulePath}'`
+    },
+    specifiers,
+    importKind: 'value'
+  };
+  const {
+    specifiersByTarget,
+    unmappedSpecifiers,
+    hasNamespaceImport
+  } = classifySpecifiers({
+    node: synthetic,
+    importContext,
+    workspaceRoot,
+    fs
+  });
+  if (hasNamespaceImport || specifiersByTarget.size === 0 || unmappedSpecifiers.length > 0) {
+    return;
+  }
+  const parentDecl = node.parent;
+  if (parentDecl.type !== 'VariableDeclaration') {
+    return;
+  }
+  if (specifiersByTarget.size > 1 && parentDecl.declarations.length !== 1) {
+    return;
+  }
+  const sourceCode = context.getSourceCode();
+  const quote = sourceCode.getText(initCall.arguments[0])[0];
+  const pkg = importContext.packageName;
+  const buildFixes = fixer => {
+    const fixes = [];
+    let hasValue = false;
+    const automockPaths = [];
+    if (specifiersByTarget.size === 1) {
+      const [targetKey, specsWithTarget] = [...specifiersByTarget.entries()][0];
+      const newImportPath = fullNewImportPathForTarget(targetKey, specsWithTarget, pkg);
+      if (specsWithTarget.some(s => s.kind === 'value')) {
+        hasValue = true;
+        automockPaths.push(newImportPath);
+      }
+      fixes.push(fixer.replaceText(initCall.arguments[0], `${quote}${newImportPath}${quote}`));
+    } else {
+      const lines = [];
+      for (const [targetKey, specsWithTarget] of specifiersByTarget) {
+        const newImportPath = fullNewImportPathForTarget(targetKey, specsWithTarget, pkg);
+        if (specsWithTarget.some(s => s.kind === 'value')) {
+          hasValue = true;
+          automockPaths.push(newImportPath);
+        }
+        for (const st of specsWithTarget) {
+          const transformed = transformSpecifierForExport({
+            spec: st.spec,
+            originalName: st.originalName,
+            kind: st.kind
+          });
+          const rhs = getRhsPropertyAfterTransform(transformed);
+          const local = st.spec.local.name;
+          lines.push(`${local} = require(${quote}${newImportPath}${quote}).${rhs}`);
+        }
+      }
+      const declText = lines.map(l => `${parentDecl.kind} ${l};`).join('\n');
+      fixes.push(fixer.replaceText(parentDecl, declText));
+    }
+    if (hasValue) {
+      fixes.push(...appendAutomockFixesForPathMigration({
+        fixer,
+        sourceCode,
+        oldBarrelPath: modulePath,
+        newPaths: [...new Set(automockPaths)]
+      }));
+    }
+    return fixes;
+  };
+  context.report({
+    node: initCall,
+    messageId: 'barrelEntryImport',
+    data: {
+      path: importContext.importPath
+    },
+    fix: buildFixes
+  });
+}
 
 /**
  * Handles an ImportDeclaration node to check for barrel file imports.
@@ -792,6 +1131,24 @@ export function createRule(fs) {
             fs,
             applyToImportsFrom
           });
+        },
+        MemberExpression(rawNode) {
+          handleRequireMemberExpression({
+            node: rawNode,
+            context,
+            workspaceRoot,
+            fs,
+            applyToImportsFrom
+          });
+        },
+        VariableDeclarator(rawNode) {
+          handleRequireDestructuringDeclarator({
+            node: rawNode,
+            context,
+            workspaceRoot,
+            fs,
+            applyToImportsFrom
+          });
         }
       };
     }