@atlaskit/eslint-plugin-platform 2.7.2 → 2.8.0

package/dist/es2019/rules/import/shared/barrel-parsing.js

@@ -0,0 +1,433 @@
+import { dirname } from 'path';
+import * as ts from 'typescript';
+import { isRelativeImport, readFileContent, resolveImportPath } from './file-system';
+import { resolveCrossPackageImport } from './package-resolution';
+import { perfInc, perfTime } from './perf';
+/**
+ * Maximum depth to traverse when looking for source files in barrel exports.
+ * Can be adjusted based on project structure needs.
+ */
+const MAX_BARREL_DEPTH = 10;
+
+/**
+ * Get all named exports from a file.
+ * This extracts what names are exported from a file for star exports.
+ */
+export function getNamedExportsFromFile({
+  filePath,
+  fs
+}) {
+  const names = new Set();
+  const content = readFileContent({
+    filePath,
+    fs
+  });
+  if (!content) {
+    return names;
+  }
+  try {
+    const sourceFile = ts.createSourceFile(filePath, content, ts.ScriptTarget.Latest, true);
+    ts.forEachChild(sourceFile, node => {
+      if (ts.isExportDeclaration(node)) {
+        if (node.exportClause && ts.isNamedExports(node.exportClause)) {
+          node.exportClause.elements.forEach(e => names.add(e.name.text));
+        }
+      } else if (ts.isExportAssignment(node)) {
+        names.add('default');
+      } else if (ts.isVariableStatement(node)) {
+        if (node.modifiers && node.modifiers.some(m => m.kind === ts.SyntaxKind.ExportKeyword)) {
+          node.declarationList.declarations.forEach(d => {
+            if (ts.isIdentifier(d.name)) {
+              names.add(d.name.text);
+            }
+          });
+        }
+      } else if (ts.isFunctionDeclaration(node) || ts.isClassDeclaration(node) || ts.isInterfaceDeclaration(node) || ts.isTypeAliasDeclaration(node) || ts.isEnumDeclaration(node)) {
+        if (node.modifiers && node.modifiers.some(m => m.kind === ts.SyntaxKind.ExportKeyword)) {
+          if (node.name && ts.isIdentifier(node.name)) {
+            names.add(node.name.text);
+          }
+        }
+      }
+    });
+  } catch {
+    // Ignore parsing errors
+  }
+  return names;
+}
+
+/**
+ * Check if an export map represents a barrel file (has re-exports from other files)
+ */
+export function hasReExportsFromOtherFiles({
+  exportMap,
+  sourceFilePath
+}) {
+  return Array.from(exportMap.values()).some(info => info.path !== sourceFilePath);
+}
+
+/**
+ * Process a named export element with cross-package support and add it to the exports map
+ */
+function processNamedExportElementWithCrossPackage({
+  element,
+  resolvedSource,
+  nestedExports,
+  isStatementTypeOnly,
+  exports,
+  crossPackageSource
+}) {
+  const localName = element.name.text;
+  const propertyName = element.propertyName ? element.propertyName.text : localName;
+  const isElementTypeOnly = isStatementTypeOnly || element.isTypeOnly;
+  const isDefaultExport = propertyName === 'default';
+  // Track if this export is aliased (exported name differs from source name)
+  const isAliased = element.propertyName !== undefined && localName !== propertyName;
+  if (nestedExports) {
+    const deepSource = nestedExports.get(propertyName);
+    if (deepSource) {
+      var _deepSource$originalN;
+      exports.set(localName, {
+        path: deepSource.path,
+        isTypeOnly: isElementTypeOnly || deepSource.isTypeOnly,
+        isDefaultExport: deepSource.isDefaultExport,
+        // Use deep source's original name if available, otherwise use propertyName if aliased
+        originalName: (_deepSource$originalN = deepSource.originalName) !== null && _deepSource$originalN !== void 0 ? _deepSource$originalN : isAliased ? propertyName : undefined,
+        // Preserve existing crossPackageSource from nested exports, or use the one from this level
+        crossPackageSource: deepSource.crossPackageSource || crossPackageSource
+      });
+    } else {
+      exports.set(localName, {
+        path: resolvedSource,
+        isTypeOnly: isElementTypeOnly,
+        isDefaultExport,
+        originalName: isAliased ? propertyName : undefined,
+        crossPackageSource
+      });
+    }
+  } else {
+    exports.set(localName, {
+      path: resolvedSource,
+      isTypeOnly: isElementTypeOnly,
+      isDefaultExport,
+      originalName: isAliased ? propertyName : undefined,
+      crossPackageSource
+    });
+  }
+}
+
+/**
+ * Handle star exports with cross-package support (export * from '...')
+ */
+function processStarExportWithCrossPackage({
+  resolvedSource,
+  nestedExports,
+  exports,
+  fs,
+  crossPackageSource
+}) {
+  if (nestedExports) {
+    for (const [name, info] of nestedExports) {
+      if (name !== 'default') {
+        // Preserve existing crossPackageSource from nested exports, or use the one from this level
+        exports.set(name, {
+          ...info,
+          crossPackageSource: info.crossPackageSource || crossPackageSource
+        });
+      }
+    }
+  } else {
+    const nonBarrelExports = getNamedExportsFromFile({
+      filePath: resolvedSource,
+      fs
+    });
+    for (const name of nonBarrelExports) {
+      if (name !== 'default') {
+        exports.set(name, {
+          path: resolvedSource,
+          isTypeOnly: false,
+          crossPackageSource
+        });
+      }
+    }
+  }
+}
+
+/**
+ * Process export declarations that have module specifiers (export ... from '...')
+ */
+function processExportWithModuleSpecifier({
+  statement,
+  resolveModule,
+  depth,
+  exports,
+  fs,
+  workspaceRoot,
+  visitedPackages
+}) {
+  if (!statement.moduleSpecifier || !ts.isStringLiteral(statement.moduleSpecifier)) {
+    return;
+  }
+  const modulePath = statement.moduleSpecifier.text;
+
+  // Try relative resolution first (existing behavior)
+  let resolvedSource = resolveModule(modulePath);
+  let crossPackageSource;
+
+  // If not a relative import, try cross-package resolution
+  if (!resolvedSource && !isRelativeImport(modulePath) && workspaceRoot) {
+    const crossPackageInfo = resolveCrossPackageImport({
+      moduleSpecifier: modulePath,
+      workspaceRoot,
+      fs
+    });
+    if (crossPackageInfo) {
+      // Check for circular dependencies
+      if (visitedPackages !== null && visitedPackages !== void 0 && visitedPackages.has(crossPackageInfo.packageName)) {
+        return;
+      }
+      resolvedSource = crossPackageInfo.entryFilePath;
+      crossPackageSource = {
+        packageName: crossPackageInfo.packageName,
+        exportPath: crossPackageInfo.exportPath
+      };
+    }
+  }
+  if (!resolvedSource) {
+    return;
+  }
+  const isStatementTypeOnly = statement.isTypeOnly;
+
+  // For cross-package imports, track visited packages to prevent circular deps
+  const newVisitedPackages = visitedPackages ? new Set(visitedPackages) : new Set();
+  if (crossPackageSource) {
+    newVisitedPackages.add(crossPackageSource.packageName);
+  }
+
+  // Always trace through nested barrels and cross-package exports to find the ultimate source
+  const potentialNestedExports = parseBarrelExports({
+    barrelFilePath: resolvedSource,
+    depth: depth + 1,
+    fs,
+    workspaceRoot,
+    visitedPackages: newVisitedPackages
+  });
+  const nestedExports = hasReExportsFromOtherFiles({
+    exportMap: potentialNestedExports,
+    sourceFilePath: resolvedSource
+  }) ? potentialNestedExports : null;
+  if (statement.exportClause) {
+    if (ts.isNamedExports(statement.exportClause)) {
+      for (const element of statement.exportClause.elements) {
+        processNamedExportElementWithCrossPackage({
+          element,
+          resolvedSource,
+          nestedExports,
+          isStatementTypeOnly,
+          exports,
+          crossPackageSource
+        });
+      }
+    } else if (ts.isNamespaceExport(statement.exportClause)) {
+      const name = statement.exportClause.name.text;
+      exports.set(name, {
+        path: resolvedSource,
+        isTypeOnly: isStatementTypeOnly,
+        crossPackageSource
+      });
+    }
+  } else {
+    processStarExportWithCrossPackage({
+      resolvedSource,
+      nestedExports,
+      exports,
+      fs,
+      crossPackageSource
+    });
+  }
+}
+
+/**
+ * Process local export statements (no module specifier)
+ */
+function processLocalExportDeclaration({
+  statement,
+  barrelFilePath,
+  exports
+}) {
+  if (!statement.exportClause || !ts.isNamedExports(statement.exportClause)) {
+    return;
+  }
+  const isStatementTypeOnly = statement.isTypeOnly;
+  for (const element of statement.exportClause.elements) {
+    const isElementTypeOnly = isStatementTypeOnly || element.isTypeOnly;
+    exports.set(element.name.text, {
+      path: barrelFilePath,
+      isTypeOnly: isElementTypeOnly
+    });
+  }
+}
+
+/**
+ * Process various declaration statements with export modifiers
+ */
+function processExportedDeclaration({
+  statement,
+  barrelFilePath,
+  exports
+}) {
+  if (ts.isExportAssignment(statement)) {
+    exports.set('default', {
+      path: barrelFilePath,
+      isTypeOnly: false
+    });
+    return;
+  }
+  const hasExportModifier = 'modifiers' in statement && Array.isArray(statement.modifiers) && statement.modifiers.some(m => m.kind === ts.SyntaxKind.ExportKeyword);
+  if (!hasExportModifier) {
+    return;
+  }
+  if (ts.isVariableStatement(statement)) {
+    for (const decl of statement.declarationList.declarations) {
+      if (ts.isIdentifier(decl.name)) {
+        exports.set(decl.name.text, {
+          path: barrelFilePath,
+          isTypeOnly: false
+        });
+      }
+    }
+  } else if (ts.isFunctionDeclaration(statement) || ts.isClassDeclaration(statement)) {
+    if (statement.name && ts.isIdentifier(statement.name)) {
+      exports.set(statement.name.text, {
+        path: barrelFilePath,
+        isTypeOnly: false
+      });
+    }
+  } else if (ts.isInterfaceDeclaration(statement) || ts.isTypeAliasDeclaration(statement)) {
+    if (statement.name && ts.isIdentifier(statement.name)) {
+      exports.set(statement.name.text, {
+        path: barrelFilePath,
+        isTypeOnly: true
+      });
+    }
+  } else if (ts.isEnumDeclaration(statement)) {
+    if (statement.name && ts.isIdentifier(statement.name)) {
+      exports.set(statement.name.text, {
+        path: barrelFilePath,
+        isTypeOnly: false
+      });
+    }
+  }
+}
+
+/**
+ * Parse export statements from a file to find where each export comes from.
+ * Returns a map of export name -> ExportInfo.
+ *
+ * This function recursively traces through nested barrels and cross-package re-exports
+ * to find the ultimate source file for each export.
+ */
+export function parseBarrelExports({
+  barrelFilePath,
+  depth = 0,
+  fs,
+  workspaceRoot,
+  visitedPackages
+}) {
+  perfInc({
+    fs,
+    key: 'parseBarrelExports.calls'
+  });
+  return perfTime({
+    fs,
+    key: 'parseBarrelExports.totalMs',
+    fn: () => {
+      if (depth > MAX_BARREL_DEPTH) {
+        return new Map();
+      }
+      if (!fs.cache.barrelExportsByPath) {
+        fs.cache.barrelExportsByPath = new Map();
+      }
+      let currentMtimeMs = 0;
+      try {
+        var _fs$statSync$mtimeMs;
+        currentMtimeMs = (_fs$statSync$mtimeMs = fs.statSync(barrelFilePath).mtimeMs) !== null && _fs$statSync$mtimeMs !== void 0 ? _fs$statSync$mtimeMs : 0;
+      } catch {
+        currentMtimeMs = 0;
+      }
+      const cached = fs.cache.barrelExportsByPath.get(barrelFilePath);
+      if (cached && cached.mtimeMs === currentMtimeMs) {
+        perfInc({
+          fs,
+          key: 'parseBarrelExports.cacheHit'
+        });
+        return cached.exports;
+      }
+      perfInc({
+        fs,
+        key: 'parseBarrelExports.cacheMiss'
+      });
+      const exports = new Map();
+      const content = readFileContent({
+        filePath: barrelFilePath,
+        fs
+      });
+      if (!content) {
+        return exports;
+      }
+      let sourceFile;
+      try {
+        sourceFile = perfTime({
+          fs,
+          key: 'parseBarrelExports.tsCreateSourceFileMs',
+          fn: () => ts.createSourceFile(barrelFilePath, content, ts.ScriptTarget.Latest, true)
+        });
+      } catch {
+        return exports;
+      }
+      const barrelDir = dirname(barrelFilePath);
+      const resolveModule = moduleSpecifier => {
+        if (!isRelativeImport(moduleSpecifier)) {
+          return null;
+        }
+        return resolveImportPath({
+          basedir: barrelDir,
+          importPath: moduleSpecifier,
+          fs
+        });
+      };
+      for (const statement of sourceFile.statements) {
+        if (ts.isExportDeclaration(statement)) {
+          if (statement.moduleSpecifier) {
+            processExportWithModuleSpecifier({
+              statement,
+              resolveModule,
+              depth,
+              exports,
+              fs,
+              workspaceRoot,
+              visitedPackages
+            });
+          } else {
+            processLocalExportDeclaration({
+              statement,
+              barrelFilePath,
+              exports
+            });
+          }
+        } else {
+          processExportedDeclaration({
+            statement,
+            barrelFilePath,
+            exports
+          });
+        }
+      }
+      fs.cache.barrelExportsByPath.set(barrelFilePath, {
+        mtimeMs: currentMtimeMs,
+        exports
+      });
+      return exports;
+    }
+  });
+}

