@atlaskit/eslint-plugin-platform 2.7.1 → 2.8.0

package/dist/es2019/rules/import/shared/jest-utils.js

@@ -0,0 +1,159 @@
+/**
+ * Shared utilities for jest.mock-related lint rules.
+ *
+ * These helpers are used by both `no-barrel-entry-jest-mock` (cross-package)
+ * and `no-jest-mock-barrel-files` (relative imports).
+ */
+
+/**
+ * Check if a CallExpression node is a jest.mock() call
+ */
+export function isJestMockCall(node) {
+  const callee = node.callee;
+  if (callee.type === 'MemberExpression') {
+    return callee.object.type === 'Identifier' && callee.object.name === 'jest' && callee.property.type === 'Identifier' && callee.property.name === 'mock';
+  }
+  if (callee.type === 'Identifier') {
+    return callee.name === 'jest.mock';
+  }
+  return false;
+}
+
+/**
+ * Check if a node is a jest.requireActual() call
+ */
+export function isJestRequireActual(node) {
+  if (node.type !== 'CallExpression') {
+    return false;
+  }
+  const callee = node.callee;
+  if (callee.type === 'MemberExpression') {
+    return callee.object.type === 'Identifier' && callee.object.name === 'jest' && callee.property.type === 'Identifier' && callee.property.name === 'requireActual';
+  }
+  return false;
+}
+
+/**
+ * Check if a node is a jest.requireMock() call
+ */
+export function isJestRequireMock(node) {
+  if (node.type !== 'CallExpression') {
+    return false;
+  }
+  const callee = node.callee;
+  if (callee.type === 'MemberExpression') {
+    return callee.object.type === 'Identifier' && callee.object.name === 'jest' && callee.property.type === 'Identifier' && callee.property.name === 'requireMock';
+  }
+  return false;
+}
+
+/**
+ * Extract the import path string from a jest.mock/jest.requireMock/jest.requireActual call's arguments.
+ * Returns null if the path cannot be statically determined.
+ */
+export function extractImportPath(node) {
+  if (node.arguments.length === 0) {
+    return null;
+  }
+  const firstArg = node.arguments[0];
+  if (firstArg.type === 'Literal') {
+    return String(firstArg.value);
+  }
+  if (firstArg.type === 'TemplateLiteral' && firstArg.expressions.length === 0) {
+    return firstArg.quasis[0].value.raw;
+  }
+  return null;
+}
+
+/**
+ * Find all jest.requireMock() calls in the AST whose import path matches a given target.
+ *
+ * The `matchPath` callback allows callers to provide their own path-matching strategy:
+ * - Cross-package rules can use simple string equality
+ * - Relative import rules can use normalized/resolved path comparison
+ */
+export function findJestRequireMockCalls({
+  ast,
+  matchPath
+}) {
+  const results = [];
+  const visited = new WeakSet();
+  const skipKeys = new Set(['parent', 'loc', 'range', 'tokens', 'comments']);
+  function visit(node) {
+    if (visited.has(node)) {
+      return;
+    }
+    visited.add(node);
+    if (node.type === 'CallExpression' && isJestRequireMock(node)) {
+      const path = extractImportPath(node);
+      if (path && matchPath(path)) {
+        results.push(node);
+      }
+    }
+    for (const key in node) {
+      if (skipKeys.has(key)) {
+        continue;
+      }
+      const value = node[key];
+      if (value && typeof value === 'object') {
+        if (Array.isArray(value)) {
+          for (const child of value) {
+            if (child && typeof child === 'object' && 'type' in child) {
+              visit(child);
+            }
+          }
+        } else if ('type' in value) {
+          visit(value);
+        }
+      }
+    }
+  }
+  visit(ast);
+  return results;
+}
+
+/**
+ * Determine the best new import path for a jest.requireMock() call by inspecting
+ * the destructured symbols or property access at the call site.
+ *
+ * @param requireMockNode - The jest.requireMock() CallExpression node
+ * @param symbolToNewPath - Map from symbol name to the new mock path that provides it
+ * @returns The resolved new path, or null if it cannot be determined
+ */
+export function resolveNewPathForRequireMock({
+  requireMockNode,
+  symbolToNewPath
+}) {
+  const parent = requireMockNode.parent;
+  if (parent) {
+    var _parent;
+    // Check for destructuring pattern: const { foo } = jest.requireMock('...')
+    const declarator = parent.type === 'VariableDeclarator' ? parent : ((_parent = parent.parent) === null || _parent === void 0 ? void 0 : _parent.type) === 'VariableDeclarator' ? parent.parent : null;
+    if (declarator && declarator.type === 'VariableDeclarator' && declarator.id.type === 'ObjectPattern') {
+      for (const prop of declarator.id.properties) {
+        if (prop.type === 'Property' && prop.key.type === 'Identifier') {
+          const matchedPath = symbolToNewPath.get(prop.key.name);
+          if (matchedPath) {
+            return matchedPath;
+          }
+        }
+      }
+    }
+
+    // Check for property access pattern: jest.requireMock('...').foo
+    if (parent.type === 'MemberExpression' && parent.property.type === 'Identifier') {
+      const matchedPath = symbolToNewPath.get(parent.property.name);
+      if (matchedPath) {
+        return matchedPath;
+      }
+    }
+  }
+
+  // Fallback: if only one new path exists, use it
+  const uniquePaths = new Set(symbolToNewPath.values());
+  if (uniquePaths.size === 1) {
+    var _uniquePaths$values$n;
+    return (_uniquePaths$values$n = uniquePaths.values().next().value) !== null && _uniquePaths$values$n !== void 0 ? _uniquePaths$values$n : null;
+  }
+  return null;
+}

