@atlaskit/eslint-plugin-platform 2.7.1 → 2.8.0

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

@@ -0,0 +1,738 @@
+import { dirname, relative } from 'path';
+import { hasReExportsFromOtherFiles, parseBarrelExports as parseBarrelExportsFromShared } from '../shared/barrel-parsing';
+import { findWorkspaceRoot, isRelativeImport, resolveImportPath } from '../shared/file-system';
+import { findPackageInRegistry } from '../shared/package-registry';
+import { findExportForSourceFile, parsePackageExports } from '../shared/package-resolution';
+import { realFileSystem } from '../shared/types';
+
+/**
+ * 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.
+const sourcePackageExportsMapsByFs = new WeakMap();
+function getSourcePackageExportsMaps(fs) {
+  let map = sourcePackageExportsMapsByFs.get(fs);
+  if (!map) {
+    map = new Map();
+    sourcePackageExportsMapsByFs.set(fs, map);
+  }
+  return map;
+}
+function getImportedName(spec) {
+  const 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({
+  sourceFilePath,
+  basedir,
+  originalImportPath,
+  exportInfo,
+  workspaceRoot,
+  fs
+}) {
+  var _exportInfo$crossPack;
+  const crossPackageName = exportInfo === null || exportInfo === void 0 ? void 0 : (_exportInfo$crossPack = exportInfo.crossPackageSource) === null || _exportInfo$crossPack === void 0 ? void 0 : _exportInfo$crossPack.packageName;
+  if (crossPackageName) {
+    const sourcePackageExportsMaps = getSourcePackageExportsMaps(fs);
+    let exportsMap = sourcePackageExportsMaps.get(crossPackageName);
+    if (!exportsMap) {
+      const pkgDir = findPackageInRegistry({
+        packageName: crossPackageName,
+        workspaceRoot,
+        fs
+      });
+      if (pkgDir) {
+        exportsMap = parsePackageExports({
+          packageDir: pkgDir,
+          fs
+        });
+        sourcePackageExportsMaps.set(crossPackageName, exportsMap);
+      }
+    }
+    const targetExportPath = exportsMap ? findExportForSourceFile({
+      sourceFilePath,
+      exportsMap
+    }) : null;
+    return targetExportPath ? crossPackageName + targetExportPath.slice(1) : crossPackageName;
+  }
+  return getRelativeImportPath({
+    basedir,
+    absolutePath: sourceFilePath,
+    originalImportPath
+  });
+}
+function getRelativeImportPath({
+  basedir,
+  absolutePath,
+  originalImportPath
+}) {
+  if (!absolutePath.startsWith('/') && !absolutePath.match(/^[a-zA-Z]:/)) {
+    return absolutePath;
+  }
+  let relativePath = relative(basedir, absolutePath);
+  // Normalize to use forward slashes
+  relativePath = relativePath.replace(/\\/g, '/');
+
+  // Check for extension in original path
+  const extMatch = originalImportPath.match(/\.(js|jsx|ts|tsx|mjs|cjs)$/);
+  const originalExt = extMatch ? extMatch[0] : '';
+
+  // Get extension from the resolved absolute path
+  const targetExtMatch = absolutePath.match(/\.(js|jsx|ts|tsx|mjs|cjs)$/);
+  const 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({
+  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};`;
+  }
+}
+
+/**
+ * Build an export statement for a set of specifiers
+ */
+function buildExportStatement({
+  specs,
+  path,
+  quoteChar,
+  isTypeExport = false
+}) {
+  const exportNames = specs.map(spec => {
+    const isInlineType = spec.kind === 'type' && !isTypeExport;
+    const prefix = isInlineType ? 'type ' : '';
+    return spec.nameInSource === spec.nameInLocal ? `${prefix}${spec.nameInSource}` : `${prefix}${spec.nameInSource} as ${spec.nameInLocal}`;
+  }).filter(name => name.length > 0);
+  if (exportNames.length === 0) {
+    return '';
+  }
+  const typeKeyword = isTypeExport ? 'type ' : '';
+  return `export ${typeKeyword}{ ${exportNames.join(', ')} } from ${quoteChar}${path}${quoteChar};`;
+}
+const 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({
+  node,
+  context,
+  fs
+}) {
+  if (!node.source) {
+    return null;
+  }
+  const importPath = node.source.value;
+  if (!isRelativeImport(importPath)) {
+    return null;
+  }
+  const basedir = dirname(context.filename);
+  const resolvedPath = resolveImportPath({
+    basedir,
+    importPath,
+    fs
+  });
+  if (!resolvedPath) {
+    return null;
+  }
+  const workspaceRoot = findWorkspaceRoot({
+    startPath: basedir,
+    fs
+  });
+  const exportMap = parseBarrelExportsFromShared({
+    barrelFilePath: resolvedPath,
+    workspaceRoot,
+    fs
+  });
+  if (exportMap.size === 0) {
+    return null;
+  }
+  if (!hasReExportsFromOtherFiles({
+    exportMap,
+    sourceFilePath: resolvedPath
+  })) {
+    return null;
+  }
+  return {
+    importPath,
+    basedir,
+    resolvedPath,
+    workspaceRoot,
+    exportMap
+  };
+}
+
+/**
+ * Collect specifiers grouped by their source file.
+ */
+function collectSpecifiersBySource({
+  specifiers,
+  node,
+  exportMap
+}) {
+  const importsBySource = new Map();
+  const unmappedSpecifiers = [];
+  let hasNamespaceImport = false;
+  for (const spec of specifiers) {
+    let nameInSource;
+    let nameInLocal;
+    let 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;
+      const 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;
+      const parentExportKind = node.type === 'ExportNamedDeclaration' ? node.exportKind : undefined;
+      kind = parentExportKind === 'type' || spec.exportKind === 'type' ? 'type' : 'value';
+    } else {
+      continue;
+    }
+    const exportInfo = exportMap.get(nameInSource);
+    if (exportInfo) {
+      if (!importsBySource.has(exportInfo.path)) {
+        importsBySource.set(exportInfo.path, []);
+      }
+      const effectiveKind = kind === 'type' || exportInfo.isTypeOnly ? 'type' : 'value';
+      importsBySource.get(exportInfo.path).push({
+        spec,
+        originalName: exportInfo.originalName,
+        exportInfo,
+        nameInSource,
+        nameInLocal,
+        kind: effectiveKind
+      });
+    } else {
+      unmappedSpecifiers.push(spec);
+    }
+  }
+  return {
+    importsBySource,
+    unmappedSpecifiers,
+    hasNamespaceImport
+  };
+}
+
+/**
+ * Find an existing import statement that imports from the same source file.
+ */
+function findExistingImportForSourceFile({
+  sourceFile,
+  allImports,
+  basedir,
+  fs
+}) {
+  return allImports.find(n => {
+    const isSourceAbsolute = sourceFile.startsWith('/') || sourceFile.match(/^[a-zA-Z]:/);
+    if (!isRelativeImport(sourceFile) && !isSourceAbsolute) {
+      return n.source.value === sourceFile;
+    }
+    if (!isRelativeImport(n.source.value)) {
+      return false;
+    }
+    const existingPath = resolveImportPath({
+      basedir,
+      importPath: n.source.value,
+      fs
+    });
+    return existingPath === sourceFile;
+  });
+}
+
+/**
+ * Find an existing export statement that exports from the same source file.
+ */
+function findExistingExportForSourceFile({
+  sourceFile,
+  allExports,
+  basedir,
+  fs
+}) {
+  return allExports.find(n => {
+    if (!n.source) {
+      return false;
+    }
+    const isSourceAbsolute = sourceFile.startsWith('/') || sourceFile.match(/^[a-zA-Z]:/);
+    if (!isRelativeImport(sourceFile) && !isSourceAbsolute) {
+      return n.source.value === sourceFile;
+    }
+    if (!isRelativeImport(n.source.value)) {
+      return false;
+    }
+    const existingPath = resolveImportPath({
+      basedir,
+      importPath: n.source.value,
+      fs
+    });
+    return existingPath === sourceFile;
+  });
+}
+
+/**
+ * Transform import specifiers to handle aliasing when the original name differs.
+ */
+function transformImportSpecifiers({
+  specsWithOriginal
+}) {
+  return specsWithOriginal.map(({
+    spec,
+    originalName,
+    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({
+  specsWithOriginal
+}) {
+  return specsWithOriginal.map(({
+    originalName,
+    nameInLocal,
+    kind
+  }) => ({
+    nameInSource: originalName || 'default',
+    nameInLocal,
+    kind
+  }));
+}
+export function createRule(fs) {
+  return {
+    meta: ruleMeta,
+    create(context) {
+      const checkNode = rawNode => {
+        const node = rawNode;
+
+        // Resolve barrel file context (handles early exits for non-barrel files)
+        const barrelContext = resolveBarrelFileContext({
+          node,
+          context,
+          fs
+        });
+        if (!barrelContext) {
+          return;
+        }
+        const {
+          importPath,
+          resolvedPath,
+          exportMap
+        } = barrelContext;
+
+        // Check if we have any imports from this barrel
+        const specifiers = node.specifiers;
+        if (specifiers.length === 0) {
+          return;
+        }
+
+        // Collect imports by source file
+        const {
+          importsBySource,
+          unmappedSpecifiers,
+          hasNamespaceImport
+        } = collectSpecifiersBySource({
+          specifiers,
+          node,
+          exportMap
+        });
+
+        // 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
+        const 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
+        const nodeSource = node.source;
+        if (unmappedSpecifiers.length === 0 && nodeSource) {
+          reportObj.fix = function (fixer) {
+            const sourceCode = context.getSourceCode();
+            const quote = sourceCode.getText(nodeSource)[0]; // Get quote character
+            const basedirForFix = dirname(context.filename);
+            const fixes = [];
+            const newStatementsForBarrelReplacement = [];
+
+            // Generate new import statements for each source file
+            const sourceFileArray = Array.from(importsBySource.entries());
+            for (let i = 0; i < sourceFileArray.length; i++) {
+              const [sourceFile, specsWithOriginal] = sourceFileArray[i];
+              if (node.type === 'ImportDeclaration') {
+                // Transform specifiers if needed (handle aliasing)
+                const specs = transformImportSpecifiers({
+                  specsWithOriginal
+                });
+
+                // Get all existing imports to check for merging
+                const allImports = sourceCode.ast.body.filter(n => n.type === 'ImportDeclaration' && n !== node);
+
+                // Check for existing import
+                const existingImport = findExistingImportForSourceFile({
+                  sourceFile,
+                  allImports,
+                  basedir: basedirForFix,
+                  fs
+                });
+
+                // 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) {
+                  var _specsWithOriginal$0$, _specsWithOriginal$;
+                  // Merge!
+                  const existingSpecs = existingImport.specifiers.map(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 {
+                        ...s,
+                        importKind: 'type'
+                      };
+                    }
+                    return s;
+                  });
+                  const newSpecs = specs.map(s => {
+                    if (node.importKind === 'type') {
+                      return {
+                        ...s,
+                        importKind: 'type'
+                      };
+                    }
+                    return s;
+                  });
+                  const mergedSpecs = [...existingSpecs, ...newSpecs];
+
+                  // Determine if we should use 'import type'
+                  const allType = mergedSpecs.every(s => s.importKind === 'type');
+                  const 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: findWorkspaceRoot({
+                      startPath: basedirForFix,
+                      fs: fs
+                    }),
+                    fs: fs
+                  });
+                  const 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
+                  const 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: findWorkspaceRoot({
+                      startPath: basedirForFix,
+                      fs: fs
+                    }),
+                    fs: fs
+                  });
+                  const isTypeImport = node.importKind === 'type';
+                  const importStatement = buildImportStatement({
+                    specs,
+                    path: relativePath,
+                    quoteChar: quote,
+                    isTypeImport
+                  });
+                  if (importStatement.length > 0) {
+                    newStatementsForBarrelReplacement.push(importStatement);
+                  }
+                }
+              } else if (node.type === 'ExportNamedDeclaration') {
+                // Handle ExportNamedDeclaration
+                const specs = transformExportSpecifiers({
+                  specsWithOriginal
+                });
+
+                // Get all existing exports to check for merging
+                const allExports = sourceCode.ast.body.filter(n => n.type === 'ExportNamedDeclaration' && n !== node && !!n.source);
+
+                // Check for existing export
+                const existingExport = findExistingExportForSourceFile({
+                  sourceFile,
+                  allExports,
+                  basedir: basedirForFix,
+                  fs
+                });
+                if (existingExport) {
+                  var _specsWithOriginal$0$3, _specsWithOriginal$3;
+                  // Merge!
+                  const existingSpecs = existingExport.specifiers.map(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
+                    const effectiveKind = existingExport.exportKind === 'type' || s.exportKind === 'type' ? 'type' : 'value';
+                    return {
+                      nameInSource: getExportedName(s.local),
+                      nameInLocal: getExportedName(s.exported),
+                      kind: effectiveKind
+                    };
+                  });
+                  const newSpecs = specs.map(s => {
+                    if (node.exportKind === 'type') {
+                      return {
+                        ...s,
+                        kind: 'type'
+                      };
+                    }
+                    return s;
+                  });
+                  const mergedSpecs = [...existingSpecs, ...newSpecs];
+
+                  // Determine if we should use 'export type'
+                  const allType = mergedSpecs.every(s => s.kind === 'type');
+                  const relativePath = 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: findWorkspaceRoot({
+                      startPath: basedirForFix,
+                      fs: fs
+                    }),
+                    fs: fs
+                  });
+                  const newExportStatement = buildExportStatement({
+                    specs: mergedSpecs,
+                    path: relativePath,
+                    quoteChar: quote,
+                    isTypeExport: allType
+                  });
+                  if (newExportStatement.length > 0) {
+                    fixes.push(fixer.replaceText(existingExport, newExportStatement));
+                  }
+                } else {
+                  var _specsWithOriginal$0$4, _specsWithOriginal$4;
+                  // Create new export
+                  const relativePath = 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: findWorkspaceRoot({
+                      startPath: basedirForFix,
+                      fs: fs
+                    }),
+                    fs: fs
+                  });
+                  const isTypeExport = node.exportKind === 'type';
+                  const exportStatement = buildExportStatement({
+                    specs,
+                    path: relativePath,
+                    quoteChar: quote,
+                    isTypeExport
+                  });
+                  if (exportStatement.length > 0) {
+                    newStatementsForBarrelReplacement.push(exportStatement);
+                  }
+                }
+              }
+            }
+            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
+      };
+    }
+  };
+}
+const rule = createRule(realFileSystem);
+export default rule;