@atlaskit/eslint-plugin-platform 2.7.2 → 2.9.0

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

@@ -0,0 +1,1272 @@
+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 from a module specifier string.
+ * Returns null if the import should not be processed (relative import, not in target folder, etc.)
+ */
+function resolveImportContextFromModulePath(_ref2) {
+  var importPath = _ref2.importPath,
+    workspaceRoot = _ref2.workspaceRoot,
+    fs = _ref2.fs,
+    applyToImportsFrom = _ref2.applyToImportsFrom;
+  // 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
+  };
+}
+
+/**
+ * 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(_ref4) {
+  var node = _ref4.node,
+    importContext = _ref4.importContext,
+    workspaceRoot = _ref4.workspaceRoot,
+    fs = _ref4.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, _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) {
+          // 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;
+          var resolvedOriginalName = exportInfo.originalName;
+          if (sourcePackageExportsMap) {
+            var _exportInfo$originalN, _matchResult$exportPa;
+            var _sourceExportName = (_exportInfo$originalN = exportInfo.originalName) !== null && _exportInfo$originalN !== void 0 ? _exportInfo$originalN : nameInSource;
+            var _matchResult = findExportForSourceFile({
+              sourceFilePath: exportInfo.path,
+              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
+          : sourcePackageName;
+          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;
+        }
+
+        // Find if there's a package.json export that points to this source file
+        var sourceExportName = (_exportInfo$originalN2 = exportInfo.originalName) !== null && _exportInfo$originalN2 !== void 0 ? _exportInfo$originalN2 : nameInSource;
+        var matchResult = findExportForSourceFile({
+          sourceFilePath: exportInfo.path,
+          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);
+
+        // 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: resolvedOriginalName2,
+            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(_ref5) {
+  var spec = _ref5.spec,
+    originalName = _ref5.originalName,
+    kind = _ref5.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(_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), {}, {
+        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(_ref7) {
+  var sourceCode = _ref7.sourceCode,
+    importPath = _ref7.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(_ref8) {
+  var path = _ref8.path,
+    quoteChar = _ref8.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(_ref9) {
+  var fixer = _ref9.fixer,
+    node = _ref9.node,
+    sourceCode = _ref9.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(_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;
+  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 (_ref10) {
+        var spec = _ref10.spec,
+          originalName = _ref10.originalName,
+          kind = _ref10.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 (_ref11) {
+          var kind = _ref11.kind,
+            spec = _ref11.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 (_ref1) {
+        var kind = _ref1.kind,
+          spec = _ref1.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;
+}
+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;
+  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
+    }),
+    specifiersByTarget = _classifySpecifiers.specifiersByTarget,
+    hasNamespaceImport = _classifySpecifiers.hasNamespaceImport;
+  if (hasNamespaceImport || specifiersByTarget.size === 0) {
+    return;
+  }
+  var entries = _toConsumableArray(specifiersByTarget.entries());
+  if (entries.length !== 1) {
+    return;
+  }
+  var _ref14 = entries[0],
+    _ref15 = _slicedToArray(_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, _toConsumableArray(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;
+  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
+    }),
+    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 = _toConsumableArray(specifiersByTarget.entries())[0],
+        _ref18 = _slicedToArray(_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 = _slicedToArray(_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, _toConsumableArray(appendAutomockFixesForPathMigration({
+        fixer: fixer,
+        sourceCode: sourceCode,
+        oldBarrelPath: modulePath,
+        newPaths: _toConsumableArray(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(_ref19) {
+  var node = _ref19.node,
+    context = _ref19.context,
+    workspaceRoot = _ref19.workspaceRoot,
+    fs = _ref19.fs,
+    applyToImportsFrom = _ref19.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 _classifySpecifiers3 = classifySpecifiers({
+      node: node,
+      importContext: importContext,
+      workspaceRoot: workspaceRoot,
+      fs: fs
+    }),
+    specifiersByTarget = _classifySpecifiers3.specifiersByTarget,
+    unmappedSpecifiers = _classifySpecifiers3.unmappedSpecifiers,
+    hasNamespaceImport = _classifySpecifiers3.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
+          });
+        },
+        MemberExpression: function MemberExpression(rawNode) {
+          handleRequireMemberExpression({
+            node: rawNode,
+            context: context,
+            workspaceRoot: workspaceRoot,
+            fs: fs,
+            applyToImportsFrom: applyToImportsFrom
+          });
+        },
+        VariableDeclarator: function VariableDeclarator(rawNode) {
+          handleRequireDestructuringDeclarator({
+            node: rawNode,
+            context: context,
+            workspaceRoot: workspaceRoot,
+            fs: fs,
+            applyToImportsFrom: applyToImportsFrom
+          });
+        }
+      };
+    }
+  };
+}
+var rule = createRule(realFileSystem);
+export default rule;