@atlaskit/eslint-plugin-platform 2.8.0 → 2.9.1

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

@@ -48,6 +48,10 @@ 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 imported barrel package when they bridge to the dependency (e.g. @scope/pkg/subpath instead of @scope/dependency).'
       }
     },
     additionalProperties: false
@@ -137,19 +141,14 @@ function buildImportStatement(_ref) {
  */
 
 /**
- * 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(_ref2) {
-  var node = _ref2.node,
+function resolveImportContextFromModulePath(_ref2) {
+  var importPath = _ref2.importPath,
     workspaceRoot = _ref2.workspaceRoot,
     fs = _ref2.fs,
     applyToImportsFrom = _ref2.applyToImportsFrom;
-  if (!node.source || typeof node.source.value !== 'string') {
-    return null;
-  }
-  var importPath = node.source.value;
-
   // Skip relative imports - this rule is for cross-package imports
   if ((0, _fileSystem.isRelativeImport)(importPath)) {
     return null;
@@ -223,19 +222,41 @@ function resolveImportContext(_ref2) {
   };
 }
 
+/**
+ * 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(_ref3) {
+  var node = _ref3.node,
+    workspaceRoot = _ref3.workspaceRoot,
+    fs = _ref3.fs,
+    applyToImportsFrom = _ref3.applyToImportsFrom;
+  if (!node.source || typeof node.source.value !== 'string') {
+    return null;
+  }
+  return resolveImportContextFromModulePath({
+    importPath: node.source.value,
+    workspaceRoot: workspaceRoot,
+    fs: fs,
+    applyToImportsFrom: applyToImportsFrom
+  });
+}
+
 /**
  * Classifies import specifiers by their target export paths.
  * Groups specifiers that can be remapped to more specific exports.
  * For cross-package re-exports, suggests importing from the source package's most specific subpath.
  */
-function classifySpecifiers(_ref3) {
-  var node = _ref3.node,
-    importContext = _ref3.importContext,
-    workspaceRoot = _ref3.workspaceRoot,
-    fs = _ref3.fs;
+function classifySpecifiers(_ref4) {
+  var node = _ref4.node,
+    importContext = _ref4.importContext,
+    workspaceRoot = _ref4.workspaceRoot,
+    fs = _ref4.fs,
+    preferImportedPackageSubpath = _ref4.preferImportedPackageSubpath;
   var currentExportPath = importContext.currentExportPath,
     exportsMap = importContext.exportsMap,
-    exportMap = importContext.exportMap;
+    exportMap = importContext.exportMap,
+    importedPackageName = importContext.packageName;
   var specifiers = node.specifiers;
   var specifiersByTarget = new Map();
   var unmappedSpecifiers = [];
@@ -256,6 +277,7 @@ function classifySpecifiers(_ref3) {
       var kind = 'value';
       if (spec.type === 'ImportDefaultSpecifier') {
         nameInSource = 'default';
+        kind = node.importKind === 'type' ? 'type' : 'value';
       } else if (spec.type === 'ImportSpecifier') {
         nameInSource = getImportedName(spec);
         var parentImportKind = node.importKind;
@@ -265,12 +287,42 @@ function classifySpecifiers(_ref3) {
       }
       var exportInfo = exportMap.get(nameInSource);
       if (exportInfo) {
-        var _exportInfo$crossPack;
+        var _exportInfo$crossPack, _exportInfo$originalN2, _matchResult$exportPa2;
         var effectiveKind = kind === 'type' || exportInfo.isTypeOnly ? 'type' : 'value';
 
         // Check if this is a cross-package re-export
         var sourcePackageName = (_exportInfo$crossPack = exportInfo.crossPackageSource) === null || _exportInfo$crossPack === void 0 ? void 0 : _exportInfo$crossPack.packageName;
         if (sourcePackageName) {
+          var targetKey = void 0;
+          var resolvedOriginalName = exportInfo.originalName;
+          if (preferImportedPackageSubpath) {
+            var bridge = (0, _packageResolution.findCrossPackageBridgeExportPath)({
+              exportsMap: exportsMap,
+              crossPackageName: sourcePackageName,
+              exportedName: nameInSource,
+              fs: fs
+            });
+            if (bridge) {
+              targetKey = importedPackageName + bridge.exportPath.slice(1);
+              if (bridge.entryPointExportName !== undefined) {
+                resolvedOriginalName = bridge.entryPointExportName === nameInSource ? undefined : bridge.entryPointExportName;
+              }
+              if (!specifiersByTarget.has(targetKey)) {
+                specifiersByTarget.set(targetKey, []);
+              }
+              specifiersByTarget.get(targetKey).push({
+                spec: _objectSpread(_objectSpread({}, spec), {}, {
+                  importKind: effectiveKind
+                }),
+                originalName: resolvedOriginalName,
+                targetExportPath: targetKey,
+                kind: effectiveKind,
+                sourcePackageName: sourcePackageName
+              });
+              continue;
+            }
+          }
+
           // For cross-package re-exports, find the most specific subpath in the source package
           // Note: Package resolution is not constrained by applyToImportsFrom - any package can be resolved
           var sourcePackageExportsMap = sourcePackageExportsMaps.get(sourcePackageName);
@@ -292,14 +344,22 @@ function classifySpecifiers(_ref3) {
           // Find the best export path in the source package
           var _targetExportPath = null;
           if (sourcePackageExportsMap) {
-            _targetExportPath = (0, _packageResolution.findExportForSourceFile)({
+            var _exportInfo$originalN, _matchResult$exportPa;
+            var _sourceExportName = (_exportInfo$originalN = exportInfo.originalName) !== null && _exportInfo$originalN !== void 0 ? _exportInfo$originalN : nameInSource;
+            var _matchResult = (0, _packageResolution.findExportForSourceFile)({
               sourceFilePath: exportInfo.path,
-              exportsMap: sourcePackageExportsMap
+              exportsMap: sourcePackageExportsMap,
+              fs: fs,
+              sourceExportName: _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
-          var targetKey = _targetExportPath ? sourcePackageName + _targetExportPath.slice(1) // Remove leading '.' from subpath
+          targetKey = _targetExportPath ? sourcePackageName + _targetExportPath.slice(1) // Remove leading '.' from subpath
           : sourcePackageName;
           if (!specifiersByTarget.has(targetKey)) {
             specifiersByTarget.set(targetKey, []);
@@ -308,7 +368,7 @@ function classifySpecifiers(_ref3) {
             spec: _objectSpread(_objectSpread({}, spec), {}, {
               importKind: effectiveKind
             }),
-            originalName: exportInfo.originalName,
+            originalName: resolvedOriginalName,
             targetExportPath: targetKey,
             kind: effectiveKind,
             sourcePackageName: sourcePackageName
@@ -317,10 +377,18 @@ function classifySpecifiers(_ref3) {
         }
 
         // Find if there's a package.json export that points to this source file
-        var targetExportPath = (0, _packageResolution.findExportForSourceFile)({
+        var sourceExportName = (_exportInfo$originalN2 = exportInfo.originalName) !== null && _exportInfo$originalN2 !== void 0 ? _exportInfo$originalN2 : nameInSource;
+        var matchResult = (0, _packageResolution.findExportForSourceFile)({
           sourceFilePath: exportInfo.path,
-          exportsMap: exportsMap
+          exportsMap: exportsMap,
+          fs: fs,
+          sourceExportName: sourceExportName
         });
+        var targetExportPath = (_matchResult$exportPa2 = matchResult === null || matchResult === void 0 ? void 0 : matchResult.exportPath) !== null && _matchResult$exportPa2 !== void 0 ? _matchResult$exportPa2 : null;
+        var 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
         var currentExportResolvedFile = exportsMap.get(currentExportPath);
@@ -339,7 +407,7 @@ function classifySpecifiers(_ref3) {
             spec: _objectSpread(_objectSpread({}, spec), {}, {
               importKind: effectiveKind
             }),
-            originalName: exportInfo.originalName,
+            originalName: resolvedOriginalName2,
             targetExportPath: targetExportPath,
             kind: effectiveKind
           });
@@ -375,10 +443,10 @@ function classifySpecifiers(_ref3) {
  * Transforms a specifier to use the original export name (handling aliasing).
  * Converts named imports of default exports to ImportDefaultSpecifier.
  */
-function transformSpecifierForExport(_ref4) {
-  var spec = _ref4.spec,
-    originalName = _ref4.originalName,
-    kind = _ref4.kind;
+function transformSpecifierForExport(_ref5) {
+  var spec = _ref5.spec,
+    originalName = _ref5.originalName,
+    kind = _ref5.kind;
   if (!originalName) {
     return spec;
   }
@@ -427,12 +495,12 @@ function transformSpecifierForExport(_ref4) {
  * Merges new specifiers with an existing import declaration.
  * Returns the new import statement string.
  */
-function buildMergedImportStatement(_ref5) {
-  var existingImport = _ref5.existingImport,
-    newSpecs = _ref5.newSpecs,
-    newImportPath = _ref5.newImportPath,
-    nodeImportKind = _ref5.nodeImportKind,
-    quoteChar = _ref5.quoteChar;
+function buildMergedImportStatement(_ref6) {
+  var existingImport = _ref6.existingImport,
+    newSpecs = _ref6.newSpecs,
+    newImportPath = _ref6.newImportPath,
+    nodeImportKind = _ref6.nodeImportKind,
+    quoteChar = _ref6.quoteChar;
   var existingSpecs = existingImport.specifiers.map(function (s) {
     if (existingImport.importKind === 'type') {
       return _objectSpread(_objectSpread({}, s), {}, {
@@ -505,9 +573,9 @@ function getJestAutomock(node) {
 /**
  * Find all Jest automocks in the AST that match the given import path.
  */
-function findMatchingAutomocks(_ref6) {
-  var sourceCode = _ref6.sourceCode,
-    importPath = _ref6.importPath;
+function findMatchingAutomocks(_ref7) {
+  var sourceCode = _ref7.sourceCode,
+    importPath = _ref7.importPath;
   var automocks = [];
   var ast = sourceCode.ast;
   var _iterator2 = _createForOfIteratorHelper(ast.body),
@@ -531,9 +599,9 @@ function findMatchingAutomocks(_ref6) {
 /**
  * Build a jest.mock() statement string
  */
-function buildAutomockStatement(_ref7) {
-  var path = _ref7.path,
-    quoteChar = _ref7.quoteChar;
+function buildAutomockStatement(_ref8) {
+  var path = _ref8.path,
+    quoteChar = _ref8.quoteChar;
   return "jest.mock(".concat(quoteChar).concat(path).concat(quoteChar, ");");
 }
 
@@ -541,10 +609,10 @@ function buildAutomockStatement(_ref7) {
  * Creates a fix to remove a node with proper whitespace handling.
  * Removes surrounding newlines to avoid leaving blank lines.
  */
-function createNodeRemovalFix(_ref8) {
-  var fixer = _ref8.fixer,
-    node = _ref8.node,
-    sourceCode = _ref8.sourceCode;
+function createNodeRemovalFix(_ref9) {
+  var fixer = _ref9.fixer,
+    node = _ref9.node,
+    sourceCode = _ref9.sourceCode;
   var nodeStart = node.range[0];
   var nodeEnd = node.range[1];
 
@@ -570,13 +638,13 @@ function createNodeRemovalFix(_ref8) {
  * Generates new import statements and handles merging with existing imports.
  * Also updates Jest automocks (jest.mock calls with only a path) when present.
  */
-function createBarrelImportFix(_ref9) {
-  var fixer = _ref9.fixer,
-    node = _ref9.node,
-    context = _ref9.context,
-    importContext = _ref9.importContext,
-    specifiersByTarget = _ref9.specifiersByTarget,
-    unmappedSpecifiers = _ref9.unmappedSpecifiers;
+function createBarrelImportFix(_ref0) {
+  var fixer = _ref0.fixer,
+    node = _ref0.node,
+    context = _ref0.context,
+    importContext = _ref0.importContext,
+    specifiersByTarget = _ref0.specifiersByTarget,
+    unmappedSpecifiers = _ref0.unmappedSpecifiers;
   var importPath = importContext.importPath,
     packageName = importContext.packageName;
   var sourceCode = context.sourceCode;
@@ -618,10 +686,10 @@ function createBarrelImportFix(_ref9) {
       : packageName + targetExportPath.slice(1); // Remove leading '.' for same-package imports
 
       // Transform specifiers if needed (handle aliasing)
-      var specs = specsWithTarget.map(function (_ref1) {
-        var spec = _ref1.spec,
-          originalName = _ref1.originalName,
-          kind = _ref1.kind;
+      var specs = specsWithTarget.map(function (_ref10) {
+        var spec = _ref10.spec,
+          originalName = _ref10.originalName,
+          kind = _ref10.kind;
         return transformSpecifierForExport({
           spec: spec,
           originalName: originalName,
@@ -632,9 +700,9 @@ function createBarrelImportFix(_ref9) {
       // Check if any specifier in this group is a value import (not type-only)
       // Only add automock paths for value imports (types don't need mocking at runtime)
       if (automocks.length > 0) {
-        var hasValueImport = specsWithTarget.some(function (_ref10) {
-          var kind = _ref10.kind,
-            spec = _ref10.spec;
+        var hasValueImport = specsWithTarget.some(function (_ref11) {
+          var kind = _ref11.kind,
+            spec = _ref11.spec;
           return kind === 'value' && (spec.type !== 'ImportSpecifier' || spec.importKind !== 'type');
         });
         if (hasValueImport) {
@@ -666,7 +734,10 @@ function createBarrelImportFix(_ref9) {
         }
       } else {
         // Create new import
-        var _isTypeImport = node.importKind === 'type';
+        var allSpecsAreType = specsWithTarget.every(function (s) {
+          return s.kind === 'type';
+        });
+        var _isTypeImport = node.importKind === 'type' || allSpecsAreType;
         var importStatement = buildImportStatement({
           specs: specs,
           path: newImportPath,
@@ -692,7 +763,10 @@ function createBarrelImportFix(_ref9) {
     var unmappedSpecs = unmappedSpecifiers.map(function (u) {
       return u.spec;
     });
-    var isTypeImport = node.importKind === 'type';
+    var allUnmappedAreType = unmappedSpecifiers.every(function (u) {
+      return u.kind === 'type';
+    });
+    var isTypeImport = node.importKind === 'type' || allUnmappedAreType;
     var remainingImport = buildImportStatement({
       specs: unmappedSpecs,
       path: importPath,
@@ -705,9 +779,9 @@ function createBarrelImportFix(_ref9) {
 
     // If there are unmapped value specifiers and automocks, keep the original automock path too
     if (automocks.length > 0) {
-      var hasUnmappedValueImport = unmappedSpecifiers.some(function (_ref0) {
-        var kind = _ref0.kind,
-          spec = _ref0.spec;
+      var hasUnmappedValueImport = unmappedSpecifiers.some(function (_ref1) {
+        var kind = _ref1.kind,
+          spec = _ref1.spec;
         return kind === 'value' && (spec.type !== 'ImportSpecifier' || spec.importKind !== 'type');
       });
       if (hasUnmappedValueImport) {
@@ -758,17 +832,380 @@ function createBarrelImportFix(_ref9) {
   }
   return fixes;
 }
+function isPlainRequireCall(node) {
+  if (node.callee.type !== 'Identifier' || node.callee.name !== 'require') {
+    return false;
+  }
+  if (node.arguments.length !== 1) {
+    return false;
+  }
+  var arg = node.arguments[0];
+  return arg.type === 'Literal' && typeof arg.value === 'string';
+}
+function unwrapToRequireCall(expr) {
+  var e = expr;
+  for (;;) {
+    var 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) {
+  var 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: "'".concat(modulePath, "'")
+    },
+    specifiers: specifiers,
+    importKind: 'value'
+  };
+}
+function fullNewImportPathForTarget(targetKey, specsWithTarget, packageName) {
+  var isCrossPackage = specsWithTarget.some(function (s) {
+    return s.sourcePackageName;
+  });
+  return isCrossPackage ? targetKey : packageName + targetKey.slice(1);
+}
+function getRhsPropertyAfterTransform(spec) {
+  if (spec.type === 'ImportDefaultSpecifier') {
+    return 'default';
+  }
+  return getImportedName(spec);
+}
+function appendAutomockFixesForPathMigration(_ref12) {
+  var fixer = _ref12.fixer,
+    sourceCode = _ref12.sourceCode,
+    oldBarrelPath = _ref12.oldBarrelPath,
+    newPaths = _ref12.newPaths;
+  var automocks = findMatchingAutomocks({
+    sourceCode: sourceCode,
+    importPath: oldBarrelPath
+  });
+  if (automocks.length === 0 || newPaths.length === 0) {
+    return [];
+  }
+  var fixes = [];
+  var _iterator5 = _createForOfIteratorHelper(automocks),
+    _step5;
+  try {
+    var _loop3 = function _loop3() {
+      var automock = _step5.value;
+      var newAutomockStatements = newPaths.map(function (path) {
+        return buildAutomockStatement({
+          path: path,
+          quoteChar: automock.quoteChar
+        });
+      });
+      fixes.push(fixer.replaceTextRange(automock.statementNode.range, newAutomockStatements.join('\n')));
+    };
+    for (_iterator5.s(); !(_step5 = _iterator5.n()).done;) {
+      _loop3();
+    }
+  } catch (err) {
+    _iterator5.e(err);
+  } finally {
+    _iterator5.f();
+  }
+  return fixes;
+}
+
+/**
+ * `require('barrel').default` or `require('barrel').namedExport`
+ */
+function handleRequireMemberExpression(_ref13) {
+  var node = _ref13.node,
+    context = _ref13.context,
+    workspaceRoot = _ref13.workspaceRoot,
+    fs = _ref13.fs,
+    applyToImportsFrom = _ref13.applyToImportsFrom,
+    preferImportedPackageSubpath = _ref13.preferImportedPackageSubpath;
+  if (node.computed || node.property.type !== 'Identifier') {
+    return;
+  }
+  var reqCall = unwrapToRequireCall(node.object);
+  if (!reqCall) {
+    return;
+  }
+  var modulePath = reqCall.arguments[0].value;
+  var importContext = resolveImportContextFromModulePath({
+    importPath: modulePath,
+    workspaceRoot: workspaceRoot,
+    fs: fs,
+    applyToImportsFrom: applyToImportsFrom
+  });
+  if (!importContext) {
+    return;
+  }
+  var exportPropertyName = node.property.name;
+  var synthetic = buildSyntheticImportFromRequireAccess(exportPropertyName, modulePath);
+  var _classifySpecifiers = classifySpecifiers({
+      node: synthetic,
+      importContext: importContext,
+      workspaceRoot: workspaceRoot,
+      fs: fs,
+      preferImportedPackageSubpath: preferImportedPackageSubpath
+    }),
+    specifiersByTarget = _classifySpecifiers.specifiersByTarget,
+    hasNamespaceImport = _classifySpecifiers.hasNamespaceImport;
+  if (hasNamespaceImport || specifiersByTarget.size === 0) {
+    return;
+  }
+  var entries = (0, _toConsumableArray2.default)(specifiersByTarget.entries());
+  if (entries.length !== 1) {
+    return;
+  }
+  var _ref14 = entries[0],
+    _ref15 = (0, _slicedToArray2.default)(_ref14, 2),
+    targetKey = _ref15[0],
+    specsWithTarget = _ref15[1];
+  if (specsWithTarget.length !== 1) {
+    return;
+  }
+  var st = specsWithTarget[0];
+  var newImportPath = fullNewImportPathForTarget(targetKey, specsWithTarget, importContext.packageName);
+  var transformed = transformSpecifierForExport({
+    spec: st.spec,
+    originalName: st.originalName,
+    kind: st.kind
+  });
+  var newRhs = getRhsPropertyAfterTransform(transformed);
+  var sourceCode = context.getSourceCode();
+  var quote = sourceCode.getText(reqCall.arguments[0])[0];
+  context.report({
+    node: node,
+    messageId: 'barrelEntryImport',
+    data: {
+      path: importContext.importPath
+    },
+    fix: function fix(fixer) {
+      var fixes = [];
+      fixes.push(fixer.replaceText(node, "require(".concat(quote).concat(newImportPath).concat(quote, ").").concat(newRhs)));
+      if (st.kind === 'value') {
+        fixes.push.apply(fixes, (0, _toConsumableArray2.default)(appendAutomockFixesForPathMigration({
+          fixer: fixer,
+          sourceCode: sourceCode,
+          oldBarrelPath: modulePath,
+          newPaths: [newImportPath]
+        })));
+      }
+      return fixes;
+    }
+  });
+}
+
+/**
+ * `const { a, b } = require('barrel')`
+ */
+function handleRequireDestructuringDeclarator(_ref16) {
+  var node = _ref16.node,
+    context = _ref16.context,
+    workspaceRoot = _ref16.workspaceRoot,
+    fs = _ref16.fs,
+    applyToImportsFrom = _ref16.applyToImportsFrom,
+    preferImportedPackageSubpath = _ref16.preferImportedPackageSubpath;
+  if (node.id.type !== 'ObjectPattern' || !node.init || node.init.type !== 'CallExpression') {
+    return;
+  }
+  var initCall = node.init;
+  if (!isPlainRequireCall(initCall)) {
+    return;
+  }
+  var modulePath = initCall.arguments[0].value;
+  var importContext = resolveImportContextFromModulePath({
+    importPath: modulePath,
+    workspaceRoot: workspaceRoot,
+    fs: fs,
+    applyToImportsFrom: applyToImportsFrom
+  });
+  if (!importContext) {
+    return;
+  }
+  var specifiers = [];
+  var _iterator6 = _createForOfIteratorHelper(node.id.properties),
+    _step6;
+  try {
+    for (_iterator6.s(); !(_step6 = _iterator6.n()).done;) {
+      var prop = _step6.value;
+      if (prop.type !== 'Property' || prop.computed) {
+        continue;
+      }
+      if (prop.key.type !== 'Identifier' || prop.value.type !== 'Identifier') {
+        continue;
+      }
+      var importedName = prop.key.name;
+      var localName = prop.value.name;
+      specifiers.push({
+        type: 'ImportSpecifier',
+        imported: {
+          type: 'Identifier',
+          name: importedName
+        },
+        local: {
+          type: 'Identifier',
+          name: localName
+        }
+      });
+    }
+  } catch (err) {
+    _iterator6.e(err);
+  } finally {
+    _iterator6.f();
+  }
+  if (specifiers.length === 0) {
+    return;
+  }
+  var synthetic = {
+    type: 'ImportDeclaration',
+    source: {
+      type: 'Literal',
+      value: modulePath,
+      raw: "'".concat(modulePath, "'")
+    },
+    specifiers: specifiers,
+    importKind: 'value'
+  };
+  var _classifySpecifiers2 = classifySpecifiers({
+      node: synthetic,
+      importContext: importContext,
+      workspaceRoot: workspaceRoot,
+      fs: fs,
+      preferImportedPackageSubpath: preferImportedPackageSubpath
+    }),
+    specifiersByTarget = _classifySpecifiers2.specifiersByTarget,
+    unmappedSpecifiers = _classifySpecifiers2.unmappedSpecifiers,
+    hasNamespaceImport = _classifySpecifiers2.hasNamespaceImport;
+  if (hasNamespaceImport || specifiersByTarget.size === 0 || unmappedSpecifiers.length > 0) {
+    return;
+  }
+  var parentDecl = node.parent;
+  if (parentDecl.type !== 'VariableDeclaration') {
+    return;
+  }
+  if (specifiersByTarget.size > 1 && parentDecl.declarations.length !== 1) {
+    return;
+  }
+  var sourceCode = context.getSourceCode();
+  var quote = sourceCode.getText(initCall.arguments[0])[0];
+  var pkg = importContext.packageName;
+  var buildFixes = function buildFixes(fixer) {
+    var fixes = [];
+    var hasValue = false;
+    var automockPaths = [];
+    if (specifiersByTarget.size === 1) {
+      var _ref17 = (0, _toConsumableArray2.default)(specifiersByTarget.entries())[0],
+        _ref18 = (0, _slicedToArray2.default)(_ref17, 2),
+        targetKey = _ref18[0],
+        specsWithTarget = _ref18[1];
+      var newImportPath = fullNewImportPathForTarget(targetKey, specsWithTarget, pkg);
+      if (specsWithTarget.some(function (s) {
+        return s.kind === 'value';
+      })) {
+        hasValue = true;
+        automockPaths.push(newImportPath);
+      }
+      fixes.push(fixer.replaceText(initCall.arguments[0], "".concat(quote).concat(newImportPath).concat(quote)));
+    } else {
+      var lines = [];
+      var _iterator7 = _createForOfIteratorHelper(specifiersByTarget),
+        _step7;
+      try {
+        for (_iterator7.s(); !(_step7 = _iterator7.n()).done;) {
+          var _step7$value = (0, _slicedToArray2.default)(_step7.value, 2),
+            _targetKey = _step7$value[0],
+            _specsWithTarget = _step7$value[1];
+          var _newImportPath = fullNewImportPathForTarget(_targetKey, _specsWithTarget, pkg);
+          if (_specsWithTarget.some(function (s) {
+            return s.kind === 'value';
+          })) {
+            hasValue = true;
+            automockPaths.push(_newImportPath);
+          }
+          var _iterator8 = _createForOfIteratorHelper(_specsWithTarget),
+            _step8;
+          try {
+            for (_iterator8.s(); !(_step8 = _iterator8.n()).done;) {
+              var st = _step8.value;
+              var transformed = transformSpecifierForExport({
+                spec: st.spec,
+                originalName: st.originalName,
+                kind: st.kind
+              });
+              var rhs = getRhsPropertyAfterTransform(transformed);
+              var local = st.spec.local.name;
+              lines.push("".concat(local, " = require(").concat(quote).concat(_newImportPath).concat(quote, ").").concat(rhs));
+            }
+          } catch (err) {
+            _iterator8.e(err);
+          } finally {
+            _iterator8.f();
+          }
+        }
+      } catch (err) {
+        _iterator7.e(err);
+      } finally {
+        _iterator7.f();
+      }
+      var declText = lines.map(function (l) {
+        return "".concat(parentDecl.kind, " ").concat(l, ";");
+      }).join('\n');
+      fixes.push(fixer.replaceText(parentDecl, declText));
+    }
+    if (hasValue) {
+      fixes.push.apply(fixes, (0, _toConsumableArray2.default)(appendAutomockFixesForPathMigration({
+        fixer: fixer,
+        sourceCode: sourceCode,
+        oldBarrelPath: modulePath,
+        newPaths: (0, _toConsumableArray2.default)(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.
  * Reports and auto-fixes imports that could use more specific export paths.
  */
-function handleImportDeclaration(_ref11) {
-  var node = _ref11.node,
-    context = _ref11.context,
-    workspaceRoot = _ref11.workspaceRoot,
-    fs = _ref11.fs,
-    applyToImportsFrom = _ref11.applyToImportsFrom;
+function handleImportDeclaration(_ref19) {
+  var node = _ref19.node,
+    context = _ref19.context,
+    workspaceRoot = _ref19.workspaceRoot,
+    fs = _ref19.fs,
+    applyToImportsFrom = _ref19.applyToImportsFrom,
+    preferImportedPackageSubpath = _ref19.preferImportedPackageSubpath;
   // Resolve import context (validates and extracts package/export info)
   // applyToImportsFrom is used here to filter which packages the rule applies to
   var importContext = resolveImportContext({
@@ -787,15 +1224,16 @@ function handleImportDeclaration(_ref11) {
   }
 
   // Classify specifiers by their target export paths
-  var _classifySpecifiers = classifySpecifiers({
+  var _classifySpecifiers3 = classifySpecifiers({
       node: node,
       importContext: importContext,
       workspaceRoot: workspaceRoot,
-      fs: fs
+      fs: fs,
+      preferImportedPackageSubpath: preferImportedPackageSubpath
     }),
-    specifiersByTarget = _classifySpecifiers.specifiersByTarget,
-    unmappedSpecifiers = _classifySpecifiers.unmappedSpecifiers,
-    hasNamespaceImport = _classifySpecifiers.hasNamespaceImport;
+    specifiersByTarget = _classifySpecifiers3.specifiersByTarget,
+    unmappedSpecifiers = _classifySpecifiers3.unmappedSpecifiers,
+    hasNamespaceImport = _classifySpecifiers3.hasNamespaceImport;
 
   // If namespace import, report without auto-fix if there are specific exports available
   if (hasNamespaceImport) {
@@ -844,9 +1282,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,
@@ -860,7 +1299,28 @@ function createRule(fs) {
             context: context,
             workspaceRoot: workspaceRoot,
             fs: fs,
-            applyToImportsFrom: applyToImportsFrom
+            applyToImportsFrom: applyToImportsFrom,
+            preferImportedPackageSubpath: preferImportedPackageSubpath
+          });
+        },
+        MemberExpression: function MemberExpression(rawNode) {
+          handleRequireMemberExpression({
+            node: rawNode,
+            context: context,
+            workspaceRoot: workspaceRoot,
+            fs: fs,
+            applyToImportsFrom: applyToImportsFrom,
+            preferImportedPackageSubpath: preferImportedPackageSubpath
+          });
+        },
+        VariableDeclarator: function VariableDeclarator(rawNode) {
+          handleRequireDestructuringDeclarator({
+            node: rawNode,
+            context: context,
+            workspaceRoot: workspaceRoot,
+            fs: fs,
+            applyToImportsFrom: applyToImportsFrom,
+            preferImportedPackageSubpath: preferImportedPackageSubpath
           });
         }
       };