package/dist/es2019/rules/import/shared/package-registry.js

@@ -0,0 +1,240 @@
+import { join } from 'path';
+import { DEFAULT_TARGET_FOLDERS } from './file-system';
+import { perfInc, perfTime } from './perf';
+/**
+ * The folder paths used for package resolution.
+ * All packages under these folders can be resolved regardless of applyToImportsFrom.
+ * applyToImportsFrom is only used to filter which packages the lint rules apply to.
+ */
+const PACKAGE_RESOLUTION_ROOTS = ['platform/packages'];
+
+/**
+ * Get yarn.lock modification time for cache invalidation.
+ * Returns 0 if yarn.lock doesn't exist.
+ */
+function getYarnLockMtime({
+  workspaceRoot,
+  fs
+}) {
+  const yarnLockPath = join(workspaceRoot, 'yarn.lock');
+  try {
+    if (fs.existsSync(yarnLockPath)) {
+      var _stats$mtimeMs;
+      const stats = fs.statSync(yarnLockPath);
+      return (_stats$mtimeMs = stats.mtimeMs) !== null && _stats$mtimeMs !== void 0 ? _stats$mtimeMs : 0;
+    }
+  } catch {
+    // Ignore errors
+  }
+  return 0;
+}
+
+/**
+ * Check if the cache is valid for the given workspace root.
+ * Cache is invalid if:
+ * - The cache is not fully initialized
+ * - The workspace root has changed
+ * - The yarn.lock file has been modified
+ */
+function isCacheValid({
+  cache,
+  workspaceRoot,
+  fs
+}) {
+  // Cache is invalid if not initialized
+  if (!cache.packageNameToDir || !cache.scannedDirectories) {
+    return false;
+  }
+
+  // Cache is invalid if workspace root changed
+  if (cache.workspaceRoot !== workspaceRoot) {
+    return false;
+  }
+
+  // Cache is invalid if yarn.lock mtime changed
+  const currentMtime = getYarnLockMtime({
+    workspaceRoot,
+    fs
+  });
+  return currentMtime === cache.yarnLockMtime;
+}
+
+/**
+ * Read package name from a package.json file.
+ * Returns null if the file doesn't exist or doesn't have a valid name.
+ */
+function readPackageName({
+  packageJsonPath,
+  fs
+}) {
+  try {
+    if (!fs.existsSync(packageJsonPath)) {
+      return null;
+    }
+    const content = fs.readFileSync(packageJsonPath, 'utf-8');
+    const pkg = JSON.parse(content);
+    if (pkg.name && typeof pkg.name === 'string') {
+      return pkg.name;
+    }
+  } catch {
+    // Ignore errors (invalid JSON, etc.)
+  }
+  return null;
+}
+
+/**
+ * Recursively scan a directory for packages and update the cache.
+ * Directories are cached (including those without packages) to avoid re-scanning.
+ *
+ * Once a package.json is found, subdirectories are not scanned since packages
+ * don't contain nested packages. The exception is target folder roots (e.g., 'platform')
+ * which may have a package.json but still contain packages in subdirectories.
+ */
+function scanDirectoryForPackages({
+  dir,
+  cache,
+  fs,
+  isTargetRoot = false,
+  nestedTargetRoots
+}) {
+  // Skip if already scanned
+  if (cache.scannedDirectories.has(dir)) {
+    return;
+  }
+
+  // Mark as scanned (even if it doesn't contain a package)
+  cache.scannedDirectories.add(dir);
+  try {
+    // Check for package.json in current directory
+    const packageJsonPath = join(dir, 'package.json');
+    const packageName = readPackageName({
+      packageJsonPath,
+      fs
+    });
+    if (packageName) {
+      cache.packageNameToDir.set(packageName, dir);
+      // Don't scan subdirectories - packages don't contain nested packages
+      // Exception: target folder roots (e.g., 'platform') may have packages in subdirectories
+      if (!isTargetRoot) {
+        return;
+      }
+    }
+
+    // Recursively scan subdirectories
+    const entries = fs.readdirSync(dir, {
+      withFileTypes: true
+    });
+    for (const entry of entries) {
+      // Skip node_modules, hidden directories, and non-directories
+      if (!entry.isDirectory() || entry.name === 'node_modules' || entry.name.startsWith('.')) {
+        continue;
+      }
+      scanDirectoryForPackages({
+        dir: join(dir, entry.name),
+        cache,
+        fs,
+        // Only certain directory levels are treated as "target roots"
+        isTargetRoot: nestedTargetRoots.has(dir),
+        nestedTargetRoots
+      });
+    }
+  } catch {
+    // Directory doesn't exist or not readable, skip
+  }
+}
+
+/**
+ * Ensure all packages under platform/packages have been scanned.
+ * Initializes or updates the cache on fs.cache as needed.
+ * Package resolution is not constrained by applyToImportsFrom - any package can be resolved.
+ */
+function ensureCachePopulated({
+  workspaceRoot,
+  fs
+}) {
+  // Check if cache is still valid
+  if (isCacheValid({
+    cache: fs.cache,
+    workspaceRoot,
+    fs
+  })) {
+    return;
+  }
+  perfInc({
+    fs,
+    key: 'packageRegistry.rebuild'
+  });
+  return perfTime({
+    fs,
+    key: 'packageRegistry.rebuildMs',
+    fn: () => {
+      // Initialize fresh cache
+      fs.cache.packageNameToDir = new Map();
+      fs.cache.scannedDirectories = new Set();
+      fs.cache.yarnLockMtime = getYarnLockMtime({
+        workspaceRoot,
+        fs
+      });
+      fs.cache.workspaceRoot = workspaceRoot;
+      // When the workspace graph changes, clear derived caches as well
+      fs.cache.packageExportsByDir = new Map();
+
+      // Scan all packages under the resolution roots
+      // This is not constrained by applyToImportsFrom - any package can be resolved
+      // The immediate children of each root (e.g., ai-mate, search) are treated as
+      // "nested target roots" - they may have a package.json but still contain nested packages
+      for (const resolutionRoot of PACKAGE_RESOLUTION_ROOTS) {
+        const targetPath = join(workspaceRoot, resolutionRoot);
+        scanDirectoryForPackages({
+          dir: targetPath,
+          cache: fs.cache,
+          fs,
+          isTargetRoot: true,
+          nestedTargetRoots: new Set([targetPath])
+        });
+      }
+    }
+  });
+}
+
+/**
+ * Find the package directory for a given package name.
+ * Returns the absolute path to the package directory or null if not found.
+ *
+ * This function uses lazy scanning - it will scan platform/packages on first lookup
+ * and cache results in fs.cache for subsequent lookups.
+ *
+ * Note: Package resolution is NOT constrained by applyToImportsFrom. Any package under
+ * platform/packages can be resolved. Use isPackageInApplyToImportsFrom to check if a
+ * package should be processed by the lint rule.
+ */
+export function findPackageInRegistry({
+  packageName,
+  workspaceRoot,
+  fs
+}) {
+  var _fs$cache$packageName, _fs$cache$packageName2;
+  // Ensure cache is populated
+  ensureCachePopulated({
+    workspaceRoot,
+    fs
+  });
+
+  // Look up the package
+  return (_fs$cache$packageName = (_fs$cache$packageName2 = fs.cache.packageNameToDir) === null || _fs$cache$packageName2 === void 0 ? void 0 : _fs$cache$packageName2.get(packageName)) !== null && _fs$cache$packageName !== void 0 ? _fs$cache$packageName : null;
+}
+
+/**
+ * Check if a package is within one of the applyToImportsFrom folders.
+ * This can be used to quickly filter out packages that shouldn't be checked.
+ */
+export function isPackageInApplyToImportsFrom({
+  packageDir,
+  workspaceRoot,
+  applyToImportsFrom = DEFAULT_TARGET_FOLDERS
+}) {
+  return applyToImportsFrom.some(folder => {
+    const targetPath = join(workspaceRoot, folder);
+    return packageDir.startsWith(targetPath);
+  });
+}

