@atlaskit/eslint-plugin-platform 2.7.1 → 2.8.0

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

@@ -0,0 +1,777 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createRule = createRule;
+exports.default = void 0;
+var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));
+var _path = require("path");
+var _barrelParsing = require("../shared/barrel-parsing");
+var _fileSystem = require("../shared/file-system");
+var _packageRegistry = require("../shared/package-registry");
+var _packageResolution = require("../shared/package-resolution");
+var _types = require("../shared/types");
+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) { (0, _defineProperty2.default)(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; }
+/**
+ * Specifier with additional metadata for tracking during barrel file resolution.
+ */
+
+/**
+ * Context for barrel file resolution, returned by resolveBarrelFileContext.
+ */
+
+/**
+ * Result of collecting specifiers by their source file.
+ */
+
+// Cache per source package name to avoid repeated exports parsing during a single lint run.
+// This is keyed by fs instance to avoid test pollution.
+var sourcePackageExportsMapsByFs = new WeakMap();
+function getSourcePackageExportsMaps(fs) {
+  var map = sourcePackageExportsMapsByFs.get(fs);
+  if (!map) {
+    map = new Map();
+    sourcePackageExportsMapsByFs.set(fs, map);
+  }
+  return map;
+}
+function getImportedName(spec) {
+  var imported = spec.imported;
+  return imported.type === 'Identifier' ? imported.name : String(imported.value);
+}
+
+/**
+ * Get the exported name from an ExportSpecifier, handling both Identifier and Literal
+ */
+function getExportedName(node) {
+  return node.type === 'Identifier' ? node.name : String(node.value);
+}
+
+/**
+ * Convert absolute file path back to relative import path
+ */
+function getImportPathForSourceFile(_ref) {
+  var _exportInfo$crossPack;
+  var sourceFilePath = _ref.sourceFilePath,
+    basedir = _ref.basedir,
+    originalImportPath = _ref.originalImportPath,
+    exportInfo = _ref.exportInfo,
+    workspaceRoot = _ref.workspaceRoot,
+    fs = _ref.fs;
+  var crossPackageName = exportInfo === null || exportInfo === void 0 || (_exportInfo$crossPack = exportInfo.crossPackageSource) === null || _exportInfo$crossPack === void 0 ? void 0 : _exportInfo$crossPack.packageName;
+  if (crossPackageName) {
+    var sourcePackageExportsMaps = getSourcePackageExportsMaps(fs);
+    var exportsMap = sourcePackageExportsMaps.get(crossPackageName);
+    if (!exportsMap) {
+      var pkgDir = (0, _packageRegistry.findPackageInRegistry)({
+        packageName: crossPackageName,
+        workspaceRoot: workspaceRoot,
+        fs: fs
+      });
+      if (pkgDir) {
+        exportsMap = (0, _packageResolution.parsePackageExports)({
+          packageDir: pkgDir,
+          fs: fs
+        });
+        sourcePackageExportsMaps.set(crossPackageName, exportsMap);
+      }
+    }
+    var targetExportPath = exportsMap ? (0, _packageResolution.findExportForSourceFile)({
+      sourceFilePath: sourceFilePath,
+      exportsMap: exportsMap
+    }) : null;
+    return targetExportPath ? crossPackageName + targetExportPath.slice(1) : crossPackageName;
+  }
+  return getRelativeImportPath({
+    basedir: basedir,
+    absolutePath: sourceFilePath,
+    originalImportPath: originalImportPath
+  });
+}
+function getRelativeImportPath(_ref2) {
+  var basedir = _ref2.basedir,
+    absolutePath = _ref2.absolutePath,
+    originalImportPath = _ref2.originalImportPath;
+  if (!absolutePath.startsWith('/') && !absolutePath.match(/^[a-zA-Z]:/)) {
+    return absolutePath;
+  }
+  var relativePath = (0, _path.relative)(basedir, absolutePath);
+  // Normalize to use forward slashes
+  relativePath = relativePath.replace(/\\/g, '/');
+
+  // Check for extension in original path
+  var extMatch = originalImportPath.match(/\.(js|jsx|ts|tsx|mjs|cjs)$/);
+  var originalExt = extMatch ? extMatch[0] : '';
+
+  // Get extension from the resolved absolute path
+  var targetExtMatch = absolutePath.match(/\.(js|jsx|ts|tsx|mjs|cjs)$/);
+  var targetExt = targetExtMatch ? targetExtMatch[0] : '';
+
+  // Remove file extension from the target path
+  relativePath = relativePath.replace(/\.(ts|tsx|js|jsx|mjs|cjs)$/, '');
+
+  // If original had extension, append it
+  if (originalExt) {
+    // If original was a TypeScript source extension, use the actual target extension
+    if (['.ts', '.tsx'].includes(originalExt) && targetExt) {
+      relativePath += targetExt;
+    } else {
+      relativePath += originalExt;
+    }
+  } else {
+    // Remove /index suffix only if no extension was present
+    if (relativePath.endsWith('/index')) {
+      relativePath = relativePath.slice(0, -6);
+    } else if (relativePath === 'index') {
+      relativePath = '.';
+    }
+  }
+
+  // Ensure it starts with .. or .
+  if (!relativePath.startsWith('.') && !relativePath.startsWith('/')) {
+    relativePath = './' + relativePath;
+  }
+  return relativePath;
+}
+
+/**
+ * Build an import statement for a set of specifiers
+ */
+function buildImportStatement(_ref3) {
+  var specs = _ref3.specs,
+    path = _ref3.path,
+    quoteChar = _ref3.quoteChar,
+    _ref3$isTypeImport = _ref3.isTypeImport,
+    isTypeImport = _ref3$isTypeImport === void 0 ? false : _ref3$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, ";");
+  }
+}
+
+/**
+ * Build an export statement for a set of specifiers
+ */
+function buildExportStatement(_ref4) {
+  var specs = _ref4.specs,
+    path = _ref4.path,
+    quoteChar = _ref4.quoteChar,
+    _ref4$isTypeExport = _ref4.isTypeExport,
+    isTypeExport = _ref4$isTypeExport === void 0 ? false : _ref4$isTypeExport;
+  var exportNames = specs.map(function (spec) {
+    var isInlineType = spec.kind === 'type' && !isTypeExport;
+    var prefix = isInlineType ? 'type ' : '';
+    return spec.nameInSource === spec.nameInLocal ? "".concat(prefix).concat(spec.nameInSource) : "".concat(prefix).concat(spec.nameInSource, " as ").concat(spec.nameInLocal);
+  }).filter(function (name) {
+    return name.length > 0;
+  });
+  if (exportNames.length === 0) {
+    return '';
+  }
+  var typeKeyword = isTypeExport ? 'type ' : '';
+  return "export ".concat(typeKeyword, "{ ").concat(exportNames.join(', '), " } from ").concat(quoteChar).concat(path).concat(quoteChar, ";");
+}
+var ruleMeta = {
+  type: 'problem',
+  docs: {
+    description: 'Warn when imports are from a relative barrel file and provide an auto-fix to split them into specific imports.',
+    category: 'Best Practices',
+    recommended: false
+  },
+  fixable: 'code',
+  messages: {
+    barrelImport: "Import from barrel file '{{path}}' should be split into more specific imports. Use auto-fix to resolve."
+  }
+};
+
+/**
+ * Resolve barrel file context from an import/export node.
+ * Returns null if the node should not be checked (not relative, not resolvable, not a barrel).
+ */
+function resolveBarrelFileContext(_ref5) {
+  var node = _ref5.node,
+    context = _ref5.context,
+    fs = _ref5.fs;
+  if (!node.source) {
+    return null;
+  }
+  var importPath = node.source.value;
+  if (!(0, _fileSystem.isRelativeImport)(importPath)) {
+    return null;
+  }
+  var basedir = (0, _path.dirname)(context.filename);
+  var resolvedPath = (0, _fileSystem.resolveImportPath)({
+    basedir: basedir,
+    importPath: importPath,
+    fs: fs
+  });
+  if (!resolvedPath) {
+    return null;
+  }
+  var workspaceRoot = (0, _fileSystem.findWorkspaceRoot)({
+    startPath: basedir,
+    fs: fs
+  });
+  var exportMap = (0, _barrelParsing.parseBarrelExports)({
+    barrelFilePath: resolvedPath,
+    workspaceRoot: workspaceRoot,
+    fs: fs
+  });
+  if (exportMap.size === 0) {
+    return null;
+  }
+  if (!(0, _barrelParsing.hasReExportsFromOtherFiles)({
+    exportMap: exportMap,
+    sourceFilePath: resolvedPath
+  })) {
+    return null;
+  }
+  return {
+    importPath: importPath,
+    basedir: basedir,
+    resolvedPath: resolvedPath,
+    workspaceRoot: workspaceRoot,
+    exportMap: exportMap
+  };
+}
+
+/**
+ * Collect specifiers grouped by their source file.
+ */
+function collectSpecifiersBySource(_ref6) {
+  var specifiers = _ref6.specifiers,
+    node = _ref6.node,
+    exportMap = _ref6.exportMap;
+  var importsBySource = new Map();
+  var unmappedSpecifiers = [];
+  var hasNamespaceImport = false;
+  var _iterator = _createForOfIteratorHelper(specifiers),
+    _step;
+  try {
+    for (_iterator.s(); !(_step = _iterator.n()).done;) {
+      var spec = _step.value;
+      var nameInSource = void 0;
+      var nameInLocal = void 0;
+      var kind = 'value';
+      if (spec.type === 'ImportNamespaceSpecifier') {
+        hasNamespaceImport = true;
+        continue;
+      }
+      if (spec.type === 'ImportDefaultSpecifier') {
+        nameInSource = 'default';
+        nameInLocal = spec.local.name;
+      } else if (spec.type === 'ImportSpecifier') {
+        nameInSource = getImportedName(spec);
+        nameInLocal = spec.local.name;
+        var parentImportKind = node.type === 'ImportDeclaration' ? node.importKind : undefined;
+        kind = parentImportKind === 'type' || spec.importKind === 'type' ? 'type' : 'value';
+      } else if (spec.type === 'ExportSpecifier') {
+        nameInSource = spec.local.name;
+        nameInLocal = spec.exported.name;
+        var parentExportKind = node.type === 'ExportNamedDeclaration' ? node.exportKind : undefined;
+        kind = parentExportKind === 'type' || spec.exportKind === 'type' ? 'type' : 'value';
+      } else {
+        continue;
+      }
+      var exportInfo = exportMap.get(nameInSource);
+      if (exportInfo) {
+        if (!importsBySource.has(exportInfo.path)) {
+          importsBySource.set(exportInfo.path, []);
+        }
+        var effectiveKind = kind === 'type' || exportInfo.isTypeOnly ? 'type' : 'value';
+        importsBySource.get(exportInfo.path).push({
+          spec: spec,
+          originalName: exportInfo.originalName,
+          exportInfo: exportInfo,
+          nameInSource: nameInSource,
+          nameInLocal: nameInLocal,
+          kind: effectiveKind
+        });
+      } else {
+        unmappedSpecifiers.push(spec);
+      }
+    }
+  } catch (err) {
+    _iterator.e(err);
+  } finally {
+    _iterator.f();
+  }
+  return {
+    importsBySource: importsBySource,
+    unmappedSpecifiers: unmappedSpecifiers,
+    hasNamespaceImport: hasNamespaceImport
+  };
+}
+
+/**
+ * Find an existing import statement that imports from the same source file.
+ */
+function findExistingImportForSourceFile(_ref7) {
+  var sourceFile = _ref7.sourceFile,
+    allImports = _ref7.allImports,
+    basedir = _ref7.basedir,
+    fs = _ref7.fs;
+  return allImports.find(function (n) {
+    var isSourceAbsolute = sourceFile.startsWith('/') || sourceFile.match(/^[a-zA-Z]:/);
+    if (!(0, _fileSystem.isRelativeImport)(sourceFile) && !isSourceAbsolute) {
+      return n.source.value === sourceFile;
+    }
+    if (!(0, _fileSystem.isRelativeImport)(n.source.value)) {
+      return false;
+    }
+    var existingPath = (0, _fileSystem.resolveImportPath)({
+      basedir: basedir,
+      importPath: n.source.value,
+      fs: fs
+    });
+    return existingPath === sourceFile;
+  });
+}
+
+/**
+ * Find an existing export statement that exports from the same source file.
+ */
+function findExistingExportForSourceFile(_ref8) {
+  var sourceFile = _ref8.sourceFile,
+    allExports = _ref8.allExports,
+    basedir = _ref8.basedir,
+    fs = _ref8.fs;
+  return allExports.find(function (n) {
+    if (!n.source) {
+      return false;
+    }
+    var isSourceAbsolute = sourceFile.startsWith('/') || sourceFile.match(/^[a-zA-Z]:/);
+    if (!(0, _fileSystem.isRelativeImport)(sourceFile) && !isSourceAbsolute) {
+      return n.source.value === sourceFile;
+    }
+    if (!(0, _fileSystem.isRelativeImport)(n.source.value)) {
+      return false;
+    }
+    var existingPath = (0, _fileSystem.resolveImportPath)({
+      basedir: basedir,
+      importPath: n.source.value,
+      fs: fs
+    });
+    return existingPath === sourceFile;
+  });
+}
+
+/**
+ * Transform import specifiers to handle aliasing when the original name differs.
+ */
+function transformImportSpecifiers(_ref9) {
+  var specsWithOriginal = _ref9.specsWithOriginal;
+  return specsWithOriginal.map(function (_ref0) {
+    var spec = _ref0.spec,
+      originalName = _ref0.originalName,
+      kind = _ref0.kind;
+    if (!originalName) {
+      return spec;
+    }
+    if (originalName === 'default') {
+      if (spec.type === 'ImportDefaultSpecifier') {
+        return spec;
+      }
+      return {
+        type: 'ImportDefaultSpecifier',
+        local: spec.local,
+        range: spec.range,
+        loc: spec.loc,
+        parent: spec.parent
+      };
+    } else {
+      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
+      };
+    }
+  });
+}
+
+/**
+ * Transform export specifiers to use original names from source.
+ */
+function transformExportSpecifiers(_ref1) {
+  var specsWithOriginal = _ref1.specsWithOriginal;
+  return specsWithOriginal.map(function (_ref10) {
+    var originalName = _ref10.originalName,
+      nameInLocal = _ref10.nameInLocal,
+      kind = _ref10.kind;
+    return {
+      nameInSource: originalName || 'default',
+      nameInLocal: nameInLocal,
+      kind: kind
+    };
+  });
+}
+function createRule(fs) {
+  return {
+    meta: ruleMeta,
+    create: function create(context) {
+      var checkNode = function checkNode(rawNode) {
+        var node = rawNode;
+
+        // Resolve barrel file context (handles early exits for non-barrel files)
+        var barrelContext = resolveBarrelFileContext({
+          node: node,
+          context: context,
+          fs: fs
+        });
+        if (!barrelContext) {
+          return;
+        }
+        var importPath = barrelContext.importPath,
+          resolvedPath = barrelContext.resolvedPath,
+          exportMap = barrelContext.exportMap;
+
+        // Check if we have any imports from this barrel
+        var specifiers = node.specifiers;
+        if (specifiers.length === 0) {
+          return;
+        }
+
+        // Collect imports by source file
+        var _collectSpecifiersByS = collectSpecifiersBySource({
+            specifiers: specifiers,
+            node: node,
+            exportMap: exportMap
+          }),
+          importsBySource = _collectSpecifiersByS.importsBySource,
+          unmappedSpecifiers = _collectSpecifiersByS.unmappedSpecifiers,
+          hasNamespaceImport = _collectSpecifiersByS.hasNamespaceImport;
+
+        // If we have import * as, warn but don't auto-fix (too complex)
+        if (hasNamespaceImport) {
+          context.report({
+            node: node,
+            messageId: 'barrelImport',
+            data: {
+              path: importPath
+            }
+          });
+          return;
+        }
+
+        // Check if we actually found any imports that map to the barrel exports
+        // If we found 0 mapped imports (all are unknown or missing), don't warn
+        if (importsBySource.size === 0) {
+          return;
+        }
+
+        // If all imports map back to the resolved path itself, don't warn.
+        // This happens when the file (e.g. index.ts) exports the symbols directly (not re-exports),
+        // so it is not acting as a barrel file for these imports.
+        if (importsBySource.size === 1 && importsBySource.has(resolvedPath)) {
+          return;
+        }
+
+        // Build the report with optional auto-fix
+        var reportObj = {
+          node: node,
+          messageId: 'barrelImport',
+          data: {
+            path: importPath
+          }
+        };
+
+        // Only provide auto-fix if all imports are mapped
+        // If there are unmapped specifiers, don't auto-fix to avoid issues
+        var nodeSource = node.source;
+        if (unmappedSpecifiers.length === 0 && nodeSource) {
+          reportObj.fix = function (fixer) {
+            var sourceCode = context.getSourceCode();
+            var quote = sourceCode.getText(nodeSource)[0]; // Get quote character
+            var basedirForFix = (0, _path.dirname)(context.filename);
+            var fixes = [];
+            var newStatementsForBarrelReplacement = [];
+
+            // Generate new import statements for each source file
+            var sourceFileArray = Array.from(importsBySource.entries());
+            var _loop = function _loop() {
+              var _sourceFileArray$i = (0, _slicedToArray2.default)(sourceFileArray[i], 2),
+                sourceFile = _sourceFileArray$i[0],
+                specsWithOriginal = _sourceFileArray$i[1];
+              if (node.type === 'ImportDeclaration') {
+                // Transform specifiers if needed (handle aliasing)
+                var specs = transformImportSpecifiers({
+                  specsWithOriginal: specsWithOriginal
+                });
+
+                // Get all existing imports to check for merging
+                var allImports = sourceCode.ast.body.filter(function (n) {
+                  return n.type === 'ImportDeclaration' && n !== node;
+                });
+
+                // Check for existing import
+                var existingImport = findExistingImportForSourceFile({
+                  sourceFile: sourceFile,
+                  allImports: allImports,
+                  basedir: basedirForFix,
+                  fs: fs
+                });
+
+                // 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) {
+                  var _specsWithOriginal$0$, _specsWithOriginal$;
+                  // Merge!
+                  var existingSpecs = existingImport.specifiers.map(function (s) {
+                    // Normalize importKind
+                    if (existingImport.importKind === 'type') {
+                      // If the parent declaration is 'type', treat all specifiers as 'type'
+                      // We cast to AugmentedSpecifier to allow attaching importKind to DefaultSpecifier
+                      return _objectSpread(_objectSpread({}, s), {}, {
+                        importKind: 'type'
+                      });
+                    }
+                    return s;
+                  });
+                  var newSpecs = specs.map(function (s) {
+                    if (node.importKind === 'type') {
+                      return _objectSpread(_objectSpread({}, s), {}, {
+                        importKind: 'type'
+                      });
+                    }
+                    return s;
+                  });
+                  var mergedSpecs = [].concat((0, _toConsumableArray2.default)(existingSpecs), (0, _toConsumableArray2.default)(newSpecs));
+
+                  // Determine if we should use 'import type'
+                  var allType = mergedSpecs.every(function (s) {
+                    return s.importKind === 'type';
+                  });
+                  var relativePath = getImportPathForSourceFile({
+                    sourceFilePath: sourceFile,
+                    basedir: basedirForFix,
+                    originalImportPath: importPath,
+                    exportInfo: (_specsWithOriginal$0$ = (_specsWithOriginal$ = specsWithOriginal[0]) === null || _specsWithOriginal$ === void 0 ? void 0 : _specsWithOriginal$.exportInfo) !== null && _specsWithOriginal$0$ !== void 0 ? _specsWithOriginal$0$ : null,
+                    workspaceRoot: (0, _fileSystem.findWorkspaceRoot)({
+                      startPath: basedirForFix,
+                      fs: fs
+                    }),
+                    fs: fs
+                  });
+                  var newImportStatement = buildImportStatement({
+                    specs: mergedSpecs,
+                    path: relativePath,
+                    quoteChar: quote,
+                    isTypeImport: allType // Use type import if all are types
+                  });
+                  if (newImportStatement.length > 0) {
+                    fixes.push(fixer.replaceText(existingImport, newImportStatement));
+                  }
+                } else {
+                  var _specsWithOriginal$0$2, _specsWithOriginal$2;
+                  // Create new import
+                  var _relativePath = getImportPathForSourceFile({
+                    sourceFilePath: sourceFile,
+                    basedir: basedirForFix,
+                    originalImportPath: importPath,
+                    exportInfo: (_specsWithOriginal$0$2 = (_specsWithOriginal$2 = specsWithOriginal[0]) === null || _specsWithOriginal$2 === void 0 ? void 0 : _specsWithOriginal$2.exportInfo) !== null && _specsWithOriginal$0$2 !== void 0 ? _specsWithOriginal$0$2 : null,
+                    workspaceRoot: (0, _fileSystem.findWorkspaceRoot)({
+                      startPath: basedirForFix,
+                      fs: fs
+                    }),
+                    fs: fs
+                  });
+                  var isTypeImport = node.importKind === 'type';
+                  var importStatement = buildImportStatement({
+                    specs: specs,
+                    path: _relativePath,
+                    quoteChar: quote,
+                    isTypeImport: isTypeImport
+                  });
+                  if (importStatement.length > 0) {
+                    newStatementsForBarrelReplacement.push(importStatement);
+                  }
+                }
+              } else if (node.type === 'ExportNamedDeclaration') {
+                // Handle ExportNamedDeclaration
+                var _specs = transformExportSpecifiers({
+                  specsWithOriginal: specsWithOriginal
+                });
+
+                // Get all existing exports to check for merging
+                var allExports = sourceCode.ast.body.filter(function (n) {
+                  return n.type === 'ExportNamedDeclaration' && n !== node && !!n.source;
+                });
+
+                // Check for existing export
+                var existingExport = findExistingExportForSourceFile({
+                  sourceFile: sourceFile,
+                  allExports: allExports,
+                  basedir: basedirForFix,
+                  fs: fs
+                });
+                if (existingExport) {
+                  var _specsWithOriginal$0$3, _specsWithOriginal$3;
+                  // Merge!
+                  var _existingSpecs = existingExport.specifiers.map(function (s) {
+                    // For `export type { A, B }`, the parent's exportKind is 'type'
+                    // Individual specifiers have exportKind: 'type' only for inline type (export { type A })
+                    // If parent is type-only, all specifiers are types
+                    // Otherwise, check individual specifier's exportKind
+                    var effectiveKind = existingExport.exportKind === 'type' || s.exportKind === 'type' ? 'type' : 'value';
+                    return {
+                      nameInSource: getExportedName(s.local),
+                      nameInLocal: getExportedName(s.exported),
+                      kind: effectiveKind
+                    };
+                  });
+                  var _newSpecs = _specs.map(function (s) {
+                    if (node.exportKind === 'type') {
+                      return _objectSpread(_objectSpread({}, s), {}, {
+                        kind: 'type'
+                      });
+                    }
+                    return s;
+                  });
+                  var _mergedSpecs = [].concat((0, _toConsumableArray2.default)(_existingSpecs), (0, _toConsumableArray2.default)(_newSpecs));
+
+                  // Determine if we should use 'export type'
+                  var _allType = _mergedSpecs.every(function (s) {
+                    return s.kind === 'type';
+                  });
+                  var _relativePath2 = getImportPathForSourceFile({
+                    sourceFilePath: sourceFile,
+                    basedir: basedirForFix,
+                    originalImportPath: importPath,
+                    exportInfo: (_specsWithOriginal$0$3 = (_specsWithOriginal$3 = specsWithOriginal[0]) === null || _specsWithOriginal$3 === void 0 ? void 0 : _specsWithOriginal$3.exportInfo) !== null && _specsWithOriginal$0$3 !== void 0 ? _specsWithOriginal$0$3 : null,
+                    workspaceRoot: (0, _fileSystem.findWorkspaceRoot)({
+                      startPath: basedirForFix,
+                      fs: fs
+                    }),
+                    fs: fs
+                  });
+                  var newExportStatement = buildExportStatement({
+                    specs: _mergedSpecs,
+                    path: _relativePath2,
+                    quoteChar: quote,
+                    isTypeExport: _allType
+                  });
+                  if (newExportStatement.length > 0) {
+                    fixes.push(fixer.replaceText(existingExport, newExportStatement));
+                  }
+                } else {
+                  var _specsWithOriginal$0$4, _specsWithOriginal$4;
+                  // Create new export
+                  var _relativePath3 = getImportPathForSourceFile({
+                    sourceFilePath: sourceFile,
+                    basedir: basedirForFix,
+                    originalImportPath: importPath,
+                    exportInfo: (_specsWithOriginal$0$4 = (_specsWithOriginal$4 = specsWithOriginal[0]) === null || _specsWithOriginal$4 === void 0 ? void 0 : _specsWithOriginal$4.exportInfo) !== null && _specsWithOriginal$0$4 !== void 0 ? _specsWithOriginal$0$4 : null,
+                    workspaceRoot: (0, _fileSystem.findWorkspaceRoot)({
+                      startPath: basedirForFix,
+                      fs: fs
+                    }),
+                    fs: fs
+                  });
+                  var isTypeExport = node.exportKind === 'type';
+                  var exportStatement = buildExportStatement({
+                    specs: _specs,
+                    path: _relativePath3,
+                    quoteChar: quote,
+                    isTypeExport: isTypeExport
+                  });
+                  if (exportStatement.length > 0) {
+                    newStatementsForBarrelReplacement.push(exportStatement);
+                  }
+                }
+              }
+            };
+            for (var i = 0; i < sourceFileArray.length; i++) {
+              _loop();
+            }
+            if (newStatementsForBarrelReplacement.length > 0) {
+              fixes.push(fixer.replaceText(node, newStatementsForBarrelReplacement.join('\n')));
+            } else {
+              // If all were merged, remove the node
+              fixes.push(fixer.remove(node));
+            }
+            return fixes;
+          };
+        }
+        context.report(reportObj);
+      };
+      return {
+        ImportDeclaration: checkNode,
+        ExportNamedDeclaration: checkNode
+      };
+    }
+  };
+}
+var rule = createRule(_types.realFileSystem);
+var _default = exports.default = rule;