package/dist/es2019/rules/import/shared/file-system.js

@@ -0,0 +1,174 @@
+import { dirname, join, resolve } from 'path';
+/**
+ * The default folder paths that barrel import rules apply to.
+ * Only imports from packages within these folders will be checked.
+ * This can be overridden via lint rule options.
+ */
+export const DEFAULT_TARGET_FOLDERS = ['platform/packages/ai-mate', 'platform/packages/search'];
+
+/**
+ * Try to read file contents with error handling.
+ * Returns null if file cannot be read.
+ */
+export function readFileContent({
+  filePath,
+  fs
+}) {
+  if (!fs.cache.fileContentByPath) {
+    fs.cache.fileContentByPath = new Map();
+  }
+  try {
+    if (!fs.existsSync(filePath)) {
+      return null;
+    }
+    let currentMtimeMs = null;
+    try {
+      var _fs$statSync$mtimeMs;
+      currentMtimeMs = (_fs$statSync$mtimeMs = fs.statSync(filePath).mtimeMs) !== null && _fs$statSync$mtimeMs !== void 0 ? _fs$statSync$mtimeMs : null;
+    } catch {
+      // If stat fails, use null to force a re-read (don't use cached value)
+      currentMtimeMs = null;
+    }
+    const cached = fs.cache.fileContentByPath.get(filePath);
+    // Only use cache if we have a valid mtime and it matches
+    if (cached && currentMtimeMs !== null && cached.mtimeMs === currentMtimeMs) {
+      return cached.content;
+    }
+    const content = fs.readFileSync(filePath, 'utf-8');
+    fs.cache.fileContentByPath.set(filePath, {
+      mtimeMs: currentMtimeMs,
+      content
+    });
+    return content;
+  } catch {
+    // Silently fail if file cannot be read
+  }
+  return null;
+}
+
+/**
+ * Check if a path is a relative import (starts with ./ or ../)
+ */
+export function isRelativeImport(importPath) {
+  return importPath.startsWith('./') || importPath.startsWith('../');
+}
+
+/**
+ * Resolve the actual file path from an import path.
+ * Handles extension inference and index file resolution.
+ */
+export function resolveImportPath({
+  basedir,
+  importPath,
+  fs
+}) {
+  if (!fs.cache.resolvedImportPathByKey) {
+    fs.cache.resolvedImportPathByKey = new Map();
+  }
+  const cacheKey = `${basedir}::${importPath}`;
+  if (fs.cache.resolvedImportPathByKey.has(cacheKey)) {
+    var _fs$cache$resolvedImp;
+    return (_fs$cache$resolvedImp = fs.cache.resolvedImportPathByKey.get(cacheKey)) !== null && _fs$cache$resolvedImp !== void 0 ? _fs$cache$resolvedImp : null;
+  }
+  const possibleExtensions = ['.ts', '.tsx', '.js', '.jsx'];
+  const absolutePath = resolve(basedir, importPath);
+
+  // Check exact path first (for explicit extensions)
+  if (fs.existsSync(absolutePath)) {
+    try {
+      const stats = fs.statSync(absolutePath);
+      if (stats.isFile()) {
+        const resolvedPath = fs.realpathSync(absolutePath);
+        fs.cache.resolvedImportPathByKey.set(cacheKey, resolvedPath);
+        return resolvedPath;
+      }
+    } catch {
+      // Ignore errors
+    }
+  }
+
+  // Try with extensions
+  for (const ext of possibleExtensions) {
+    const pathWithExt = absolutePath + ext;
+    if (fs.existsSync(pathWithExt)) {
+      try {
+        const resolvedPath = fs.realpathSync(pathWithExt);
+        fs.cache.resolvedImportPathByKey.set(cacheKey, resolvedPath);
+        return resolvedPath;
+      } catch {
+        fs.cache.resolvedImportPathByKey.set(cacheKey, pathWithExt);
+        return pathWithExt;
+      }
+    }
+  }
+
+  // Try as directory with index
+  for (const ext of possibleExtensions) {
+    const indexPath = join(absolutePath, `index${ext}`);
+    if (fs.existsSync(indexPath)) {
+      try {
+        const resolvedPath = fs.realpathSync(indexPath);
+        fs.cache.resolvedImportPathByKey.set(cacheKey, resolvedPath);
+        return resolvedPath;
+      } catch {
+        fs.cache.resolvedImportPathByKey.set(cacheKey, indexPath);
+        return indexPath;
+      }
+    }
+  }
+  fs.cache.resolvedImportPathByKey.set(cacheKey, null);
+  return null;
+}
+
+/**
+ * Find the workspace root using git rev-parse --show-toplevel.
+ * The result is cached on fs.cache.gitRepoRoot to avoid repeated shell calls.
+ * Falls back to directory traversal if git command fails.
+ */
+export function findWorkspaceRoot({
+  startPath,
+  fs,
+  applyToImportsFrom = DEFAULT_TARGET_FOLDERS
+}) {
+  // Return cached value if available
+  if (fs.cache.gitRepoRoot) {
+    return fs.cache.gitRepoRoot;
+  }
+
+  // Try to get the git repository root
+  const gitRoot = fs.execSync('git rev-parse --show-toplevel', {
+    cwd: startPath
+  });
+  if (gitRoot) {
+    fs.cache.gitRepoRoot = gitRoot;
+    return gitRoot;
+  }
+
+  // Fallback: traverse up looking for workspace markers
+  let current = startPath;
+  const maxDepth = 20;
+  let depth = 0;
+  while (depth < maxDepth) {
+    // Check if we've found the platform folder (which contains the target folders)
+    if (applyToImportsFrom.some(folder => fs.existsSync(join(current, folder)))) {
+      fs.cache.gitRepoRoot = current;
+      return current;
+    }
+
+    // Check for root-level indicators
+    const hasRootPackageJson = fs.existsSync(join(current, 'package.json'));
+    const hasYarnLock = fs.existsSync(join(current, 'yarn.lock'));
+    if (hasRootPackageJson && hasYarnLock) {
+      fs.cache.gitRepoRoot = current;
+      return current;
+    }
+    const parent = dirname(current);
+    if (parent === current) {
+      // Reached filesystem root
+      return startPath;
+    }
+    current = parent;
+    depth++;
+  }
+  return startPath;
+}