package/dist/es2019/rules/import/shared/package-resolution.js

@@ -0,0 +1,161 @@
+import { join } from 'path';
+import { readFileContent, resolveImportPath } from './file-system';
+import { findPackageInRegistry } from './package-registry';
+/**
+ * Parse the package.json exports field and return a map of export paths to resolved file paths.
+ */
+export function parsePackageExports({
+  packageDir,
+  fs
+}) {
+  // Memoize per-package to avoid repeated reads/parses during IDE lint runs.
+  // Additionally, invalidate per-package if the package.json mtime changes
+  // (covers unstaged local edits in IDE).
+  if (!fs.cache.packageExportsByDir) {
+    fs.cache.packageExportsByDir = new Map();
+  }
+  const packageJsonPath = join(packageDir, 'package.json');
+  let currentMtimeMs = null;
+  try {
+    var _fs$statSync$mtimeMs;
+    currentMtimeMs = (_fs$statSync$mtimeMs = fs.statSync(packageJsonPath).mtimeMs) !== null && _fs$statSync$mtimeMs !== void 0 ? _fs$statSync$mtimeMs : null;
+  } catch {
+    // If package.json can't be stat'ed (missing/inaccessible), use null to force re-read
+    currentMtimeMs = null;
+  }
+  const cached = fs.cache.packageExportsByDir.get(packageDir);
+  // Only use cache if we have a valid mtime and it matches
+  if (cached && currentMtimeMs !== null && cached.packageJsonMtimeMs === currentMtimeMs) {
+    return cached.exportsMap;
+  }
+  const exportsMap = new Map();
+  try {
+    const content = readFileContent({
+      filePath: packageJsonPath,
+      fs
+    });
+    if (!content) {
+      return exportsMap;
+    }
+    const packageJson = JSON.parse(content);
+    const exports = packageJson.exports;
+    if (!exports || typeof exports !== 'object') {
+      return exportsMap;
+    }
+    for (const [exportPath, exportValue] of Object.entries(exports)) {
+      // Handle both simple string values and conditional exports objects
+      let resolvedPath = null;
+      if (typeof exportValue === 'string') {
+        resolvedPath = exportValue;
+      } else if (typeof exportValue === 'object' && exportValue !== null) {
+        // Handle conditional exports like { "import": "./...", "require": "./..." }
+        // Prefer "import" or "default" or first available
+        const condExports = exportValue;
+        resolvedPath = condExports['import'] || condExports['default'] || Object.values(condExports)[0];
+      }
+      if (resolvedPath && typeof resolvedPath === 'string') {
+        // Resolve the path relative to the package directory
+        const absolutePath = resolveImportPath({
+          basedir: packageDir,
+          importPath: resolvedPath,
+          fs
+        });
+        if (absolutePath) {
+          exportsMap.set(exportPath, absolutePath);
+        }
+      }
+    }
+  } catch {
+    // Ignore parsing errors
+  }
+
+  // Cache even empty maps to avoid re-reading invalid/missing exports repeatedly.
+  fs.cache.packageExportsByDir.set(packageDir, {
+    packageJsonMtimeMs: currentMtimeMs,
+    exportsMap
+  });
+  return exportsMap;
+}
+
+/**
+ * Find a matching export entry for a given source file path.
+ * Returns the export path (e.g., "./controllers/analytics") or null if not found.
+ */
+export function findExportForSourceFile({
+  sourceFilePath,
+  exportsMap
+}) {
+  for (const [exportPath, resolvedPath] of exportsMap) {
+    if (resolvedPath === sourceFilePath) {
+      return exportPath;
+    }
+  }
+  return null;
+}
+
+/**
+ * Extract the package name and subpath from an import specifier.
+ * Returns null if the import is not a scoped package import.
+ */
+export function extractPackageNameFromImport(moduleSpecifier) {
+  const match = moduleSpecifier.match(/^(@[^/]+\/[^/]+)(\/.*)?$/);
+  if (!match) {
+    return null;
+  }
+  return {
+    packageName: match[1],
+    subPath: match[2] || ''
+  };
+}
+
+/**
+ * Resolve a cross-package import to its package directory and export info.
+ * Returns null if the package is not in the target folder or cannot be resolved.
+ */
+export function resolveCrossPackageImport({
+  moduleSpecifier,
+  workspaceRoot,
+  fs
+}) {
+  // Only handle @atlassian/* scoped packages
+  const parsed = extractPackageNameFromImport(moduleSpecifier);
+  if (!parsed) {
+    return null;
+  }
+  const {
+    packageName,
+    subPath
+  } = parsed;
+
+  // Check if package is in target folder
+  const packageDir = findPackageInRegistry({
+    packageName,
+    workspaceRoot,
+    fs
+  });
+  if (!packageDir) {
+    return null;
+  }
+
+  // Parse package.json exports
+  const exportsMap = parsePackageExports({
+    packageDir,
+    fs
+  });
+  if (exportsMap.size === 0) {
+    return null;
+  }
+
+  // Determine the export path (e.g., '.' or './utils')
+  const exportPath = subPath ? '.' + subPath : '.';
+  const entryFilePath = exportsMap.get(exportPath);
+  if (!entryFilePath) {
+    return null;
+  }
+  return {
+    packageName,
+    packageDir,
+    exportPath,
+    entryFilePath
+  };
+}

