@atlaskit/eslint-plugin-platform 2.9.0 → 2.9.1

package/dist/esm/rules/import/no-barrel-entry-imports/index.js

@@ -10,7 +10,7 @@ import { dirname } from 'path';
 import { parseBarrelExports } from '../shared/barrel-parsing';
 import { DEFAULT_TARGET_FOLDERS, findWorkspaceRoot, isRelativeImport } from '../shared/file-system';
 import { findPackageInRegistry, isPackageInApplyToImportsFrom } from '../shared/package-registry';
-import { findExportForSourceFile, parsePackageExports } from '../shared/package-resolution';
+import { findCrossPackageBridgeExportPath, findExportForSourceFile, parsePackageExports } from '../shared/package-resolution';
 import { realFileSystem } from '../shared/types';
 
 /**
@@ -41,6 +41,10 @@ var ruleMeta = {
           type: 'string'
         },
         description: 'The folder paths (relative to workspace root) containing packages whose imports will be checked and autofixed.'
+      },
+      preferImportedPackageSubpath: {
+        type: 'boolean',
+        description: 'Prefer subpaths on the imported barrel package when they bridge to the dependency (e.g. @scope/pkg/subpath instead of @scope/dependency).'
       }
     },
     additionalProperties: false
@@ -240,10 +244,12 @@ function classifySpecifiers(_ref4) {
   var node = _ref4.node,
     importContext = _ref4.importContext,
     workspaceRoot = _ref4.workspaceRoot,
-    fs = _ref4.fs;
+    fs = _ref4.fs,
+    preferImportedPackageSubpath = _ref4.preferImportedPackageSubpath;
   var currentExportPath = importContext.currentExportPath,
     exportsMap = importContext.exportsMap,
-    exportMap = importContext.exportMap;
+    exportMap = importContext.exportMap,
+    importedPackageName = importContext.packageName;
   var specifiers = node.specifiers;
   var specifiersByTarget = new Map();
   var unmappedSpecifiers = [];
@@ -264,6 +270,7 @@ function classifySpecifiers(_ref4) {
       var kind = 'value';
       if (spec.type === 'ImportDefaultSpecifier') {
         nameInSource = 'default';
+        kind = node.importKind === 'type' ? 'type' : 'value';
       } else if (spec.type === 'ImportSpecifier') {
         nameInSource = getImportedName(spec);
         var parentImportKind = node.importKind;
@@ -279,6 +286,36 @@ function classifySpecifiers(_ref4) {
         // Check if this is a cross-package re-export
         var sourcePackageName = (_exportInfo$crossPack = exportInfo.crossPackageSource) === null || _exportInfo$crossPack === void 0 ? void 0 : _exportInfo$crossPack.packageName;
         if (sourcePackageName) {
+          var targetKey = void 0;
+          var resolvedOriginalName = exportInfo.originalName;
+          if (preferImportedPackageSubpath) {
+            var bridge = findCrossPackageBridgeExportPath({
+              exportsMap: exportsMap,
+              crossPackageName: sourcePackageName,
+              exportedName: nameInSource,
+              fs: fs
+            });
+            if (bridge) {
+              targetKey = importedPackageName + bridge.exportPath.slice(1);
+              if (bridge.entryPointExportName !== undefined) {
+                resolvedOriginalName = bridge.entryPointExportName === nameInSource ? undefined : bridge.entryPointExportName;
+              }
+              if (!specifiersByTarget.has(targetKey)) {
+                specifiersByTarget.set(targetKey, []);
+              }
+              specifiersByTarget.get(targetKey).push({
+                spec: _objectSpread(_objectSpread({}, spec), {}, {
+                  importKind: effectiveKind
+                }),
+                originalName: resolvedOriginalName,
+                targetExportPath: targetKey,
+                kind: effectiveKind,
+                sourcePackageName: sourcePackageName
+              });
+              continue;
+            }
+          }
+
           // For cross-package re-exports, find the most specific subpath in the source package
           // Note: Package resolution is not constrained by applyToImportsFrom - any package can be resolved
           var sourcePackageExportsMap = sourcePackageExportsMaps.get(sourcePackageName);
@@ -299,7 +336,6 @@ function classifySpecifiers(_ref4) {
 
           // Find the best export path in the source package
           var _targetExportPath = null;
-          var resolvedOriginalName = exportInfo.originalName;
           if (sourcePackageExportsMap) {
             var _exportInfo$originalN, _matchResult$exportPa;
             var _sourceExportName = (_exportInfo$originalN = exportInfo.originalName) !== null && _exportInfo$originalN !== void 0 ? _exportInfo$originalN : nameInSource;
@@ -316,7 +352,7 @@ function classifySpecifiers(_ref4) {
           }
 
           // Build the full import path: @package/subpath or just @package if no subpath found
-          var targetKey = _targetExportPath ? sourcePackageName + _targetExportPath.slice(1) // Remove leading '.' from subpath
+          targetKey = _targetExportPath ? sourcePackageName + _targetExportPath.slice(1) // Remove leading '.' from subpath
           : sourcePackageName;
           if (!specifiersByTarget.has(targetKey)) {
             specifiersByTarget.set(targetKey, []);
@@ -691,7 +727,10 @@ function createBarrelImportFix(_ref0) {
         }
       } else {
         // Create new import
-        var _isTypeImport = node.importKind === 'type';
+        var allSpecsAreType = specsWithTarget.every(function (s) {
+          return s.kind === 'type';
+        });
+        var _isTypeImport = node.importKind === 'type' || allSpecsAreType;
         var importStatement = buildImportStatement({
           specs: specs,
           path: newImportPath,
@@ -717,7 +756,10 @@ function createBarrelImportFix(_ref0) {
     var unmappedSpecs = unmappedSpecifiers.map(function (u) {
       return u.spec;
     });
-    var isTypeImport = node.importKind === 'type';
+    var allUnmappedAreType = unmappedSpecifiers.every(function (u) {
+      return u.kind === 'type';
+    });
+    var isTypeImport = node.importKind === 'type' || allUnmappedAreType;
     var remainingImport = buildImportStatement({
       specs: unmappedSpecs,
       path: importPath,
@@ -893,7 +935,8 @@ function handleRequireMemberExpression(_ref13) {
     context = _ref13.context,
     workspaceRoot = _ref13.workspaceRoot,
     fs = _ref13.fs,
-    applyToImportsFrom = _ref13.applyToImportsFrom;
+    applyToImportsFrom = _ref13.applyToImportsFrom,
+    preferImportedPackageSubpath = _ref13.preferImportedPackageSubpath;
   if (node.computed || node.property.type !== 'Identifier') {
     return;
   }
@@ -917,7 +960,8 @@ function handleRequireMemberExpression(_ref13) {
       node: synthetic,
       importContext: importContext,
       workspaceRoot: workspaceRoot,
-      fs: fs
+      fs: fs,
+      preferImportedPackageSubpath: preferImportedPackageSubpath
     }),
     specifiersByTarget = _classifySpecifiers.specifiersByTarget,
     hasNamespaceImport = _classifySpecifiers.hasNamespaceImport;
@@ -975,7 +1019,8 @@ function handleRequireDestructuringDeclarator(_ref16) {
     context = _ref16.context,
     workspaceRoot = _ref16.workspaceRoot,
     fs = _ref16.fs,
-    applyToImportsFrom = _ref16.applyToImportsFrom;
+    applyToImportsFrom = _ref16.applyToImportsFrom,
+    preferImportedPackageSubpath = _ref16.preferImportedPackageSubpath;
   if (node.id.type !== 'ObjectPattern' || !node.init || node.init.type !== 'CallExpression') {
     return;
   }
@@ -1041,7 +1086,8 @@ function handleRequireDestructuringDeclarator(_ref16) {
       node: synthetic,
       importContext: importContext,
       workspaceRoot: workspaceRoot,
-      fs: fs
+      fs: fs,
+      preferImportedPackageSubpath: preferImportedPackageSubpath
     }),
     specifiersByTarget = _classifySpecifiers2.specifiersByTarget,
     unmappedSpecifiers = _classifySpecifiers2.unmappedSpecifiers,
@@ -1151,7 +1197,8 @@ function handleImportDeclaration(_ref19) {
     context = _ref19.context,
     workspaceRoot = _ref19.workspaceRoot,
     fs = _ref19.fs,
-    applyToImportsFrom = _ref19.applyToImportsFrom;
+    applyToImportsFrom = _ref19.applyToImportsFrom,
+    preferImportedPackageSubpath = _ref19.preferImportedPackageSubpath;
   // Resolve import context (validates and extracts package/export info)
   // applyToImportsFrom is used here to filter which packages the rule applies to
   var importContext = resolveImportContext({
@@ -1174,7 +1221,8 @@ function handleImportDeclaration(_ref19) {
       node: node,
       importContext: importContext,
       workspaceRoot: workspaceRoot,
-      fs: fs
+      fs: fs,
+      preferImportedPackageSubpath: preferImportedPackageSubpath
     }),
     specifiersByTarget = _classifySpecifiers3.specifiersByTarget,
     unmappedSpecifiers = _classifySpecifiers3.unmappedSpecifiers,
@@ -1227,9 +1275,10 @@ export function createRule(fs) {
   return {
     meta: ruleMeta,
     create: function create(context) {
-      var _options$applyToImpor;
+      var _options$applyToImpor, _options$preferImport;
       var options = context.options[0] || {};
       var applyToImportsFrom = (_options$applyToImpor = options.applyToImportsFrom) !== null && _options$applyToImpor !== void 0 ? _options$applyToImpor : DEFAULT_TARGET_FOLDERS;
+      var preferImportedPackageSubpath = (_options$preferImport = options.preferImportedPackageSubpath) !== null && _options$preferImport !== void 0 ? _options$preferImport : false;
       var workspaceRoot = findWorkspaceRoot({
         startPath: dirname(context.filename),
         fs: fs,
@@ -1243,7 +1292,8 @@ export function createRule(fs) {
             context: context,
             workspaceRoot: workspaceRoot,
             fs: fs,
-            applyToImportsFrom: applyToImportsFrom
+            applyToImportsFrom: applyToImportsFrom,
+            preferImportedPackageSubpath: preferImportedPackageSubpath
           });
         },
         MemberExpression: function MemberExpression(rawNode) {
@@ -1252,7 +1302,8 @@ export function createRule(fs) {
             context: context,
             workspaceRoot: workspaceRoot,
             fs: fs,
-            applyToImportsFrom: applyToImportsFrom
+            applyToImportsFrom: applyToImportsFrom,
+            preferImportedPackageSubpath: preferImportedPackageSubpath
           });
         },
         VariableDeclarator: function VariableDeclarator(rawNode) {
@@ -1261,7 +1312,8 @@ export function createRule(fs) {
             context: context,
             workspaceRoot: workspaceRoot,
             fs: fs,
-            applyToImportsFrom: applyToImportsFrom
+            applyToImportsFrom: applyToImportsFrom,
+            preferImportedPackageSubpath: preferImportedPackageSubpath
           });
         }
       };

package/dist/esm/rules/import/no-barrel-entry-jest-mock/index.js

@@ -10,7 +10,7 @@ import { hasReExportsFromOtherFiles, parseBarrelExports } from '../shared/barrel
 import { DEFAULT_TARGET_FOLDERS, findWorkspaceRoot, isRelativeImport, readFileContent, resolveImportPath } from '../shared/file-system';
 import { extractImportPath, findJestRequireActualCalls, findJestRequireMockCalls, isJestMockCall, isJestRequireActual, resolveNewPathForRequireMock } from '../shared/jest-utils';
 import { findPackageInRegistry, isPackageInApplyToImportsFrom } from '../shared/package-registry';
-import { findExportForSourceFile, parsePackageExports } from '../shared/package-resolution';
+import { findCrossPackageBridgeExportPath, findExportForSourceFile, parsePackageExports } from '../shared/package-resolution';
 import { realFileSystem } from '../shared/types';
 
 /**
@@ -662,7 +662,9 @@ function traceSymbolsToExports(_ref10) {
     exportMap = _ref10.exportMap,
     exportsMap = _ref10.exportsMap,
     currentExportPath = _ref10.currentExportPath,
-    fs = _ref10.fs;
+    fs = _ref10.fs,
+    barrelPackageName = _ref10.barrelPackageName,
+    preferImportedPackageSubpath = _ref10.preferImportedPackageSubpath;
   var groupedByExport = new Map();
   var crossPackageGroups = new Map();
   var unmappedSymbols = [];
@@ -680,16 +682,38 @@ function traceSymbolsToExports(_ref10) {
 
       // Check for cross-package source first
       if (exportInfo.crossPackageSource) {
-        var key = "".concat(exportInfo.crossPackageSource.packageName).concat(exportInfo.crossPackageSource.exportPath === '.' ? '' : exportInfo.crossPackageSource.exportPath.slice(1));
+        var key = void 0;
+        var tracedOriginalName = exportInfo.originalName;
+        var barrelBridgeExportPath = void 0;
+        if (preferImportedPackageSubpath) {
+          var bridge = findCrossPackageBridgeExportPath({
+            exportsMap: exportsMap,
+            crossPackageName: exportInfo.crossPackageSource.packageName,
+            exportedName: symbolName,
+            fs: fs
+          });
+          if (bridge) {
+            key = "".concat(barrelPackageName).concat(bridge.exportPath.slice(1));
+            barrelBridgeExportPath = bridge.exportPath;
+            if (bridge.entryPointExportName !== undefined) {
+              tracedOriginalName = bridge.entryPointExportName === symbolName ? undefined : bridge.entryPointExportName;
+            }
+          } else {
+            key = "".concat(exportInfo.crossPackageSource.packageName).concat(exportInfo.crossPackageSource.exportPath === '.' ? '' : exportInfo.crossPackageSource.exportPath.slice(1));
+          }
+        } else {
+          key = "".concat(exportInfo.crossPackageSource.packageName).concat(exportInfo.crossPackageSource.exportPath === '.' ? '' : exportInfo.crossPackageSource.exportPath.slice(1));
+        }
         if (!crossPackageGroups.has(key)) {
           crossPackageGroups.set(key, []);
         }
         crossPackageGroups.get(key).push({
           symbolName: symbolName,
-          originalName: exportInfo.originalName,
+          originalName: tracedOriginalName,
           sourceFilePath: exportInfo.path,
           isTypeOnly: exportInfo.isTypeOnly,
-          crossPackageSource: exportInfo.crossPackageSource
+          crossPackageSource: exportInfo.crossPackageSource,
+          barrelBridgeExportPath: barrelBridgeExportPath
         });
         continue;
       }
@@ -1060,6 +1084,10 @@ var ruleMeta = {
           type: 'string'
         },
         description: 'The folder paths (relative to workspace root) containing packages whose imports will be checked and autofixed.'
+      },
+      preferImportedPackageSubpath: {
+        type: 'boolean',
+        description: 'Prefer subpaths on the mocked barrel package when they bridge to the dependency.'
       }
     },
     additionalProperties: false
@@ -1078,9 +1106,10 @@ export function createRule(fs) {
   return {
     meta: ruleMeta,
     create: function create(context) {
-      var _options$applyToImpor;
+      var _options$applyToImpor, _options$preferImport;
       var options = context.options[0] || {};
       var applyToImportsFrom = (_options$applyToImpor = options.applyToImportsFrom) !== null && _options$applyToImpor !== void 0 ? _options$applyToImpor : DEFAULT_TARGET_FOLDERS;
+      var preferImportedPackageSubpath = (_options$preferImport = options.preferImportedPackageSubpath) !== null && _options$preferImport !== void 0 ? _options$preferImport : false;
       var workspaceRoot = findWorkspaceRoot({
         startPath: dirname(context.filename),
         fs: fs,
@@ -1175,7 +1204,9 @@ export function createRule(fs) {
                 exportMap: raContext.exportMap,
                 exportsMap: raContext.exportsMap,
                 currentExportPath: raContext.currentExportPath,
-                fs: fs
+                fs: fs,
+                barrelPackageName: raContext.packageName,
+                preferImportedPackageSubpath: preferImportedPackageSubpath
               }),
               _groupedByExport = _traceSymbolsToExport.groupedByExport,
               _crossPackageGroups = _traceSymbolsToExport.crossPackageGroups;
@@ -1272,7 +1303,9 @@ export function createRule(fs) {
               exportMap: mockContext.exportMap,
               exportsMap: mockContext.exportsMap,
               currentExportPath: mockContext.currentExportPath,
-              fs: fs
+              fs: fs,
+              barrelPackageName: mockContext.packageName,
+              preferImportedPackageSubpath: preferImportedPackageSubpath
             }),
             groupedByExport = _traceSymbolsToExport2.groupedByExport,
             crossPackageGroups = _traceSymbolsToExport2.crossPackageGroups,
@@ -1364,8 +1397,9 @@ export function createRule(fs) {
 
               // Get cross-package source info from the first symbol (all symbols in same group have same source)
               var crossPackageSource = _symbols[0].crossPackageSource;
+              var bridgeExportPath = _symbols[0].barrelBridgeExportPath;
               crossPackageMockGroups.push({
-                exportPath: crossPackageSource.exportPath,
+                exportPath: bridgeExportPath !== null && bridgeExportPath !== void 0 ? bridgeExportPath : crossPackageSource.exportPath,
                 importPath: _importPath,
                 propertyNames: _symbols.map(function (s) {
                   return s.symbolName;

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

@@ -161,10 +161,52 @@ export function parsePackageExports(_ref2) {
   });
   return exportsMap;
 }
+/**
+ * Check whether a subpath export key (e.g. `"./checkbox-select"`) is kebab-case.
+ *
+ * A key is considered kebab-case when the portion after the leading `"./"` prefix
+ * consists only of lowercase letters, digits, hyphens, dots, and forward-slash
+ * separators — i.e. no uppercase letters, underscores, or camelCase humps.
+ */
+export function isKebabCaseExportKey(key) {
+  var body = key.replace(/^\.\//, '');
+  if (body.length === 0) {
+    return false;
+  }
+  return /^[a-z0-9][a-z0-9\-./]*$/.test(body);
+}
+
+/**
+ * Given a list of candidate {@link ExportMatchResult}s that all resolve to the same
+ * source file, pick the best one.  When any candidate's export path is kebab-case
+ * and points to an entry-point file, prefer it over non-kebab-case alternatives.
+ * Falls back to the first candidate if no kebab-case entry-point candidate is found.
+ */
+function pickBestMatch(candidates, exportsMap) {
+  if (candidates.length === 1) {
+    return candidates[0];
+  }
+
+  // Among candidates whose value is an entry-point file, prefer kebab-case keys.
+  var entryPointKebab = candidates.filter(function (c) {
+    var resolved = exportsMap.get(c.exportPath);
+    return resolved && isInEntryPointsFolder(resolved) && isKebabCaseExportKey(c.exportPath);
+  });
+  if (entryPointKebab.length > 0) {
+    return entryPointKebab[0];
+  }
+
+  // Fall back to the first candidate (preserves previous behaviour).
+  return candidates[0];
+}
+
 /**
  * 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 multiple export paths resolve to the same source file **and** point to an
+ * entry-point file, kebab-case keys are preferred over other casing styles.
+ *
  * 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`.
@@ -178,6 +220,8 @@ export function findExportForSourceFile(_ref3) {
     exportsMap = _ref3.exportsMap,
     fs = _ref3.fs,
     sourceExportName = _ref3.sourceExportName;
+  // --- Phase 1: direct matches (export value === sourceFilePath) ---
+  var directMatches = [];
   var _iterator3 = _createForOfIteratorHelper(exportsMap),
     _step3;
   try {
@@ -186,9 +230,9 @@ export function findExportForSourceFile(_ref3) {
         _exportPath = _step3$value[0],
         _resolvedPath = _step3$value[1];
       if (_resolvedPath === sourceFilePath) {
-        return {
+        directMatches.push({
           exportPath: _exportPath
-        };
+        });
       }
     }
   } catch (err) {
@@ -196,7 +240,13 @@ export function findExportForSourceFile(_ref3) {
   } finally {
     _iterator3.f();
   }
+  if (directMatches.length > 0) {
+    return pickBestMatch(directMatches, exportsMap);
+  }
+
+  // --- Phase 2: entry-point wrapper re-export matches ---
   if (fs) {
+    var entryPointMatches = [];
     var _iterator4 = _createForOfIteratorHelper(exportsMap),
       _step4;
     try {
@@ -219,10 +269,10 @@ export function findExportForSourceFile(_ref3) {
                 if (sourceExportName !== undefined && reExport.nameMap.has(sourceExportName)) {
                   entryPointExportName = reExport.nameMap.get(sourceExportName);
                 }
-                return {
+                entryPointMatches.push({
                   exportPath: exportPath,
                   entryPointExportName: entryPointExportName
-                };
+                });
               }
             }
           } catch (err) {
@@ -237,6 +287,99 @@ export function findExportForSourceFile(_ref3) {
     } finally {
       _iterator4.f();
     }
+    if (entryPointMatches.length > 0) {
+      return pickBestMatch(entryPointMatches, exportsMap);
+    }
+  }
+  return null;
+}
+
+/**
+ * When a symbol reaches the consumer through a barrel package that re-exports from
+ * `crossPackageName`, find a `package.json` export subpath of that barrel whose entry
+ * file directly re-exports the symbol from `crossPackageName` (named exports only).
+ *
+ * This enables rewriting imports to `@scope/barrel/subpath` instead of
+ * `@scope/cross-package/...` when the barrel exposes such a subpath (e.g. `@atlaskit/select/react-select`).
+ */
+export function findCrossPackageBridgeExportPath(_ref4) {
+  var exportsMap = _ref4.exportsMap,
+    crossPackageName = _ref4.crossPackageName,
+    exportedName = _ref4.exportedName,
+    fs = _ref4.fs;
+  var _iterator6 = _createForOfIteratorHelper(exportsMap),
+    _step6;
+  try {
+    for (_iterator6.s(); !(_step6 = _iterator6.n()).done;) {
+      var _step6$value = _slicedToArray(_step6.value, 2),
+        exportPath = _step6$value[0],
+        resolvedPath = _step6$value[1];
+      var content = readFileContent({
+        filePath: resolvedPath,
+        fs: fs
+      });
+      if (!content) {
+        continue;
+      }
+      try {
+        var sourceFile = ts.createSourceFile(resolvedPath, content, ts.ScriptTarget.Latest, true);
+        var _iterator7 = _createForOfIteratorHelper(sourceFile.statements),
+          _step7;
+        try {
+          for (_iterator7.s(); !(_step7 = _iterator7.n()).done;) {
+            var statement = _step7.value;
+            if (!ts.isExportDeclaration(statement) || statement.isTypeOnly) {
+              continue;
+            }
+            if (!statement.moduleSpecifier || !ts.isStringLiteral(statement.moduleSpecifier)) {
+              continue;
+            }
+            if (statement.moduleSpecifier.text !== crossPackageName) {
+              continue;
+            }
+            if (!statement.exportClause || ts.isNamespaceExport(statement.exportClause)) {
+              continue;
+            }
+            if (!ts.isNamedExports(statement.exportClause)) {
+              continue;
+            }
+            var _iterator8 = _createForOfIteratorHelper(statement.exportClause.elements),
+              _step8;
+            try {
+              for (_iterator8.s(); !(_step8 = _iterator8.n()).done;) {
+                var element = _step8.value;
+                if (element.isTypeOnly) {
+                  continue;
+                }
+                var publicName = element.name.text;
+                if (publicName !== exportedName) {
+                  continue;
+                }
+                var entryPointExportName = element.propertyName ? element.propertyName.text : undefined;
+                return {
+                  exportPath: exportPath,
+                  entryPointExportName: entryPointExportName
+                };
+              }
+            } catch (err) {
+              _iterator8.e(err);
+            } finally {
+              _iterator8.f();
+            }
+          }
+        } catch (err) {
+          _iterator7.e(err);
+        } finally {
+          _iterator7.f();
+        }
+      } catch (_unused4) {
+        // Ignore parse errors for individual export entry files
+      }
+    }
+  } catch (err) {
+    _iterator6.e(err);
+  } finally {
+    _iterator6.f();
   }
   return null;
 }
@@ -260,10 +403,10 @@ export function extractPackageNameFromImport(moduleSpecifier) {
  * 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;
+export function resolveCrossPackageImport(_ref5) {
+  var moduleSpecifier = _ref5.moduleSpecifier,
+    workspaceRoot = _ref5.workspaceRoot,
+    fs = _ref5.fs;
   // Only handle @atlassian/* scoped packages
   var parsed = extractPackageNameFromImport(moduleSpecifier);
   if (!parsed) {

package/dist/esm/rules/no-restricted-fedramp-imports/index.js

@@ -0,0 +1,59 @@
+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; }
+// eslint-disable-next-line import/no-extraneous-dependencies
+
+var RESTRICTED_IMPORTS = {
+  '@atlassian/atl-context': ['isFedRamp', 'isIsolatedCloud'],
+  '@atlaskit/atlassian-context': ['isFedRamp', 'isIsolatedCloud'],
+  '@atlassian/teams-common': ['isFedramp']
+};
+var rule = {
+  meta: {
+    type: 'problem',
+    docs: {
+      description: 'Disallow importing deprecated FedRamp/IsolatedCloud context functions. Use isFeatureEnabled from AEM (Atlassian Environment Manager) instead.',
+      recommended: true
+    },
+    messages: {
+      noRestrictedFedrampImports: '{{name}} from {{source}} will be deprecated soon. Please use isFeatureEnabled from AEM (Atlassian Environment Manager) instead. See go/AEM for more details.'
+    },
+    schema: []
+  },
+  create: function create(context) {
+    return {
+      ImportDeclaration: function ImportDeclaration(node) {
+        var source = node.source.value;
+        if (typeof source !== 'string') {
+          return;
+        }
+        var restrictedNames = RESTRICTED_IMPORTS[source];
+        if (!restrictedNames) {
+          return;
+        }
+        var _iterator = _createForOfIteratorHelper(node.specifiers),
+          _step;
+        try {
+          for (_iterator.s(); !(_step = _iterator.n()).done;) {
+            var specifier = _step.value;
+            if (specifier.type === 'ImportSpecifier' && restrictedNames.includes(specifier.imported.name)) {
+              context.report({
+                node: specifier,
+                messageId: 'noRestrictedFedrampImports',
+                data: {
+                  name: specifier.imported.name,
+                  source: source
+                }
+              });
+            }
+          }
+        } catch (err) {
+          _iterator.e(err);
+        } finally {
+          _iterator.f();
+        }
+      }
+    };
+  }
+};
+export default rule;

package/dist/esm/rules/visit-example-type-import-required/index.js

@@ -17,7 +17,7 @@ var messages = {
   suggestFixPath: 'Update import path to match visitExample arguments'
 };
 function isTargetFile(filename) {
-  return filename.endsWith('.spec.tsx');
+  return filename.endsWith('.spec.tsx') || filename.endsWith('.spec.ts');
 }
 
 /**

package/dist/types/index.d.ts

@@ -29,6 +29,7 @@ declare const rules: {
     'no-direct-document-usage': import("eslint").Rule.RuleModule;
     'no-set-immediate': import("eslint").Rule.RuleModule;
     'prefer-crypto-random-uuid': import("eslint").Rule.RuleModule;
+    'no-restricted-fedramp-imports': import("eslint").Rule.RuleModule;
     'no-barrel-entry-imports': import("eslint").Rule.RuleModule;
     'no-barrel-entry-jest-mock': import("eslint").Rule.RuleModule;
     'no-jest-mock-barrel-files': import("eslint").Rule.RuleModule;
@@ -72,6 +73,7 @@ declare const plugin: {
         'no-direct-document-usage': import("eslint").Rule.RuleModule;
         'no-set-immediate': import("eslint").Rule.RuleModule;
         'prefer-crypto-random-uuid': import("eslint").Rule.RuleModule;
+        'no-restricted-fedramp-imports': import("eslint").Rule.RuleModule;
         'no-barrel-entry-imports': import("eslint").Rule.RuleModule;
         'no-barrel-entry-jest-mock': import("eslint").Rule.RuleModule;
         'no-jest-mock-barrel-files': import("eslint").Rule.RuleModule;

package/dist/types/rules/import/shared/package-resolution.d.ts

@@ -16,10 +16,21 @@ export interface ExportMatchResult {
      */
     entryPointExportName?: string;
 }
+/**
+ * Check whether a subpath export key (e.g. `"./checkbox-select"`) is kebab-case.
+ *
+ * A key is considered kebab-case when the portion after the leading `"./"` prefix
+ * consists only of lowercase letters, digits, hyphens, dots, and forward-slash
+ * separators — i.e. no uppercase letters, underscores, or camelCase humps.
+ */
+export declare function isKebabCaseExportKey(key: string): boolean;
 /**
  * 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 multiple export paths resolve to the same source file **and** point to an
+ * entry-point file, kebab-case keys are preferred over other casing styles.
+ *
  * 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`.
@@ -34,6 +45,20 @@ export declare function findExportForSourceFile({ sourceFilePath, exportsMap, fs
     fs?: FileSystem;
     sourceExportName?: string;
 }): ExportMatchResult | null;
+/**
+ * When a symbol reaches the consumer through a barrel package that re-exports from
+ * `crossPackageName`, find a `package.json` export subpath of that barrel whose entry
+ * file directly re-exports the symbol from `crossPackageName` (named exports only).
+ *
+ * This enables rewriting imports to `@scope/barrel/subpath` instead of
+ * `@scope/cross-package/...` when the barrel exposes such a subpath (e.g. `@atlaskit/select/react-select`).
+ */
+export declare function findCrossPackageBridgeExportPath({ exportsMap, crossPackageName, exportedName, fs, }: {
+    exportsMap: Map<string, string>;
+    crossPackageName: string;
+    exportedName: string;
+    fs: FileSystem;
+}): ExportMatchResult | null;
 /**
  * Extract the package name and subpath from an import specifier.
  * Returns null if the import is not a scoped package import.