@atlaskit/eslint-plugin-platform 2.7.2 → 2.9.0

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

@@ -0,0 +1,231 @@
+import _typeof from "@babel/runtime/helpers/typeof";
+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; }
+/**
+ * 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) {
+  var 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;
+  }
+  var 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;
+  }
+  var 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;
+  }
+  var 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(_ref) {
+  var ast = _ref.ast,
+    matchPath = _ref.matchPath;
+  var results = [];
+  var visited = new WeakSet();
+  var 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)) {
+      var path = extractImportPath(node);
+      if (path && matchPath(path)) {
+        results.push(node);
+      }
+    }
+    for (var key in node) {
+      if (skipKeys.has(key)) {
+        continue;
+      }
+      var value = node[key];
+      if (value && _typeof(value) === 'object') {
+        if (Array.isArray(value)) {
+          var _iterator = _createForOfIteratorHelper(value),
+            _step;
+          try {
+            for (_iterator.s(); !(_step = _iterator.n()).done;) {
+              var child = _step.value;
+              if (child && _typeof(child) === 'object' && 'type' in child) {
+                visit(child);
+              }
+            }
+          } catch (err) {
+            _iterator.e(err);
+          } finally {
+            _iterator.f();
+          }
+        } else if ('type' in value) {
+          visit(value);
+        }
+      }
+    }
+  }
+  visit(ast);
+  return results;
+}
+
+/**
+ * Find all jest.requireActual() calls in the AST whose import path matches a given target.
+ * Works identically to findJestRequireMockCalls but for requireActual.
+ */
+export function findJestRequireActualCalls(_ref2) {
+  var ast = _ref2.ast,
+    matchPath = _ref2.matchPath;
+  var results = [];
+  var visited = new WeakSet();
+  var skipKeys = new Set(['parent', 'loc', 'range', 'tokens', 'comments']);
+  function visit(node) {
+    if (visited.has(node)) {
+      return;
+    }
+    visited.add(node);
+    if (node.type === 'CallExpression' && isJestRequireActual(node)) {
+      var path = extractImportPath(node);
+      if (path && matchPath(path)) {
+        results.push(node);
+      }
+    }
+    for (var key in node) {
+      if (skipKeys.has(key)) {
+        continue;
+      }
+      var value = node[key];
+      if (value && _typeof(value) === 'object') {
+        if (Array.isArray(value)) {
+          var _iterator2 = _createForOfIteratorHelper(value),
+            _step2;
+          try {
+            for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+              var child = _step2.value;
+              if (child && _typeof(child) === 'object' && 'type' in child) {
+                visit(child);
+              }
+            }
+          } catch (err) {
+            _iterator2.e(err);
+          } finally {
+            _iterator2.f();
+          }
+        } 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(_ref3) {
+  var requireMockNode = _ref3.requireMockNode,
+    symbolToNewPath = _ref3.symbolToNewPath;
+  var parent = requireMockNode.parent;
+  if (parent) {
+    var _parent;
+    // Check for destructuring pattern: const { foo } = jest.requireMock('...')
+    var 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') {
+      var _iterator3 = _createForOfIteratorHelper(declarator.id.properties),
+        _step3;
+      try {
+        for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
+          var prop = _step3.value;
+          if (prop.type === 'Property' && prop.key.type === 'Identifier') {
+            var matchedPath = symbolToNewPath.get(prop.key.name);
+            if (matchedPath) {
+              return matchedPath;
+            }
+          }
+        }
+      } catch (err) {
+        _iterator3.e(err);
+      } finally {
+        _iterator3.f();
+      }
+    }
+
+    // Check for property access pattern: jest.requireMock('...').foo
+    if (parent.type === 'MemberExpression' && parent.property.type === 'Identifier') {
+      var _matchedPath = symbolToNewPath.get(parent.property.name);
+      if (_matchedPath) {
+        return _matchedPath;
+      }
+    }
+  }
+
+  // Fallback: if only one new path exists, use it
+  var 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/esm/rules/import/shared/package-registry.js

@@ -0,0 +1,256 @@
+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; }
+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.
+ */
+var PACKAGE_RESOLUTION_ROOTS = ['platform/packages'];
+
+/**
+ * Get yarn.lock modification time for cache invalidation.
+ * Returns 0 if yarn.lock doesn't exist.
+ */
+function getYarnLockMtime(_ref) {
+  var workspaceRoot = _ref.workspaceRoot,
+    fs = _ref.fs;
+  var yarnLockPath = join(workspaceRoot, 'yarn.lock');
+  try {
+    if (fs.existsSync(yarnLockPath)) {
+      var _stats$mtimeMs;
+      var stats = fs.statSync(yarnLockPath);
+      return (_stats$mtimeMs = stats.mtimeMs) !== null && _stats$mtimeMs !== void 0 ? _stats$mtimeMs : 0;
+    }
+  } catch (_unused) {
+    // 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(_ref2) {
+  var cache = _ref2.cache,
+    workspaceRoot = _ref2.workspaceRoot,
+    fs = _ref2.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
+  var currentMtime = getYarnLockMtime({
+    workspaceRoot: workspaceRoot,
+    fs: 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(_ref3) {
+  var packageJsonPath = _ref3.packageJsonPath,
+    fs = _ref3.fs;
+  try {
+    if (!fs.existsSync(packageJsonPath)) {
+      return null;
+    }
+    var content = fs.readFileSync(packageJsonPath, 'utf-8');
+    var pkg = JSON.parse(content);
+    if (pkg.name && typeof pkg.name === 'string') {
+      return pkg.name;
+    }
+  } catch (_unused2) {
+    // 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(_ref4) {
+  var dir = _ref4.dir,
+    cache = _ref4.cache,
+    fs = _ref4.fs,
+    _ref4$isTargetRoot = _ref4.isTargetRoot,
+    isTargetRoot = _ref4$isTargetRoot === void 0 ? false : _ref4$isTargetRoot,
+    nestedTargetRoots = _ref4.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
+    var packageJsonPath = join(dir, 'package.json');
+    var packageName = readPackageName({
+      packageJsonPath: packageJsonPath,
+      fs: 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
+    var entries = fs.readdirSync(dir, {
+      withFileTypes: true
+    });
+    var _iterator = _createForOfIteratorHelper(entries),
+      _step;
+    try {
+      for (_iterator.s(); !(_step = _iterator.n()).done;) {
+        var entry = _step.value;
+        // 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: cache,
+          fs: fs,
+          // Only certain directory levels are treated as "target roots"
+          isTargetRoot: nestedTargetRoots.has(dir),
+          nestedTargetRoots: nestedTargetRoots
+        });
+      }
+    } catch (err) {
+      _iterator.e(err);
+    } finally {
+      _iterator.f();
+    }
+  } catch (_unused3) {
+    // 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(_ref5) {
+  var workspaceRoot = _ref5.workspaceRoot,
+    fs = _ref5.fs;
+  // Check if cache is still valid
+  if (isCacheValid({
+    cache: fs.cache,
+    workspaceRoot: workspaceRoot,
+    fs: fs
+  })) {
+    return;
+  }
+  perfInc({
+    fs: fs,
+    key: 'packageRegistry.rebuild'
+  });
+  return perfTime({
+    fs: fs,
+    key: 'packageRegistry.rebuildMs',
+    fn: function fn() {
+      // Initialize fresh cache
+      fs.cache.packageNameToDir = new Map();
+      fs.cache.scannedDirectories = new Set();
+      fs.cache.yarnLockMtime = getYarnLockMtime({
+        workspaceRoot: workspaceRoot,
+        fs: 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
+      var _iterator2 = _createForOfIteratorHelper(PACKAGE_RESOLUTION_ROOTS),
+        _step2;
+      try {
+        for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+          var resolutionRoot = _step2.value;
+          var targetPath = join(workspaceRoot, resolutionRoot);
+          scanDirectoryForPackages({
+            dir: targetPath,
+            cache: fs.cache,
+            fs: fs,
+            isTargetRoot: true,
+            nestedTargetRoots: new Set([targetPath])
+          });
+        }
+      } catch (err) {
+        _iterator2.e(err);
+      } finally {
+        _iterator2.f();
+      }
+    }
+  });
+}
+
+/**
+ * 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(_ref6) {
+  var _fs$cache$packageName, _fs$cache$packageName2;
+  var packageName = _ref6.packageName,
+    workspaceRoot = _ref6.workspaceRoot,
+    fs = _ref6.fs;
+  // Ensure cache is populated
+  ensureCachePopulated({
+    workspaceRoot: workspaceRoot,
+    fs: 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(_ref7) {
+  var packageDir = _ref7.packageDir,
+    workspaceRoot = _ref7.workspaceRoot,
+    _ref7$applyToImportsF = _ref7.applyToImportsFrom,
+    applyToImportsFrom = _ref7$applyToImportsF === void 0 ? DEFAULT_TARGET_FOLDERS : _ref7$applyToImportsF;
+  return applyToImportsFrom.some(function (folder) {
+    var targetPath = join(workspaceRoot, folder);
+    return packageDir.startsWith(targetPath);
+  });
+}