package/dist/es2019/rules/import/shared/perf.js

@@ -0,0 +1,83 @@
+export const PERF_ENV_VAR = 'INTERNAL_ESLINT_BARREL_PERF';
+function nowMs() {
+  // eslint-disable-next-line no-restricted-globals
+  return typeof performance !== 'undefined' && performance.now ? performance.now() : Date.now();
+}
+export function isPerfEnabled() {
+  return process.env[PERF_ENV_VAR] === '1' || process.env[PERF_ENV_VAR] === 'true';
+}
+function ensurePerfInitialized({
+  fs
+}) {
+  if (!fs.cache.perf) {
+    fs.cache.perf = {
+      installedExitHook: false,
+      counters: {},
+      timers: {}
+    };
+  }
+}
+function ensureExitHookInstalled({
+  fs
+}) {
+  if (!isPerfEnabled()) {
+    return;
+  }
+  ensurePerfInitialized({
+    fs
+  });
+  if (fs.cache.perf.installedExitHook) {
+    return;
+  }
+  fs.cache.perf.installedExitHook = true;
+  // eslint-disable-next-line no-console
+  console.error(`[eslint-plugin-internal] perf enabled via ${PERF_ENV_VAR}`);
+  process.once('exit', () => {
+    var _fs$cache$perf$counte, _fs$cache$perf, _fs$cache$perf$timers, _fs$cache$perf2;
+    // eslint-disable-next-line no-console
+    console.error(`[eslint-plugin-internal] perf exit hook fired (${PERF_ENV_VAR})`);
+    // eslint-disable-next-line no-console
+    console.log(`[eslint-plugin-internal] perf summary (${PERF_ENV_VAR})`);
+    // eslint-disable-next-line no-console
+    console.log(JSON.stringify({
+      counters: (_fs$cache$perf$counte = (_fs$cache$perf = fs.cache.perf) === null || _fs$cache$perf === void 0 ? void 0 : _fs$cache$perf.counters) !== null && _fs$cache$perf$counte !== void 0 ? _fs$cache$perf$counte : {},
+      timers: (_fs$cache$perf$timers = (_fs$cache$perf2 = fs.cache.perf) === null || _fs$cache$perf2 === void 0 ? void 0 : _fs$cache$perf2.timers) !== null && _fs$cache$perf$timers !== void 0 ? _fs$cache$perf$timers : {}
+    }, null, 2));
+  });
+}
+export function perfInc({
+  fs,
+  key,
+  by = 1
+}) {
+  var _perf$counters$key;
+  if (!isPerfEnabled()) {
+    return;
+  }
+  ensureExitHookInstalled({
+    fs
+  });
+  const perf = fs.cache.perf;
+  perf.counters[key] = ((_perf$counters$key = perf.counters[key]) !== null && _perf$counters$key !== void 0 ? _perf$counters$key : 0) + by;
+}
+export function perfTime({
+  fs,
+  key,
+  fn
+}) {
+  if (!isPerfEnabled()) {
+    return fn();
+  }
+  ensureExitHookInstalled({
+    fs
+  });
+  const perf = fs.cache.perf;
+  const start = nowMs();
+  try {
+    return fn();
+  } finally {
+    var _perf$timers$key;
+    const duration = nowMs() - start;
+    perf.timers[key] = ((_perf$timers$key = perf.timers[key]) !== null && _perf$timers$key !== void 0 ? _perf$timers$key : 0) + duration;
+  }
+}

