@atlaskit/eslint-plugin-platform 2.7.1 → 2.8.0

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

@@ -0,0 +1,864 @@
+import _slicedToArray from "@babel/runtime/helpers/slicedToArray";
+import _toConsumableArray from "@babel/runtime/helpers/toConsumableArray";
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+function _createForOfIteratorHelper(r, e) { var t = "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (!t) { if (Array.isArray(r) || (t = _unsupportedIterableToArray(r)) || e && r && "number" == typeof r.length) { t && (r = t); var _n = 0, F = function F() {}; return { s: F, n: function n() { return _n >= r.length ? { done: !0 } : { done: !1, value: r[_n++] }; }, e: function e(r) { throw r; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var o, a = !0, u = !1; return { s: function s() { t = t.call(r); }, n: function n() { var r = t.next(); return a = r.done, r; }, e: function e(r) { u = !0, o = r; }, f: function f() { try { a || null == t.return || t.return(); } finally { if (u) throw o; } } }; }
+function _unsupportedIterableToArray(r, a) { if (r) { if ("string" == typeof r) return _arrayLikeToArray(r, a); var t = {}.toString.call(r).slice(8, -1); return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0; } }
+function _arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length); for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e]; return n; }
+import { dirname } from 'path';
+import { parseBarrelExports } from '../shared/barrel-parsing';
+import { DEFAULT_TARGET_FOLDERS, findWorkspaceRoot, isRelativeImport } from '../shared/file-system';
+import { findPackageInRegistry, isPackageInApplyToImportsFrom } from '../shared/package-registry';
+import { findExportForSourceFile, parsePackageExports } from '../shared/package-resolution';
+import { realFileSystem } from '../shared/types';
+
+/**
+ * Options for the no-barrel-entry-imports rule.
+ */
+
+/**
+ * Represents a Jest automock call: jest.mock('path') with no additional arguments
+ */
+
+/**
+ * Metadata for the ESLint rule
+ */
+var ruleMeta = {
+  type: 'problem',
+  docs: {
+    description: 'Disallow importing from barrel files in entry points.',
+    category: 'Best Practices',
+    recommended: false
+  },
+  fixable: 'code',
+  schema: [{
+    type: 'object',
+    properties: {
+      applyToImportsFrom: {
+        type: 'array',
+        items: {
+          type: 'string'
+        },
+        description: 'The folder paths (relative to workspace root) containing packages whose imports will be checked and autofixed.'
+      }
+    },
+    additionalProperties: false
+  }],
+  messages: {
+    barrelEntryImport: "Importing from barrel file '{{path}}' is not allowed. Import directly from the source file using a more specific package.json export instead."
+  }
+};
+
+/**
+ * Get the imported name from an ImportSpecifier, handling both Identifier and Literal
+ */
+function getImportedName(spec) {
+  var imported = spec.imported;
+  return imported.type === 'Identifier' ? imported.name : String(imported.value);
+}
+
+/**
+ * Build an import statement for a set of specifiers
+ */
+function buildImportStatement(_ref) {
+  var specs = _ref.specs,
+    path = _ref.path,
+    quoteChar = _ref.quoteChar,
+    _ref$isTypeImport = _ref.isTypeImport,
+    isTypeImport = _ref$isTypeImport === void 0 ? false : _ref$isTypeImport;
+  var importNames = specs.map(function (spec) {
+    if (spec.type === 'ImportDefaultSpecifier') {
+      return spec.local.name;
+    } else if (spec.type === 'ImportSpecifier') {
+      var imported = getImportedName(spec);
+      var local = spec.local.name;
+      var isInlineType = spec.importKind === 'type' && !isTypeImport;
+      var prefix = isInlineType ? 'type ' : '';
+      return imported === local ? "".concat(prefix).concat(imported) : "".concat(prefix).concat(imported, " as ").concat(local);
+    }
+    return '';
+  }).filter(function (name) {
+    return name.length > 0;
+  });
+  if (importNames.length === 0) {
+    return '';
+  }
+  var typeKeyword = isTypeImport ? 'type ' : '';
+  var hasDefault = specs.some(function (spec) {
+    return spec.type === 'ImportDefaultSpecifier';
+  });
+  var hasNamed = specs.some(function (spec) {
+    return spec.type === 'ImportSpecifier';
+  });
+  if (hasDefault && hasNamed) {
+    var _specs$find;
+    var defaultName = (_specs$find = specs.find(function (spec) {
+      return spec.type === 'ImportDefaultSpecifier';
+    })) === null || _specs$find === void 0 ? void 0 : _specs$find.local.name;
+    var namedImports = specs.filter(function (spec) {
+      return spec.type === 'ImportSpecifier';
+    }).map(function (spec) {
+      var imported = getImportedName(spec);
+      var local = spec.local.name;
+      var isInlineType = spec.importKind === 'type' && !isTypeImport;
+      var prefix = isInlineType ? 'type ' : '';
+      return imported === local ? "".concat(prefix).concat(imported) : "".concat(prefix).concat(imported, " as ").concat(local);
+    }).join(', ');
+    return "import ".concat(typeKeyword).concat(defaultName, ", { ").concat(namedImports, " } from ").concat(quoteChar).concat(path).concat(quoteChar, ";");
+  } else if (hasDefault) {
+    var _specs$find2;
+    var _defaultName = (_specs$find2 = specs.find(function (spec) {
+      return spec.type === 'ImportDefaultSpecifier';
+    })) === null || _specs$find2 === void 0 ? void 0 : _specs$find2.local.name;
+    return "import ".concat(typeKeyword).concat(_defaultName, " from ").concat(quoteChar).concat(path).concat(quoteChar, ";");
+  } else {
+    return "import ".concat(typeKeyword, "{ ").concat(importNames.join(', '), " } from ").concat(quoteChar).concat(path).concat(quoteChar, ";");
+  }
+}
+
+/**
+ * Represents a specifier with its resolved target export path information.
+ */
+
+/**
+ * Context resolved for an import that may be a barrel import.
+ */
+
+/**
+ * Result of classifying specifiers by their target export paths.
+ */
+
+/**
+ * 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(_ref2) {
+  var node = _ref2.node,
+    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 (isRelativeImport(importPath)) {
+    return null;
+  }
+
+  // Extract the base package name (without subpath)
+  // e.g., "@atlassian/conversation-assistant-instrumentation" from
+  // "@atlassian/conversation-assistant-instrumentation" or
+  // "@atlassian/conversation-assistant-instrumentation/controllers/analytics"
+  var packageNameMatch = importPath.match(/^(@[^/]+\/[^/]+)/);
+  if (!packageNameMatch) {
+    return null;
+  }
+  var packageName = packageNameMatch[1];
+  var subPath = importPath.slice(packageName.length); // e.g., "" or "/controllers/analytics"
+
+  // Find the package (resolution is not constrained by applyToImportsFrom)
+  var packageDir = findPackageInRegistry({
+    packageName: packageName,
+    workspaceRoot: workspaceRoot,
+    fs: fs
+  });
+  if (!packageDir) {
+    return null;
+  }
+
+  // Only check imports from packages in our applyToImportsFrom folders
+  if (!isPackageInApplyToImportsFrom({
+    packageDir: packageDir,
+    workspaceRoot: workspaceRoot,
+    applyToImportsFrom: applyToImportsFrom
+  })) {
+    return null;
+  }
+
+  // Get the exports map for this package
+  var exportsMap = parsePackageExports({
+    packageDir: packageDir,
+    fs: fs
+  });
+  if (exportsMap.size === 0) {
+    return null;
+  }
+
+  // Determine which export path we're importing from
+  // For bare package imports, it's ".", for subpath imports it's "./" + subPath
+  var currentExportPath = subPath ? '.' + subPath : '.';
+
+  // Get the resolved path for the current export (the entry point file for this import)
+  var entryFilePath = exportsMap.get(currentExportPath);
+  if (!entryFilePath) {
+    return null;
+  }
+
+  // Parse the entry file to find where each export originates
+  // Pass workspaceRoot to enable cross-package re-export resolution
+  var exportMap = parseBarrelExports({
+    barrelFilePath: entryFilePath,
+    fs: fs,
+    workspaceRoot: workspaceRoot
+  });
+  if (exportMap.size === 0) {
+    return null;
+  }
+  return {
+    importPath: importPath,
+    packageName: packageName,
+    currentExportPath: currentExportPath,
+    exportsMap: exportsMap,
+    exportMap: exportMap
+  };
+}
+
+/**
+ * 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;
+  var currentExportPath = importContext.currentExportPath,
+    exportsMap = importContext.exportsMap,
+    exportMap = importContext.exportMap;
+  var specifiers = node.specifiers;
+  var specifiersByTarget = new Map();
+  var unmappedSpecifiers = [];
+  var hasNamespaceImport = false;
+
+  // Cache for source package exports maps to avoid redundant parsing
+  var sourcePackageExportsMaps = new Map();
+  var _iterator = _createForOfIteratorHelper(specifiers),
+    _step;
+  try {
+    for (_iterator.s(); !(_step = _iterator.n()).done;) {
+      var spec = _step.value;
+      if (spec.type === 'ImportNamespaceSpecifier') {
+        hasNamespaceImport = true;
+        continue;
+      }
+      var nameInSource = void 0;
+      var kind = 'value';
+      if (spec.type === 'ImportDefaultSpecifier') {
+        nameInSource = 'default';
+      } else if (spec.type === 'ImportSpecifier') {
+        nameInSource = getImportedName(spec);
+        var parentImportKind = node.importKind;
+        kind = parentImportKind === 'type' || spec.importKind === 'type' ? 'type' : 'value';
+      } else {
+        continue;
+      }
+      var exportInfo = exportMap.get(nameInSource);
+      if (exportInfo) {
+        var _exportInfo$crossPack;
+        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) {
+          // 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);
+          if (!sourcePackageExportsMap) {
+            var sourcePackageDir = findPackageInRegistry({
+              packageName: sourcePackageName,
+              workspaceRoot: workspaceRoot,
+              fs: fs
+            });
+            if (sourcePackageDir) {
+              sourcePackageExportsMap = parsePackageExports({
+                packageDir: sourcePackageDir,
+                fs: fs
+              });
+              sourcePackageExportsMaps.set(sourcePackageName, sourcePackageExportsMap);
+            }
+          }
+
+          // Find the best export path in the source package
+          var _targetExportPath = null;
+          if (sourcePackageExportsMap) {
+            _targetExportPath = findExportForSourceFile({
+              sourceFilePath: exportInfo.path,
+              exportsMap: sourcePackageExportsMap
+            });
+          }
+
+          // 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
+          : sourcePackageName;
+          if (!specifiersByTarget.has(targetKey)) {
+            specifiersByTarget.set(targetKey, []);
+          }
+          specifiersByTarget.get(targetKey).push({
+            spec: _objectSpread(_objectSpread({}, spec), {}, {
+              importKind: effectiveKind
+            }),
+            originalName: exportInfo.originalName,
+            targetExportPath: targetKey,
+            kind: effectiveKind,
+            sourcePackageName: sourcePackageName
+          });
+          continue;
+        }
+
+        // Find if there's a package.json export that points to this source file
+        var targetExportPath = findExportForSourceFile({
+          sourceFilePath: exportInfo.path,
+          exportsMap: exportsMap
+        });
+
+        // Get the file that the current export path resolves to
+        var currentExportResolvedFile = exportsMap.get(currentExportPath);
+
+        // Skip if:
+        // 1. No target export path found
+        // 2. Target is same as current (no change needed)
+        // 3. Current export path already resolves to the same file as the source
+        //    (handles multiple exports pointing to same file - avoid no-op changes)
+        var currentExportAlreadyPointsToSourceFile = currentExportResolvedFile !== undefined && currentExportResolvedFile === exportInfo.path;
+        if (targetExportPath && targetExportPath !== currentExportPath && !currentExportAlreadyPointsToSourceFile) {
+          if (!specifiersByTarget.has(targetExportPath)) {
+            specifiersByTarget.set(targetExportPath, []);
+          }
+          specifiersByTarget.get(targetExportPath).push({
+            spec: _objectSpread(_objectSpread({}, spec), {}, {
+              importKind: effectiveKind
+            }),
+            originalName: exportInfo.originalName,
+            targetExportPath: targetExportPath,
+            kind: effectiveKind
+          });
+        } else {
+          // No more specific export available
+          unmappedSpecifiers.push({
+            spec: spec,
+            targetExportPath: null,
+            kind: kind
+          });
+        }
+      } else {
+        unmappedSpecifiers.push({
+          spec: spec,
+          targetExportPath: null,
+          kind: kind
+        });
+      }
+    }
+  } catch (err) {
+    _iterator.e(err);
+  } finally {
+    _iterator.f();
+  }
+  return {
+    specifiersByTarget: specifiersByTarget,
+    unmappedSpecifiers: unmappedSpecifiers,
+    hasNamespaceImport: hasNamespaceImport
+  };
+}
+
+/**
+ * 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;
+  if (!originalName) {
+    return spec;
+  }
+  if (originalName === 'default') {
+    // Should be ImportDefaultSpecifier
+    if (spec.type === 'ImportDefaultSpecifier') {
+      return spec;
+    }
+    // Convert ImportSpecifier to ImportDefaultSpecifier
+    return {
+      type: 'ImportDefaultSpecifier',
+      local: spec.local,
+      range: spec.range,
+      loc: spec.loc,
+      parent: spec.parent
+    };
+  } else {
+    // Create synthetic ImportSpecifier with correct importKind
+    return {
+      type: 'ImportSpecifier',
+      local: spec.local,
+      imported: {
+        type: 'Identifier',
+        name: originalName,
+        range: [0, 0],
+        loc: {
+          start: {
+            line: 0,
+            column: 0
+          },
+          end: {
+            line: 0,
+            column: 0
+          }
+        }
+      },
+      importKind: kind,
+      range: spec.range,
+      loc: spec.loc,
+      parent: spec.parent
+    };
+  }
+}
+
+/**
+ * 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;
+  var existingSpecs = existingImport.specifiers.map(function (s) {
+    if (existingImport.importKind === 'type') {
+      return _objectSpread(_objectSpread({}, s), {}, {
+        importKind: 'type'
+      });
+    }
+    return s;
+  });
+  var augmentedNewSpecs = newSpecs.map(function (s) {
+    if (nodeImportKind === 'type') {
+      return _objectSpread(_objectSpread({}, s), {}, {
+        importKind: 'type'
+      });
+    }
+    return s;
+  });
+  var mergedSpecs = [].concat(_toConsumableArray(existingSpecs), _toConsumableArray(augmentedNewSpecs));
+
+  // Determine if we should use 'import type'
+  var allType = mergedSpecs.every(function (s) {
+    return s.importKind === 'type';
+  });
+  return buildImportStatement({
+    specs: mergedSpecs,
+    path: newImportPath,
+    quoteChar: quoteChar,
+    isTypeImport: allType
+  });
+}
+
+/**
+ * Check if an ExpressionStatement is a Jest automock: jest.mock('path') with exactly one string argument.
+ * Returns the JestAutomock info if it is, null otherwise.
+ */
+function getJestAutomock(node) {
+  if (node.type !== 'ExpressionStatement') {
+    return null;
+  }
+  var statement = node;
+  var expr = statement.expression;
+  if (expr.type !== 'CallExpression') {
+    return null;
+  }
+
+  // Check for jest.mock(...)
+  var callee = expr.callee;
+  if (callee.type !== 'MemberExpression' || callee.object.type !== 'Identifier' || callee.object.name !== 'jest' || callee.property.type !== 'Identifier' || callee.property.name !== 'mock') {
+    return null;
+  }
+
+  // Must have exactly one argument (automock = no factory function)
+  if (expr.arguments.length !== 1) {
+    return null;
+  }
+  var arg = expr.arguments[0];
+  if (arg.type !== 'Literal' || typeof arg.value !== 'string') {
+    return null;
+  }
+
+  // Get the quote character from the raw value
+  var raw = arg.raw || "'".concat(arg.value, "'");
+  var quoteChar = raw[0];
+  return {
+    statementNode: statement,
+    path: arg.value,
+    quoteChar: quoteChar
+  };
+}
+
+/**
+ * Find all Jest automocks in the AST that match the given import path.
+ */
+function findMatchingAutomocks(_ref6) {
+  var sourceCode = _ref6.sourceCode,
+    importPath = _ref6.importPath;
+  var automocks = [];
+  var ast = sourceCode.ast;
+  var _iterator2 = _createForOfIteratorHelper(ast.body),
+    _step2;
+  try {
+    for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+      var statement = _step2.value;
+      var automock = getJestAutomock(statement);
+      if (automock && automock.path === importPath) {
+        automocks.push(automock);
+      }
+    }
+  } catch (err) {
+    _iterator2.e(err);
+  } finally {
+    _iterator2.f();
+  }
+  return automocks;
+}
+
+/**
+ * Build a jest.mock() statement string
+ */
+function buildAutomockStatement(_ref7) {
+  var path = _ref7.path,
+    quoteChar = _ref7.quoteChar;
+  return "jest.mock(".concat(quoteChar).concat(path).concat(quoteChar, ");");
+}
+
+/**
+ * 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;
+  var nodeStart = node.range[0];
+  var nodeEnd = node.range[1];
+
+  // Check for leading newline (prefer removing the line separator before the node)
+  var textBeforeNode = sourceCode.text.slice(0, nodeStart);
+  var leadingNewlineMatch = textBeforeNode.match(/(\r?\n)$/);
+  if (leadingNewlineMatch) {
+    // Remove the leading newline plus the node
+    return fixer.removeRange([nodeStart - leadingNewlineMatch[1].length, nodeEnd]);
+  }
+
+  // No leading newline - check for trailing newline
+  var textAfterNode = sourceCode.text.slice(nodeEnd);
+  var trailingNewlineMatch = textAfterNode.match(/^(\r?\n)/);
+  if (trailingNewlineMatch) {
+    return fixer.removeRange([nodeStart, nodeEnd + trailingNewlineMatch[1].length]);
+  }
+  return fixer.remove(node);
+}
+
+/**
+ * Creates the auto-fix for barrel import violations.
+ * 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;
+  var importPath = importContext.importPath,
+    packageName = importContext.packageName;
+  var sourceCode = context.sourceCode;
+  var quote = sourceCode.getText(node.source)[0]; // Get quote character
+
+  var fixes = [];
+  var newStatements = [];
+
+  // Find any Jest automocks that match this import path
+  var automocks = findMatchingAutomocks({
+    sourceCode: sourceCode,
+    importPath: importPath
+  });
+
+  // Track which new import paths need automocks (only value imports, not type-only)
+  var automockPaths = [];
+
+  // Track if we have any value imports at all (to determine if automocks should be updated)
+  var hasAnyValueImports = false;
+
+  // Get all existing imports to check for merging
+  var allImports = sourceCode.ast.body.filter(function (n) {
+    return n.type === 'ImportDeclaration' && n !== node;
+  });
+
+  // Generate new import statements for each target export path
+  var _iterator3 = _createForOfIteratorHelper(specifiersByTarget),
+    _step3;
+  try {
+    var _loop2 = function _loop2() {
+      var _step3$value = _slicedToArray(_step3.value, 2),
+        targetExportPath = _step3$value[0],
+        specsWithTarget = _step3$value[1];
+      // Check if this is a cross-package re-export (sourcePackageName is set)
+      var isCrossPackage = specsWithTarget.some(function (s) {
+        return s.sourcePackageName;
+      });
+      var newImportPath = isCrossPackage ? targetExportPath // For cross-package, targetExportPath is already the full import path (e.g., @package/subpath)
+      : 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;
+        return transformSpecifierForExport({
+          spec: spec,
+          originalName: originalName,
+          kind: kind
+        });
+      });
+
+      // 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;
+          return kind === 'value' && (spec.type !== 'ImportSpecifier' || spec.importKind !== 'type');
+        });
+        if (hasValueImport) {
+          hasAnyValueImports = true;
+          automockPaths.push(newImportPath);
+        }
+      }
+
+      // Check for existing import from the same path
+      var existingImport = allImports.find(function (n) {
+        return n.source.value === newImportPath;
+      });
+
+      // Skip merging if existing is namespace import
+      var isNamespace = existingImport === null || existingImport === void 0 ? void 0 : existingImport.specifiers.some(function (s) {
+        return s.type === 'ImportNamespaceSpecifier';
+      });
+      if (existingImport && !isNamespace) {
+        // Merge with existing import
+        var newImportStatement = buildMergedImportStatement({
+          existingImport: existingImport,
+          newSpecs: specs,
+          newImportPath: newImportPath,
+          nodeImportKind: node.importKind,
+          quoteChar: quote
+        });
+        if (newImportStatement.length > 0) {
+          fixes.push(fixer.replaceText(existingImport, newImportStatement));
+        }
+      } else {
+        // Create new import
+        var _isTypeImport = node.importKind === 'type';
+        var importStatement = buildImportStatement({
+          specs: specs,
+          path: newImportPath,
+          quoteChar: quote,
+          isTypeImport: _isTypeImport
+        });
+        if (importStatement.length > 0) {
+          newStatements.push(importStatement);
+        }
+      }
+    };
+    for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
+      _loop2();
+    }
+
+    // Handle unmapped specifiers - they stay in the original import
+  } catch (err) {
+    _iterator3.e(err);
+  } finally {
+    _iterator3.f();
+  }
+  if (unmappedSpecifiers.length > 0) {
+    var unmappedSpecs = unmappedSpecifiers.map(function (u) {
+      return u.spec;
+    });
+    var isTypeImport = node.importKind === 'type';
+    var remainingImport = buildImportStatement({
+      specs: unmappedSpecs,
+      path: importPath,
+      quoteChar: quote,
+      isTypeImport: isTypeImport
+    });
+    if (remainingImport.length > 0) {
+      newStatements.push(remainingImport);
+    }
+
+    // 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;
+        return kind === 'value' && (spec.type !== 'ImportSpecifier' || spec.importKind !== 'type');
+      });
+      if (hasUnmappedValueImport) {
+        hasAnyValueImports = true;
+        automockPaths.push(importPath);
+      }
+    }
+  }
+  if (newStatements.length > 0) {
+    fixes.push(fixer.replaceText(node, newStatements.join('\n')));
+  } else {
+    // If all were merged, remove the node including surrounding whitespace/newlines
+    fixes.push(createNodeRemovalFix({
+      fixer: fixer,
+      node: node,
+      sourceCode: sourceCode
+    }));
+  }
+
+  // Handle automock updates
+  // Only modify automocks if there are value imports being fixed
+  // Type-only imports don't need runtime mocking, so we preserve existing automocks
+  if (automocks.length > 0 && hasAnyValueImports && automockPaths.length > 0) {
+    var _iterator4 = _createForOfIteratorHelper(automocks),
+      _step4;
+    try {
+      var _loop = function _loop() {
+        var automock = _step4.value;
+        // Build new automock statements for all new paths
+        var newAutomockStatements = automockPaths.map(function (path) {
+          return buildAutomockStatement({
+            path: path,
+            quoteChar: automock.quoteChar
+          });
+        });
+
+        // Replace the original automock statement with the new automock(s)
+        fixes.push(fixer.replaceTextRange(automock.statementNode.range, newAutomockStatements.join('\n')));
+      };
+      for (_iterator4.s(); !(_step4 = _iterator4.n()).done;) {
+        _loop();
+      }
+    } catch (err) {
+      _iterator4.e(err);
+    } finally {
+      _iterator4.f();
+    }
+  }
+  return fixes;
+}
+
+/**
+ * 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;
+  // Resolve import context (validates and extracts package/export info)
+  // applyToImportsFrom is used here to filter which packages the rule applies to
+  var importContext = resolveImportContext({
+    node: node,
+    workspaceRoot: workspaceRoot,
+    fs: fs,
+    applyToImportsFrom: applyToImportsFrom
+  });
+  if (!importContext) {
+    return;
+  }
+
+  // Check each imported specifier to see if we can find a more specific export
+  if (node.specifiers.length === 0) {
+    return;
+  }
+
+  // Classify specifiers by their target export paths
+  var _classifySpecifiers = classifySpecifiers({
+      node: node,
+      importContext: importContext,
+      workspaceRoot: workspaceRoot,
+      fs: fs
+    }),
+    specifiersByTarget = _classifySpecifiers.specifiersByTarget,
+    unmappedSpecifiers = _classifySpecifiers.unmappedSpecifiers,
+    hasNamespaceImport = _classifySpecifiers.hasNamespaceImport;
+
+  // If namespace import, report without auto-fix if there are specific exports available
+  if (hasNamespaceImport) {
+    if (specifiersByTarget.size > 0) {
+      context.report({
+        node: node,
+        messageId: 'barrelEntryImport',
+        data: {
+          path: importContext.importPath
+        }
+      });
+    }
+    return;
+  }
+
+  // If no specifiers can be remapped to more specific imports, don't report
+  if (specifiersByTarget.size === 0) {
+    return;
+  }
+
+  // Report with auto-fix
+  context.report({
+    node: node,
+    messageId: 'barrelEntryImport',
+    data: {
+      path: importContext.importPath
+    },
+    fix: function fix(fixer) {
+      return createBarrelImportFix({
+        fixer: fixer,
+        node: node,
+        context: context,
+        importContext: importContext,
+        specifiersByTarget: specifiersByTarget,
+        unmappedSpecifiers: unmappedSpecifiers
+      });
+    }
+  });
+}
+
+/**
+ * Factory function to create the ESLint rule with a given file system.
+ * This enables testing with mock file systems.
+ */
+export function createRule(fs) {
+  return {
+    meta: ruleMeta,
+    create: function create(context) {
+      var _options$applyToImpor;
+      var options = context.options[0] || {};
+      var applyToImportsFrom = (_options$applyToImpor = options.applyToImportsFrom) !== null && _options$applyToImpor !== void 0 ? _options$applyToImpor : DEFAULT_TARGET_FOLDERS;
+      var workspaceRoot = findWorkspaceRoot({
+        startPath: dirname(context.filename),
+        fs: fs,
+        applyToImportsFrom: applyToImportsFrom
+      });
+      return {
+        ImportDeclaration: function ImportDeclaration(rawNode) {
+          var node = rawNode;
+          handleImportDeclaration({
+            node: node,
+            context: context,
+            workspaceRoot: workspaceRoot,
+            fs: fs,
+            applyToImportsFrom: applyToImportsFrom
+          });
+        }
+      };
+    }
+  };
+}
+var rule = createRule(realFileSystem);
+export default rule;