@atlaskit/eslint-plugin-platform 2.7.2 → 2.9.0

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

@@ -0,0 +1,306 @@
+import _slicedToArray from "@babel/runtime/helpers/slicedToArray";
+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; }
+import { dirname, join } from 'path';
+import * as ts from 'typescript';
+import { isRelativeImport, readFileContent, resolveImportPath } from './file-system';
+import { findPackageInRegistry } from './package-registry';
+var ENTRY_POINT_FOLDER_NAMES = new Set(['entry-points', 'entrypoints', 'entrypoint', 'entry-point']);
+function isInEntryPointsFolder(filePath) {
+  var parts = filePath.split(/[/\\]/);
+  return parts.some(function (part) {
+    return ENTRY_POINT_FOLDER_NAMES.has(part);
+  });
+}
+/**
+ * Parse an entry-point wrapper file and resolve the source files it re-exports from,
+ * along with name mappings (source export name → entry-point export name).
+ */
+function resolveEntryPointReExports(_ref) {
+  var entryPointFilePath = _ref.entryPointFilePath,
+    fs = _ref.fs;
+  var content = readFileContent({
+    filePath: entryPointFilePath,
+    fs: fs
+  });
+  if (!content) {
+    return [];
+  }
+  try {
+    var sourceFile = ts.createSourceFile(entryPointFilePath, content, ts.ScriptTarget.Latest, true);
+    var basedir = dirname(entryPointFilePath);
+    var results = [];
+    var _iterator = _createForOfIteratorHelper(sourceFile.statements),
+      _step;
+    try {
+      for (_iterator.s(); !(_step = _iterator.n()).done;) {
+        var statement = _step.value;
+        if (ts.isExportDeclaration(statement) && statement.moduleSpecifier && ts.isStringLiteral(statement.moduleSpecifier)) {
+          var modulePath = statement.moduleSpecifier.text;
+          if (!isRelativeImport(modulePath)) {
+            continue;
+          }
+          var resolved = resolveImportPath({
+            basedir: basedir,
+            importPath: modulePath,
+            fs: fs
+          });
+          if (!resolved) {
+            continue;
+          }
+          var nameMap = new Map();
+          if (statement.exportClause && ts.isNamedExports(statement.exportClause)) {
+            var _iterator2 = _createForOfIteratorHelper(statement.exportClause.elements),
+              _step2;
+            try {
+              for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+                var element = _step2.value;
+                var exportedName = element.name.text;
+                var sourceName = element.propertyName ? element.propertyName.text : exportedName;
+                nameMap.set(sourceName, exportedName);
+              }
+            } catch (err) {
+              _iterator2.e(err);
+            } finally {
+              _iterator2.f();
+            }
+          }
+          results.push({
+            sourcePath: resolved,
+            nameMap: nameMap
+          });
+        }
+      }
+    } catch (err) {
+      _iterator.e(err);
+    } finally {
+      _iterator.f();
+    }
+    return results;
+  } catch (_unused) {
+    return [];
+  }
+}
+
+/**
+ * Parse the package.json exports field and return a map of export paths to resolved file paths.
+ */
+export function parsePackageExports(_ref2) {
+  var packageDir = _ref2.packageDir,
+    fs = _ref2.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();
+  }
+  var packageJsonPath = join(packageDir, 'package.json');
+  var 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 (_unused2) {
+    // If package.json can't be stat'ed (missing/inaccessible), use null to force re-read
+    currentMtimeMs = null;
+  }
+  var 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;
+  }
+  var exportsMap = new Map();
+  try {
+    var content = readFileContent({
+      filePath: packageJsonPath,
+      fs: fs
+    });
+    if (!content) {
+      return exportsMap;
+    }
+    var packageJson = JSON.parse(content);
+    var exports = packageJson.exports;
+    if (!exports || _typeof(exports) !== 'object') {
+      return exportsMap;
+    }
+    for (var _i = 0, _Object$entries = Object.entries(exports); _i < _Object$entries.length; _i++) {
+      var _Object$entries$_i = _slicedToArray(_Object$entries[_i], 2),
+        exportPath = _Object$entries$_i[0],
+        exportValue = _Object$entries$_i[1];
+      // Handle both simple string values and conditional exports objects
+      var 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
+        var condExports = exportValue;
+        resolvedPath = condExports['import'] || condExports['default'] || Object.values(condExports)[0];
+      }
+      if (resolvedPath && typeof resolvedPath === 'string') {
+        // Resolve the path relative to the package directory
+        var absolutePath = resolveImportPath({
+          basedir: packageDir,
+          importPath: resolvedPath,
+          fs: fs
+        });
+        if (absolutePath) {
+          exportsMap.set(exportPath, absolutePath);
+        }
+      }
+    }
+  } catch (_unused3) {
+    // Ignore parsing errors
+  }
+
+  // Cache even empty maps to avoid re-reading invalid/missing exports repeatedly.
+  fs.cache.packageExportsByDir.set(packageDir, {
+    packageJsonMtimeMs: currentMtimeMs,
+    exportsMap: 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.
+ *
+ * When `fs` is provided, also checks entry-point wrapper files. If an export resolves
+ * to a file inside a recognized entry-points folder (entry-points, entrypoints, etc.),
+ * the wrapper is parsed to see if it re-exports from `sourceFilePath`.
+ *
+ * `sourceExportName` is the name under which the symbol is exported from the source file
+ * (e.g. `'default'`). Used to look up the corresponding entry-point export name so the
+ * caller can generate the correct import style.
+ */
+export function findExportForSourceFile(_ref3) {
+  var sourceFilePath = _ref3.sourceFilePath,
+    exportsMap = _ref3.exportsMap,
+    fs = _ref3.fs,
+    sourceExportName = _ref3.sourceExportName;
+  var _iterator3 = _createForOfIteratorHelper(exportsMap),
+    _step3;
+  try {
+    for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
+      var _step3$value = _slicedToArray(_step3.value, 2),
+        _exportPath = _step3$value[0],
+        _resolvedPath = _step3$value[1];
+      if (_resolvedPath === sourceFilePath) {
+        return {
+          exportPath: _exportPath
+        };
+      }
+    }
+  } catch (err) {
+    _iterator3.e(err);
+  } finally {
+    _iterator3.f();
+  }
+  if (fs) {
+    var _iterator4 = _createForOfIteratorHelper(exportsMap),
+      _step4;
+    try {
+      for (_iterator4.s(); !(_step4 = _iterator4.n()).done;) {
+        var _step4$value = _slicedToArray(_step4.value, 2),
+          exportPath = _step4$value[0],
+          resolvedPath = _step4$value[1];
+        if (isInEntryPointsFolder(resolvedPath)) {
+          var reExports = resolveEntryPointReExports({
+            entryPointFilePath: resolvedPath,
+            fs: fs
+          });
+          var _iterator5 = _createForOfIteratorHelper(reExports),
+            _step5;
+          try {
+            for (_iterator5.s(); !(_step5 = _iterator5.n()).done;) {
+              var reExport = _step5.value;
+              if (reExport.sourcePath === sourceFilePath) {
+                var entryPointExportName = void 0;
+                if (sourceExportName !== undefined && reExport.nameMap.has(sourceExportName)) {
+                  entryPointExportName = reExport.nameMap.get(sourceExportName);
+                }
+                return {
+                  exportPath: exportPath,
+                  entryPointExportName: entryPointExportName
+                };
+              }
+            }
+          } catch (err) {
+            _iterator5.e(err);
+          } finally {
+            _iterator5.f();
+          }
+        }
+      }
+    } catch (err) {
+      _iterator4.e(err);
+    } finally {
+      _iterator4.f();
+    }
+  }
+  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) {
+  var 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(_ref4) {
+  var moduleSpecifier = _ref4.moduleSpecifier,
+    workspaceRoot = _ref4.workspaceRoot,
+    fs = _ref4.fs;
+  // Only handle @atlassian/* scoped packages
+  var parsed = extractPackageNameFromImport(moduleSpecifier);
+  if (!parsed) {
+    return null;
+  }
+  var packageName = parsed.packageName,
+    subPath = parsed.subPath;
+
+  // Check if package is in target folder
+  var packageDir = findPackageInRegistry({
+    packageName: packageName,
+    workspaceRoot: workspaceRoot,
+    fs: fs
+  });
+  if (!packageDir) {
+    return null;
+  }
+
+  // Parse package.json exports
+  var exportsMap = parsePackageExports({
+    packageDir: packageDir,
+    fs: fs
+  });
+  if (exportsMap.size === 0) {
+    return null;
+  }
+
+  // Determine the export path (e.g., '.' or './utils')
+  var exportPath = subPath ? '.' + subPath : '.';
+  var entryFilePath = exportsMap.get(exportPath);
+  if (!entryFilePath) {
+    return null;
+  }
+  return {
+    packageName: packageName,
+    packageDir: packageDir,
+    exportPath: exportPath,
+    entryFilePath: entryFilePath
+  };
+}

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

@@ -0,0 +1,80 @@
+export var 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(_ref) {
+  var fs = _ref.fs;
+  if (!fs.cache.perf) {
+    fs.cache.perf = {
+      installedExitHook: false,
+      counters: {},
+      timers: {}
+    };
+  }
+}
+function ensureExitHookInstalled(_ref2) {
+  var fs = _ref2.fs;
+  if (!isPerfEnabled()) {
+    return;
+  }
+  ensurePerfInitialized({
+    fs: 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 ".concat(PERF_ENV_VAR));
+  process.once('exit', function () {
+    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 (".concat(PERF_ENV_VAR, ")"));
+    // eslint-disable-next-line no-console
+    console.log("[eslint-plugin-internal] perf summary (".concat(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(_ref3) {
+  var _perf$counters$key;
+  var fs = _ref3.fs,
+    key = _ref3.key,
+    _ref3$by = _ref3.by,
+    by = _ref3$by === void 0 ? 1 : _ref3$by;
+  if (!isPerfEnabled()) {
+    return;
+  }
+  ensureExitHookInstalled({
+    fs: fs
+  });
+  var 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(_ref4) {
+  var fs = _ref4.fs,
+    key = _ref4.key,
+    fn = _ref4.fn;
+  if (!isPerfEnabled()) {
+    return fn();
+  }
+  ensureExitHookInstalled({
+    fs: fs
+  });
+  var perf = fs.cache.perf;
+  var start = nowMs();
+  try {
+    return fn();
+  } finally {
+    var _perf$timers$key;
+    var 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/esm/rules/import/shared/types.js

@@ -0,0 +1,61 @@
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
+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) { _defineProperty(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; }
+import { execSync as _execSync } from 'child_process';
+import { existsSync, readdirSync as _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 var realFileSystem = {
+  existsSync: existsSync,
+  readFileSync: readFileSync,
+  realpathSync: realpathSync,
+  statSync: statSync,
+  readdirSync: function readdirSync(path, options) {
+    return _readdirSync(path, options);
+  },
+  execSync: function execSync(command, options) {
+    try {
+      return _execSync(command, _objectSpread(_objectSpread({}, options), {}, {
+        encoding: 'utf-8'
+      })).trim();
+    } catch (_unused) {
+      return null;
+    }
+  },
+  cache: {}
+};
+
+/**
+ * Information about cross-package re-export origin.
+ */
+
+/**
+ * Information about where an export originates.
+ */
+
+/**
+ * Context for package resolution operations.
+ */