@atlaskit/eslint-plugin-platform 2.7.2 → 2.9.0

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

@@ -0,0 +1,1158 @@
+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
+ */
+const 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) {
+  const imported = spec.imported;
+  return imported.type === 'Identifier' ? imported.name : String(imported.value);
+}
+
+/**
+ * Build an import statement for a set of specifiers
+ */
+function buildImportStatement({
+  specs,
+  path,
+  quoteChar,
+  isTypeImport = false
+}) {
+  const importNames = specs.map(spec => {
+    if (spec.type === 'ImportDefaultSpecifier') {
+      return spec.local.name;
+    } else if (spec.type === 'ImportSpecifier') {
+      const imported = getImportedName(spec);
+      const local = spec.local.name;
+      const isInlineType = spec.importKind === 'type' && !isTypeImport;
+      const prefix = isInlineType ? 'type ' : '';
+      return imported === local ? `${prefix}${imported}` : `${prefix}${imported} as ${local}`;
+    }
+    return '';
+  }).filter(name => name.length > 0);
+  if (importNames.length === 0) {
+    return '';
+  }
+  const typeKeyword = isTypeImport ? 'type ' : '';
+  const hasDefault = specs.some(spec => spec.type === 'ImportDefaultSpecifier');
+  const hasNamed = specs.some(spec => spec.type === 'ImportSpecifier');
+  if (hasDefault && hasNamed) {
+    var _specs$find;
+    const defaultName = (_specs$find = specs.find(spec => spec.type === 'ImportDefaultSpecifier')) === null || _specs$find === void 0 ? void 0 : _specs$find.local.name;
+    const namedImports = specs.filter(spec => spec.type === 'ImportSpecifier').map(spec => {
+      const imported = getImportedName(spec);
+      const local = spec.local.name;
+      const isInlineType = spec.importKind === 'type' && !isTypeImport;
+      const prefix = isInlineType ? 'type ' : '';
+      return imported === local ? `${prefix}${imported}` : `${prefix}${imported} as ${local}`;
+    }).join(', ');
+    return `import ${typeKeyword}${defaultName}, { ${namedImports} } from ${quoteChar}${path}${quoteChar};`;
+  } else if (hasDefault) {
+    var _specs$find2;
+    const defaultName = (_specs$find2 = specs.find(spec => spec.type === 'ImportDefaultSpecifier')) === null || _specs$find2 === void 0 ? void 0 : _specs$find2.local.name;
+    return `import ${typeKeyword}${defaultName} from ${quoteChar}${path}${quoteChar};`;
+  } else {
+    return `import ${typeKeyword}{ ${importNames.join(', ')} } from ${quoteChar}${path}${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({
+  importPath,
+  workspaceRoot,
+  fs,
+  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"
+  const packageNameMatch = importPath.match(/^(@[^/]+\/[^/]+)/);
+  if (!packageNameMatch) {
+    return null;
+  }
+  const packageName = packageNameMatch[1];
+  const subPath = importPath.slice(packageName.length); // e.g., "" or "/controllers/analytics"
+
+  // Find the package (resolution is not constrained by applyToImportsFrom)
+  const packageDir = findPackageInRegistry({
+    packageName,
+    workspaceRoot,
+    fs
+  });
+  if (!packageDir) {
+    return null;
+  }
+
+  // Only check imports from packages in our applyToImportsFrom folders
+  if (!isPackageInApplyToImportsFrom({
+    packageDir,
+    workspaceRoot,
+    applyToImportsFrom
+  })) {
+    return null;
+  }
+
+  // Get the exports map for this package
+  const exportsMap = parsePackageExports({
+    packageDir,
+    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
+  const currentExportPath = subPath ? '.' + subPath : '.';
+
+  // Get the resolved path for the current export (the entry point file for this import)
+  const 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
+  const exportMap = parseBarrelExports({
+    barrelFilePath: entryFilePath,
+    fs,
+    workspaceRoot
+  });
+  if (exportMap.size === 0) {
+    return null;
+  }
+  return {
+    importPath,
+    packageName,
+    currentExportPath,
+    exportsMap,
+    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({
+  node,
+  workspaceRoot,
+  fs,
+  applyToImportsFrom
+}) {
+  if (!node.source || typeof node.source.value !== 'string') {
+    return null;
+  }
+  return resolveImportContextFromModulePath({
+    importPath: node.source.value,
+    workspaceRoot,
+    fs,
+    applyToImportsFrom
+  });
+}
+
+/**
+ * Classifies import specifiers by their target export paths.
+ * Groups specifiers that can be remapped to more specific exports.
+ * For cross-package re-exports, suggests importing from the source package's most specific subpath.
+ */
+function classifySpecifiers({
+  node,
+  importContext,
+  workspaceRoot,
+  fs
+}) {
+  const {
+    currentExportPath,
+    exportsMap,
+    exportMap
+  } = importContext;
+  const specifiers = node.specifiers;
+  const specifiersByTarget = new Map();
+  const unmappedSpecifiers = [];
+  let hasNamespaceImport = false;
+
+  // Cache for source package exports maps to avoid redundant parsing
+  const sourcePackageExportsMaps = new Map();
+  for (const spec of specifiers) {
+    if (spec.type === 'ImportNamespaceSpecifier') {
+      hasNamespaceImport = true;
+      continue;
+    }
+    let nameInSource;
+    let kind = 'value';
+    if (spec.type === 'ImportDefaultSpecifier') {
+      nameInSource = 'default';
+    } else if (spec.type === 'ImportSpecifier') {
+      nameInSource = getImportedName(spec);
+      const parentImportKind = node.importKind;
+      kind = parentImportKind === 'type' || spec.importKind === 'type' ? 'type' : 'value';
+    } else {
+      continue;
+    }
+    const exportInfo = exportMap.get(nameInSource);
+    if (exportInfo) {
+      var _exportInfo$crossPack, _exportInfo$originalN2, _matchResult$exportPa2;
+      const effectiveKind = kind === 'type' || exportInfo.isTypeOnly ? 'type' : 'value';
+
+      // Check if this is a cross-package re-export
+      const 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
+        let sourcePackageExportsMap = sourcePackageExportsMaps.get(sourcePackageName);
+        if (!sourcePackageExportsMap) {
+          const sourcePackageDir = findPackageInRegistry({
+            packageName: sourcePackageName,
+            workspaceRoot,
+            fs
+          });
+          if (sourcePackageDir) {
+            sourcePackageExportsMap = parsePackageExports({
+              packageDir: sourcePackageDir,
+              fs
+            });
+            sourcePackageExportsMaps.set(sourcePackageName, sourcePackageExportsMap);
+          }
+        }
+
+        // Find the best export path in the source package
+        let targetExportPath = null;
+        let resolvedOriginalName = exportInfo.originalName;
+        if (sourcePackageExportsMap) {
+          var _exportInfo$originalN, _matchResult$exportPa;
+          const sourceExportName = (_exportInfo$originalN = exportInfo.originalName) !== null && _exportInfo$originalN !== void 0 ? _exportInfo$originalN : nameInSource;
+          const matchResult = findExportForSourceFile({
+            sourceFilePath: exportInfo.path,
+            exportsMap: sourcePackageExportsMap,
+            fs,
+            sourceExportName
+          });
+          targetExportPath = (_matchResult$exportPa = matchResult === null || matchResult === void 0 ? void 0 : matchResult.exportPath) !== null && _matchResult$exportPa !== void 0 ? _matchResult$exportPa : null;
+          if ((matchResult === null || matchResult === void 0 ? void 0 : matchResult.entryPointExportName) !== undefined) {
+            resolvedOriginalName = matchResult.entryPointExportName === nameInSource ? undefined : matchResult.entryPointExportName;
+          }
+        }
+
+        // Build the full import path: @package/subpath or just @package if no subpath found
+        const targetKey = targetExportPath ? sourcePackageName + targetExportPath.slice(1) // Remove leading '.' from subpath
+        : sourcePackageName;
+        if (!specifiersByTarget.has(targetKey)) {
+          specifiersByTarget.set(targetKey, []);
+        }
+        specifiersByTarget.get(targetKey).push({
+          spec: {
+            ...spec,
+            importKind: effectiveKind
+          },
+          originalName: resolvedOriginalName,
+          targetExportPath: targetKey,
+          kind: effectiveKind,
+          sourcePackageName
+        });
+        continue;
+      }
+
+      // Find if there's a package.json export that points to this source file
+      const sourceExportName = (_exportInfo$originalN2 = exportInfo.originalName) !== null && _exportInfo$originalN2 !== void 0 ? _exportInfo$originalN2 : nameInSource;
+      const matchResult = findExportForSourceFile({
+        sourceFilePath: exportInfo.path,
+        exportsMap,
+        fs,
+        sourceExportName
+      });
+      const targetExportPath = (_matchResult$exportPa2 = matchResult === null || matchResult === void 0 ? void 0 : matchResult.exportPath) !== null && _matchResult$exportPa2 !== void 0 ? _matchResult$exportPa2 : null;
+      let resolvedOriginalName2 = exportInfo.originalName;
+      if ((matchResult === null || matchResult === void 0 ? void 0 : matchResult.entryPointExportName) !== undefined) {
+        resolvedOriginalName2 = matchResult.entryPointExportName === nameInSource ? undefined : matchResult.entryPointExportName;
+      }
+
+      // Get the file that the current export path resolves to
+      const currentExportResolvedFile = exportsMap.get(currentExportPath);
+
+      // 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)
+      const currentExportAlreadyPointsToSourceFile = currentExportResolvedFile !== undefined && currentExportResolvedFile === exportInfo.path;
+      if (targetExportPath && targetExportPath !== currentExportPath && !currentExportAlreadyPointsToSourceFile) {
+        if (!specifiersByTarget.has(targetExportPath)) {
+          specifiersByTarget.set(targetExportPath, []);
+        }
+        specifiersByTarget.get(targetExportPath).push({
+          spec: {
+            ...spec,
+            importKind: effectiveKind
+          },
+          originalName: resolvedOriginalName2,
+          targetExportPath,
+          kind: effectiveKind
+        });
+      } else {
+        // No more specific export available
+        unmappedSpecifiers.push({
+          spec: spec,
+          targetExportPath: null,
+          kind
+        });
+      }
+    } else {
+      unmappedSpecifiers.push({
+        spec: spec,
+        targetExportPath: null,
+        kind
+      });
+    }
+  }
+  return {
+    specifiersByTarget,
+    unmappedSpecifiers,
+    hasNamespaceImport
+  };
+}
+
+/**
+ * Transforms a specifier to use the original export name (handling aliasing).
+ * Converts named imports of default exports to ImportDefaultSpecifier.
+ */
+function transformSpecifierForExport({
+  spec,
+  originalName,
+  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({
+  existingImport,
+  newSpecs,
+  newImportPath,
+  nodeImportKind,
+  quoteChar
+}) {
+  const existingSpecs = existingImport.specifiers.map(s => {
+    if (existingImport.importKind === 'type') {
+      return {
+        ...s,
+        importKind: 'type'
+      };
+    }
+    return s;
+  });
+  const augmentedNewSpecs = newSpecs.map(s => {
+    if (nodeImportKind === 'type') {
+      return {
+        ...s,
+        importKind: 'type'
+      };
+    }
+    return s;
+  });
+  const mergedSpecs = [...existingSpecs, ...augmentedNewSpecs];
+
+  // Determine if we should use 'import type'
+  const allType = mergedSpecs.every(s => s.importKind === 'type');
+  return buildImportStatement({
+    specs: mergedSpecs,
+    path: newImportPath,
+    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;
+  }
+  const statement = node;
+  const expr = statement.expression;
+  if (expr.type !== 'CallExpression') {
+    return null;
+  }
+
+  // Check for jest.mock(...)
+  const 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;
+  }
+  const arg = expr.arguments[0];
+  if (arg.type !== 'Literal' || typeof arg.value !== 'string') {
+    return null;
+  }
+
+  // Get the quote character from the raw value
+  const raw = arg.raw || `'${arg.value}'`;
+  const quoteChar = raw[0];
+  return {
+    statementNode: statement,
+    path: arg.value,
+    quoteChar
+  };
+}
+
+/**
+ * Find all Jest automocks in the AST that match the given import path.
+ */
+function findMatchingAutomocks({
+  sourceCode,
+  importPath
+}) {
+  const automocks = [];
+  const ast = sourceCode.ast;
+  for (const statement of ast.body) {
+    const automock = getJestAutomock(statement);
+    if (automock && automock.path === importPath) {
+      automocks.push(automock);
+    }
+  }
+  return automocks;
+}
+
+/**
+ * Build a jest.mock() statement string
+ */
+function buildAutomockStatement({
+  path,
+  quoteChar
+}) {
+  return `jest.mock(${quoteChar}${path}${quoteChar});`;
+}
+
+/**
+ * Creates a fix to remove a node with proper whitespace handling.
+ * Removes surrounding newlines to avoid leaving blank lines.
+ */
+function createNodeRemovalFix({
+  fixer,
+  node,
+  sourceCode
+}) {
+  const nodeStart = node.range[0];
+  const nodeEnd = node.range[1];
+
+  // Check for leading newline (prefer removing the line separator before the node)
+  const textBeforeNode = sourceCode.text.slice(0, nodeStart);
+  const 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
+  const textAfterNode = sourceCode.text.slice(nodeEnd);
+  const 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({
+  fixer,
+  node,
+  context,
+  importContext,
+  specifiersByTarget,
+  unmappedSpecifiers
+}) {
+  const {
+    importPath,
+    packageName
+  } = importContext;
+  const sourceCode = context.sourceCode;
+  const quote = sourceCode.getText(node.source)[0]; // Get quote character
+
+  const fixes = [];
+  const newStatements = [];
+
+  // Find any Jest automocks that match this import path
+  const automocks = findMatchingAutomocks({
+    sourceCode,
+    importPath
+  });
+
+  // Track which new import paths need automocks (only value imports, not type-only)
+  const automockPaths = [];
+
+  // Track if we have any value imports at all (to determine if automocks should be updated)
+  let hasAnyValueImports = false;
+
+  // Get all existing imports to check for merging
+  const allImports = sourceCode.ast.body.filter(n => n.type === 'ImportDeclaration' && n !== node);
+
+  // Generate new import statements for each target export path
+  for (const [targetExportPath, specsWithTarget] of specifiersByTarget) {
+    // Check if this is a cross-package re-export (sourcePackageName is set)
+    const isCrossPackage = specsWithTarget.some(s => s.sourcePackageName);
+    const 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)
+    const specs = specsWithTarget.map(({
+      spec,
+      originalName,
+      kind
+    }) => transformSpecifierForExport({
+      spec,
+      originalName,
+      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) {
+      const hasValueImport = specsWithTarget.some(({
+        kind,
+        spec
+      }) => kind === 'value' && (spec.type !== 'ImportSpecifier' || spec.importKind !== 'type'));
+      if (hasValueImport) {
+        hasAnyValueImports = true;
+        automockPaths.push(newImportPath);
+      }
+    }
+
+    // Check for existing import from the same path
+    const existingImport = allImports.find(n => n.source.value === newImportPath);
+
+    // Skip merging if existing is namespace import
+    const isNamespace = existingImport === null || existingImport === void 0 ? void 0 : existingImport.specifiers.some(s => s.type === 'ImportNamespaceSpecifier');
+    if (existingImport && !isNamespace) {
+      // Merge with existing import
+      const newImportStatement = buildMergedImportStatement({
+        existingImport,
+        newSpecs: specs,
+        newImportPath,
+        nodeImportKind: node.importKind,
+        quoteChar: quote
+      });
+      if (newImportStatement.length > 0) {
+        fixes.push(fixer.replaceText(existingImport, newImportStatement));
+      }
+    } else {
+      // Create new import
+      const isTypeImport = node.importKind === 'type';
+      const importStatement = buildImportStatement({
+        specs,
+        path: newImportPath,
+        quoteChar: quote,
+        isTypeImport
+      });
+      if (importStatement.length > 0) {
+        newStatements.push(importStatement);
+      }
+    }
+  }
+
+  // Handle unmapped specifiers - they stay in the original import
+  if (unmappedSpecifiers.length > 0) {
+    const unmappedSpecs = unmappedSpecifiers.map(u => u.spec);
+    const isTypeImport = node.importKind === 'type';
+    const remainingImport = buildImportStatement({
+      specs: unmappedSpecs,
+      path: importPath,
+      quoteChar: quote,
+      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) {
+      const hasUnmappedValueImport = unmappedSpecifiers.some(({
+        kind,
+        spec
+      }) => 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,
+      node,
+      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) {
+    for (const automock of automocks) {
+      // Build new automock statements for all new paths
+      const newAutomockStatements = automockPaths.map(path => buildAutomockStatement({
+        path,
+        quoteChar: automock.quoteChar
+      }));
+
+      // Replace the original automock statement with the new automock(s)
+      fixes.push(fixer.replaceTextRange(automock.statementNode.range, newAutomockStatements.join('\n')));
+    }
+  }
+  return fixes;
+}
+function isPlainRequireCall(node) {
+  if (node.callee.type !== 'Identifier' || node.callee.name !== 'require') {
+    return false;
+  }
+  if (node.arguments.length !== 1) {
+    return false;
+  }
+  const arg = node.arguments[0];
+  return arg.type === 'Literal' && typeof arg.value === 'string';
+}
+function unwrapToRequireCall(expr) {
+  let e = expr;
+  for (;;) {
+    const wrapped = e;
+    if (wrapped.type !== 'ParenthesizedExpression' || !wrapped.expression) {
+      break;
+    }
+    e = wrapped.expression;
+  }
+  if (e.type !== 'CallExpression' || !isPlainRequireCall(e)) {
+    return null;
+  }
+  return e;
+}
+function buildSyntheticImportFromRequireAccess(exportPropertyName, modulePath) {
+  const specifiers = exportPropertyName === 'default' ? [{
+    type: 'ImportDefaultSpecifier',
+    local: {
+      type: 'Identifier',
+      name: '_r'
+    }
+  }] : [{
+    type: 'ImportSpecifier',
+    imported: {
+      type: 'Identifier',
+      name: exportPropertyName
+    },
+    local: {
+      type: 'Identifier',
+      name: exportPropertyName
+    }
+  }];
+  return {
+    type: 'ImportDeclaration',
+    source: {
+      type: 'Literal',
+      value: modulePath,
+      raw: `'${modulePath}'`
+    },
+    specifiers,
+    importKind: 'value'
+  };
+}
+function fullNewImportPathForTarget(targetKey, specsWithTarget, packageName) {
+  const isCrossPackage = specsWithTarget.some(s => s.sourcePackageName);
+  return isCrossPackage ? targetKey : packageName + targetKey.slice(1);
+}
+function getRhsPropertyAfterTransform(spec) {
+  if (spec.type === 'ImportDefaultSpecifier') {
+    return 'default';
+  }
+  return getImportedName(spec);
+}
+function appendAutomockFixesForPathMigration({
+  fixer,
+  sourceCode,
+  oldBarrelPath,
+  newPaths
+}) {
+  const automocks = findMatchingAutomocks({
+    sourceCode,
+    importPath: oldBarrelPath
+  });
+  if (automocks.length === 0 || newPaths.length === 0) {
+    return [];
+  }
+  const fixes = [];
+  for (const automock of automocks) {
+    const newAutomockStatements = newPaths.map(path => buildAutomockStatement({
+      path,
+      quoteChar: automock.quoteChar
+    }));
+    fixes.push(fixer.replaceTextRange(automock.statementNode.range, newAutomockStatements.join('\n')));
+  }
+  return fixes;
+}
+
+/**
+ * `require('barrel').default` or `require('barrel').namedExport`
+ */
+function handleRequireMemberExpression({
+  node,
+  context,
+  workspaceRoot,
+  fs,
+  applyToImportsFrom
+}) {
+  if (node.computed || node.property.type !== 'Identifier') {
+    return;
+  }
+  const reqCall = unwrapToRequireCall(node.object);
+  if (!reqCall) {
+    return;
+  }
+  const modulePath = reqCall.arguments[0].value;
+  const importContext = resolveImportContextFromModulePath({
+    importPath: modulePath,
+    workspaceRoot,
+    fs,
+    applyToImportsFrom
+  });
+  if (!importContext) {
+    return;
+  }
+  const exportPropertyName = node.property.name;
+  const synthetic = buildSyntheticImportFromRequireAccess(exportPropertyName, modulePath);
+  const {
+    specifiersByTarget,
+    hasNamespaceImport
+  } = classifySpecifiers({
+    node: synthetic,
+    importContext,
+    workspaceRoot,
+    fs
+  });
+  if (hasNamespaceImport || specifiersByTarget.size === 0) {
+    return;
+  }
+  const entries = [...specifiersByTarget.entries()];
+  if (entries.length !== 1) {
+    return;
+  }
+  const [targetKey, specsWithTarget] = entries[0];
+  if (specsWithTarget.length !== 1) {
+    return;
+  }
+  const st = specsWithTarget[0];
+  const newImportPath = fullNewImportPathForTarget(targetKey, specsWithTarget, importContext.packageName);
+  const transformed = transformSpecifierForExport({
+    spec: st.spec,
+    originalName: st.originalName,
+    kind: st.kind
+  });
+  const newRhs = getRhsPropertyAfterTransform(transformed);
+  const sourceCode = context.getSourceCode();
+  const quote = sourceCode.getText(reqCall.arguments[0])[0];
+  context.report({
+    node: node,
+    messageId: 'barrelEntryImport',
+    data: {
+      path: importContext.importPath
+    },
+    fix(fixer) {
+      const fixes = [];
+      fixes.push(fixer.replaceText(node, `require(${quote}${newImportPath}${quote}).${newRhs}`));
+      if (st.kind === 'value') {
+        fixes.push(...appendAutomockFixesForPathMigration({
+          fixer,
+          sourceCode,
+          oldBarrelPath: modulePath,
+          newPaths: [newImportPath]
+        }));
+      }
+      return fixes;
+    }
+  });
+}
+
+/**
+ * `const { a, b } = require('barrel')`
+ */
+function handleRequireDestructuringDeclarator({
+  node,
+  context,
+  workspaceRoot,
+  fs,
+  applyToImportsFrom
+}) {
+  if (node.id.type !== 'ObjectPattern' || !node.init || node.init.type !== 'CallExpression') {
+    return;
+  }
+  const initCall = node.init;
+  if (!isPlainRequireCall(initCall)) {
+    return;
+  }
+  const modulePath = initCall.arguments[0].value;
+  const importContext = resolveImportContextFromModulePath({
+    importPath: modulePath,
+    workspaceRoot,
+    fs,
+    applyToImportsFrom
+  });
+  if (!importContext) {
+    return;
+  }
+  const specifiers = [];
+  for (const prop of node.id.properties) {
+    if (prop.type !== 'Property' || prop.computed) {
+      continue;
+    }
+    if (prop.key.type !== 'Identifier' || prop.value.type !== 'Identifier') {
+      continue;
+    }
+    const importedName = prop.key.name;
+    const localName = prop.value.name;
+    specifiers.push({
+      type: 'ImportSpecifier',
+      imported: {
+        type: 'Identifier',
+        name: importedName
+      },
+      local: {
+        type: 'Identifier',
+        name: localName
+      }
+    });
+  }
+  if (specifiers.length === 0) {
+    return;
+  }
+  const synthetic = {
+    type: 'ImportDeclaration',
+    source: {
+      type: 'Literal',
+      value: modulePath,
+      raw: `'${modulePath}'`
+    },
+    specifiers,
+    importKind: 'value'
+  };
+  const {
+    specifiersByTarget,
+    unmappedSpecifiers,
+    hasNamespaceImport
+  } = classifySpecifiers({
+    node: synthetic,
+    importContext,
+    workspaceRoot,
+    fs
+  });
+  if (hasNamespaceImport || specifiersByTarget.size === 0 || unmappedSpecifiers.length > 0) {
+    return;
+  }
+  const parentDecl = node.parent;
+  if (parentDecl.type !== 'VariableDeclaration') {
+    return;
+  }
+  if (specifiersByTarget.size > 1 && parentDecl.declarations.length !== 1) {
+    return;
+  }
+  const sourceCode = context.getSourceCode();
+  const quote = sourceCode.getText(initCall.arguments[0])[0];
+  const pkg = importContext.packageName;
+  const buildFixes = fixer => {
+    const fixes = [];
+    let hasValue = false;
+    const automockPaths = [];
+    if (specifiersByTarget.size === 1) {
+      const [targetKey, specsWithTarget] = [...specifiersByTarget.entries()][0];
+      const newImportPath = fullNewImportPathForTarget(targetKey, specsWithTarget, pkg);
+      if (specsWithTarget.some(s => s.kind === 'value')) {
+        hasValue = true;
+        automockPaths.push(newImportPath);
+      }
+      fixes.push(fixer.replaceText(initCall.arguments[0], `${quote}${newImportPath}${quote}`));
+    } else {
+      const lines = [];
+      for (const [targetKey, specsWithTarget] of specifiersByTarget) {
+        const newImportPath = fullNewImportPathForTarget(targetKey, specsWithTarget, pkg);
+        if (specsWithTarget.some(s => s.kind === 'value')) {
+          hasValue = true;
+          automockPaths.push(newImportPath);
+        }
+        for (const st of specsWithTarget) {
+          const transformed = transformSpecifierForExport({
+            spec: st.spec,
+            originalName: st.originalName,
+            kind: st.kind
+          });
+          const rhs = getRhsPropertyAfterTransform(transformed);
+          const local = st.spec.local.name;
+          lines.push(`${local} = require(${quote}${newImportPath}${quote}).${rhs}`);
+        }
+      }
+      const declText = lines.map(l => `${parentDecl.kind} ${l};`).join('\n');
+      fixes.push(fixer.replaceText(parentDecl, declText));
+    }
+    if (hasValue) {
+      fixes.push(...appendAutomockFixesForPathMigration({
+        fixer,
+        sourceCode,
+        oldBarrelPath: modulePath,
+        newPaths: [...new Set(automockPaths)]
+      }));
+    }
+    return fixes;
+  };
+  context.report({
+    node: initCall,
+    messageId: 'barrelEntryImport',
+    data: {
+      path: importContext.importPath
+    },
+    fix: buildFixes
+  });
+}
+
+/**
+ * Handles an ImportDeclaration node to check for barrel file imports.
+ * Reports and auto-fixes imports that could use more specific export paths.
+ */
+function handleImportDeclaration({
+  node,
+  context,
+  workspaceRoot,
+  fs,
+  applyToImportsFrom
+}) {
+  // Resolve import context (validates and extracts package/export info)
+  // applyToImportsFrom is used here to filter which packages the rule applies to
+  const importContext = resolveImportContext({
+    node,
+    workspaceRoot,
+    fs,
+    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
+  const {
+    specifiersByTarget,
+    unmappedSpecifiers,
+    hasNamespaceImport
+  } = classifySpecifiers({
+    node,
+    importContext,
+    workspaceRoot,
+    fs
+  });
+
+  // If namespace import, report without auto-fix if there are specific exports available
+  if (hasNamespaceImport) {
+    if (specifiersByTarget.size > 0) {
+      context.report({
+        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,
+    messageId: 'barrelEntryImport',
+    data: {
+      path: importContext.importPath
+    },
+    fix(fixer) {
+      return createBarrelImportFix({
+        fixer,
+        node,
+        context,
+        importContext,
+        specifiersByTarget,
+        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(context) {
+      var _options$applyToImpor;
+      const options = context.options[0] || {};
+      const applyToImportsFrom = (_options$applyToImpor = options.applyToImportsFrom) !== null && _options$applyToImpor !== void 0 ? _options$applyToImpor : DEFAULT_TARGET_FOLDERS;
+      const workspaceRoot = findWorkspaceRoot({
+        startPath: dirname(context.filename),
+        fs,
+        applyToImportsFrom
+      });
+      return {
+        ImportDeclaration(rawNode) {
+          const node = rawNode;
+          handleImportDeclaration({
+            node,
+            context,
+            workspaceRoot,
+            fs,
+            applyToImportsFrom
+          });
+        },
+        MemberExpression(rawNode) {
+          handleRequireMemberExpression({
+            node: rawNode,
+            context,
+            workspaceRoot,
+            fs,
+            applyToImportsFrom
+          });
+        },
+        VariableDeclarator(rawNode) {
+          handleRequireDestructuringDeclarator({
+            node: rawNode,
+            context,
+            workspaceRoot,
+            fs,
+            applyToImportsFrom
+          });
+        }
+      };
+    }
+  };
+}
+const rule = createRule(realFileSystem);
+export default rule;