package/dist/es2019/rules/import/shared/types.js

@@ -0,0 +1,57 @@
+import { execSync } from 'child_process';
+import { existsSync, readdirSync, readFileSync, realpathSync, statSync } from 'fs';
+
+/**
+ * Directory entry returned by readdirSync with withFileTypes option.
+ */
+
+/**
+ * State for the package registry cache.
+ * This is used to cache package name to directory mappings for efficient lookups.
+ */
+
+/**
+ * Cache structure for file system operations.
+ * Contains both package registry cache and workspace root cache.
+ */
+
+/**
+ * File system abstraction for testability.
+ * This interface allows the core logic to be tested with mock file systems.
+ * The cache property holds package resolution state and can be passed as an empty
+ * object for tests to ensure fresh state for each test case.
+ */
+
+/**
+ * Real file system implementation using Node.js fs module.
+ */
+export const realFileSystem = {
+  existsSync,
+  readFileSync,
+  realpathSync,
+  statSync,
+  readdirSync: (path, options) => readdirSync(path, options),
+  execSync: (command, options) => {
+    try {
+      return execSync(command, {
+        ...options,
+        encoding: 'utf-8'
+      }).trim();
+    } catch {
+      return null;
+    }
+  },
+  cache: {}
+};
+
+/**
+ * Information about cross-package re-export origin.
+ */
+
+/**
+ * Information about where an export originates.
+ */
+
+/**
+ * Context for package resolution operations.
+ */

package/dist/es2019/rules/no-invalid-storybook-decorator-usage/index.js

@@ -1,6 +1,6 @@
 // eslint-disable-next-line import/no-extraneous-dependencies
 
-const STORYBOOK_DECORATOR_IDENTIFIER = 'withPlatformFeatureFlags';
+const STORYBOOK_DECORATOR_IDENTIFIER = 'withPlatformFeatureGates';
 const rule = {
   meta: {
     hasSuggestions: false,