@atlaskit/eslint-plugin-platform 2.9.0 → 2.9.2

package/dist/es2019/rules/compiled/no-css-prop-in-object-spread/index.js

@@ -0,0 +1,136 @@
+import { getScope, getSourceCode } from '../../util/context-compat';
+
+/**
+ * Returns the `css` Property node from an ObjectExpression, or null if not found.
+ */
+function getCssProperty(objectExpression) {
+  for (const prop of objectExpression.properties) {
+    if (prop.type !== 'Property') {
+      continue;
+    }
+    const {
+      key
+    } = prop;
+    if (key.type === 'Identifier' && key.name === 'css' || key.type === 'Literal' && key.value === 'css') {
+      return prop;
+    }
+  }
+  return null;
+}
+export const noCssPropInObjectSpread = {
+  meta: {
+    docs: {
+      url: 'https://bitbucket.org/atlassian/atlassian-frontend-monorepo/src/master/platform/packages/platform/eslint-plugin/src/rules/compiled/no-css-prop-in-object-spread/',
+      description: 'Disallows `css` property inside objects spread into JSX — the Compiled JSX pragma ignores it'
+    },
+    fixable: 'code',
+    messages: {
+      noCssPropInObjectSpread: 'The `css` property inside an object spread into JSX is a no-op. The Compiled JSX pragma only processes `css` as a direct JSX attribute. Move `css` out of the spread: <El css={...} />'
+    },
+    type: 'problem'
+  },
+  create(context) {
+    return {
+      JSXSpreadAttribute(node) {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const spreadNode = node;
+        const arg = spreadNode.argument;
+
+        // Case 1: inline object literal — <div {...{ css: styles, id: 'foo' }} />
+        if (arg.type === 'ObjectExpression') {
+          const objectArg = arg;
+          const cssProp = getCssProperty(objectArg);
+          if (!cssProp) {
+            return;
+          }
+          context.report({
+            node,
+            messageId: 'noCssPropInObjectSpread',
+            fix(fixer) {
+              const sourceCode = getSourceCode(context);
+              const cssValueText = sourceCode.getText(cssProp.value);
+              const remainingProps = objectArg.properties.filter(p => p !== cssProp);
+              const directCssProp = `css={${cssValueText}}`;
+              if (remainingProps.length === 0) {
+                return fixer.replaceText(node, directCssProp);
+              }
+              const remainingText = remainingProps.map(p => sourceCode.getText(p)).join(', ');
+              return fixer.replaceText(node, `${directCssProp} {...{ ${remainingText} }}`);
+            }
+          });
+          return;
+        }
+
+        // Case 2: variable reference — <div {...props} />
+        if (arg.type === 'Identifier') {
+          const scope = getScope(context, arg);
+          let currentScope = scope;
+          let variable = null;
+          while (currentScope) {
+            const found = currentScope.variables.find(v => v.name === arg.name);
+            if (found) {
+              variable = found;
+              break;
+            }
+            currentScope = currentScope.upper;
+          }
+          if (!variable || variable.defs.length === 0) {
+            return;
+          }
+          const def = variable.defs[0];
+          if (def.type !== 'Variable' || !def.node.init || def.node.init.type !== 'ObjectExpression') {
+            return;
+          }
+          const initObject = def.node.init;
+          const cssProp = getCssProperty(initObject);
+          if (!cssProp) {
+            return;
+          }
+
+          // Only auto-fix when there is exactly one JSX spread site for this variable
+          const spreadCount = variable.references.filter(ref => {
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            const refParent = ref.identifier.parent;
+            return (refParent === null || refParent === void 0 ? void 0 : refParent.type) === 'JSXSpreadAttribute';
+          }).length;
+          context.report({
+            node,
+            messageId: 'noCssPropInObjectSpread',
+            ...(spreadCount === 1 ? {
+              fix(fixer) {
+                const sourceCode = getSourceCode(context);
+                const cssValueText = sourceCode.getText(cssProp.value);
+                const fixes = [];
+                const remainingProps = initObject.properties.filter(p => p !== cssProp);
+                if (remainingProps.length === 0) {
+                  fixes.push(fixer.replaceText(initObject, '{}'));
+                } else {
+                  const propIndex = initObject.properties.indexOf(cssProp);
+                  const isLast = propIndex === initObject.properties.length - 1;
+                  const tokenBefore = sourceCode.getTokenBefore(cssProp);
+                  const tokenAfter = sourceCode.getTokenAfter(cssProp);
+                  if (!isLast && tokenAfter && tokenAfter.value === ',') {
+                    const src = sourceCode.getText();
+                    const afterEnd = tokenAfter.range[1];
+                    let end = afterEnd;
+                    while (end < src.length && src[end] === ' ') {
+                      end++;
+                    }
+                    fixes.push(fixer.removeRange([cssProp.range[0], end]));
+                  } else if (tokenBefore && tokenBefore.value === ',') {
+                    fixes.push(fixer.removeRange([tokenBefore.range[0], cssProp.range[1]]));
+                  } else {
+                    fixes.push(fixer.remove(cssProp));
+                  }
+                }
+                fixes.push(fixer.insertTextBefore(node, `css={${cssValueText}} `));
+                return fixes;
+              }
+            } : {})
+          });
+        }
+      }
+    };
+  }
+};
+export default noCssPropInObjectSpread;

package/dist/es2019/rules/ensure-critical-dependency-resolutions/index.js

@@ -11,7 +11,6 @@ const DESIRED_PKG_VERSIONS = {
   tslib: ['2.6', '2.8'],
   '@types/react': ['16.14', '18.2', '18.3'],
   'react-relay': ['npm:atl-react-relay@0.0.0-main-39e79f66'],
-  'relay-compiler': ['npm:atl-relay-compiler@0.0.0-main-39e79f66'],
   'relay-runtime': ['npm:atl-relay-runtime@0.0.0-main-39e79f66'],
   'relay-test-utils': ['npm:atl-relay-test-utils@0.0.0-main-39e79f66']
 };

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

@@ -2,7 +2,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';
 
 /**
@@ -33,6 +33,10 @@ const 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
@@ -222,12 +226,14 @@ function classifySpecifiers({
   node,
   importContext,
   workspaceRoot,
-  fs
+  fs,
+  preferImportedPackageSubpath
 }) {
   const {
     currentExportPath,
     exportsMap,
-    exportMap
+    exportMap,
+    packageName: importedPackageName
   } = importContext;
   const specifiers = node.specifiers;
   const specifiersByTarget = new Map();
@@ -245,6 +251,7 @@ function classifySpecifiers({
     let kind = 'value';
     if (spec.type === 'ImportDefaultSpecifier') {
       nameInSource = 'default';
+      kind = node.importKind === 'type' ? 'type' : 'value';
     } else if (spec.type === 'ImportSpecifier') {
       nameInSource = getImportedName(spec);
       const parentImportKind = node.importKind;
@@ -260,6 +267,37 @@ function classifySpecifiers({
       // Check if this is a cross-package re-export
       const sourcePackageName = (_exportInfo$crossPack = exportInfo.crossPackageSource) === null || _exportInfo$crossPack === void 0 ? void 0 : _exportInfo$crossPack.packageName;
       if (sourcePackageName) {
+        let targetKey;
+        let resolvedOriginalName = exportInfo.originalName;
+        if (preferImportedPackageSubpath) {
+          const bridge = findCrossPackageBridgeExportPath({
+            exportsMap,
+            crossPackageName: sourcePackageName,
+            exportedName: nameInSource,
+            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: {
+                ...spec,
+                importKind: effectiveKind
+              },
+              originalName: resolvedOriginalName,
+              targetExportPath: targetKey,
+              kind: effectiveKind,
+              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
         let sourcePackageExportsMap = sourcePackageExportsMaps.get(sourcePackageName);
@@ -280,7 +318,6 @@ function classifySpecifiers({
 
         // Find the best export path in the source package
         let targetExportPath = null;
-        let resolvedOriginalName = exportInfo.originalName;
         if (sourcePackageExportsMap) {
           var _exportInfo$originalN, _matchResult$exportPa;
           const sourceExportName = (_exportInfo$originalN = exportInfo.originalName) !== null && _exportInfo$originalN !== void 0 ? _exportInfo$originalN : nameInSource;
@@ -297,7 +334,7 @@ function classifySpecifiers({
         }
 
         // Build the full import path: @package/subpath or just @package if no subpath found
-        const 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, []);
@@ -652,7 +689,8 @@ function createBarrelImportFix({
       }
     } else {
       // Create new import
-      const isTypeImport = node.importKind === 'type';
+      const allSpecsAreType = specsWithTarget.every(s => s.kind === 'type');
+      const isTypeImport = node.importKind === 'type' || allSpecsAreType;
       const importStatement = buildImportStatement({
         specs,
         path: newImportPath,
@@ -668,7 +706,8 @@ function createBarrelImportFix({
   // Handle unmapped specifiers - they stay in the original import
   if (unmappedSpecifiers.length > 0) {
     const unmappedSpecs = unmappedSpecifiers.map(u => u.spec);
-    const isTypeImport = node.importKind === 'type';
+    const allUnmappedAreType = unmappedSpecifiers.every(u => u.kind === 'type');
+    const isTypeImport = node.importKind === 'type' || allUnmappedAreType;
     const remainingImport = buildImportStatement({
       specs: unmappedSpecs,
       path: importPath,
@@ -814,7 +853,8 @@ function handleRequireMemberExpression({
   context,
   workspaceRoot,
   fs,
-  applyToImportsFrom
+  applyToImportsFrom,
+  preferImportedPackageSubpath
 }) {
   if (node.computed || node.property.type !== 'Identifier') {
     return;
@@ -842,7 +882,8 @@ function handleRequireMemberExpression({
     node: synthetic,
     importContext,
     workspaceRoot,
-    fs
+    fs,
+    preferImportedPackageSubpath
   });
   if (hasNamespaceImport || specifiersByTarget.size === 0) {
     return;
@@ -895,7 +936,8 @@ function handleRequireDestructuringDeclarator({
   context,
   workspaceRoot,
   fs,
-  applyToImportsFrom
+  applyToImportsFrom,
+  preferImportedPackageSubpath
 }) {
   if (node.id.type !== 'ObjectPattern' || !node.init || node.init.type !== 'CallExpression') {
     return;
@@ -957,7 +999,8 @@ function handleRequireDestructuringDeclarator({
     node: synthetic,
     importContext,
     workspaceRoot,
-    fs
+    fs,
+    preferImportedPackageSubpath
   });
   if (hasNamespaceImport || specifiersByTarget.size === 0 || unmappedSpecifiers.length > 0) {
     return;
@@ -1035,7 +1078,8 @@ function handleImportDeclaration({
   context,
   workspaceRoot,
   fs,
-  applyToImportsFrom
+  applyToImportsFrom,
+  preferImportedPackageSubpath
 }) {
   // Resolve import context (validates and extracts package/export info)
   // applyToImportsFrom is used here to filter which packages the rule applies to
@@ -1063,7 +1107,8 @@ function handleImportDeclaration({
     node,
     importContext,
     workspaceRoot,
-    fs
+    fs,
+    preferImportedPackageSubpath
   });
 
   // If namespace import, report without auto-fix if there are specific exports available
@@ -1113,9 +1158,10 @@ export function createRule(fs) {
   return {
     meta: ruleMeta,
     create(context) {
-      var _options$applyToImpor;
+      var _options$applyToImpor, _options$preferImport;
       const options = context.options[0] || {};
       const applyToImportsFrom = (_options$applyToImpor = options.applyToImportsFrom) !== null && _options$applyToImpor !== void 0 ? _options$applyToImpor : DEFAULT_TARGET_FOLDERS;
+      const preferImportedPackageSubpath = (_options$preferImport = options.preferImportedPackageSubpath) !== null && _options$preferImport !== void 0 ? _options$preferImport : false;
       const workspaceRoot = findWorkspaceRoot({
         startPath: dirname(context.filename),
         fs,
@@ -1129,7 +1175,8 @@ export function createRule(fs) {
             context,
             workspaceRoot,
             fs,
-            applyToImportsFrom
+            applyToImportsFrom,
+            preferImportedPackageSubpath
           });
         },
         MemberExpression(rawNode) {
@@ -1138,7 +1185,8 @@ export function createRule(fs) {
             context,
             workspaceRoot,
             fs,
-            applyToImportsFrom
+            applyToImportsFrom,
+            preferImportedPackageSubpath
           });
         },
         VariableDeclarator(rawNode) {
@@ -1147,7 +1195,8 @@ export function createRule(fs) {
             context,
             workspaceRoot,
             fs,
-            applyToImportsFrom
+            applyToImportsFrom,
+            preferImportedPackageSubpath
           });
         }
       };

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

@@ -4,7 +4,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';
 
 /**
@@ -525,7 +525,9 @@ function traceSymbolsToExports({
   exportMap,
   exportsMap,
   currentExportPath,
-  fs
+  fs,
+  barrelPackageName,
+  preferImportedPackageSubpath
 }) {
   const groupedByExport = new Map();
   const crossPackageGroups = new Map();
@@ -540,16 +542,38 @@ function traceSymbolsToExports({
 
     // Check for cross-package source first
     if (exportInfo.crossPackageSource) {
-      const key = `${exportInfo.crossPackageSource.packageName}${exportInfo.crossPackageSource.exportPath === '.' ? '' : exportInfo.crossPackageSource.exportPath.slice(1)}`;
+      let key;
+      let tracedOriginalName = exportInfo.originalName;
+      let barrelBridgeExportPath;
+      if (preferImportedPackageSubpath) {
+        const bridge = findCrossPackageBridgeExportPath({
+          exportsMap,
+          crossPackageName: exportInfo.crossPackageSource.packageName,
+          exportedName: symbolName,
+          fs
+        });
+        if (bridge) {
+          key = `${barrelPackageName}${bridge.exportPath.slice(1)}`;
+          barrelBridgeExportPath = bridge.exportPath;
+          if (bridge.entryPointExportName !== undefined) {
+            tracedOriginalName = bridge.entryPointExportName === symbolName ? undefined : bridge.entryPointExportName;
+          }
+        } else {
+          key = `${exportInfo.crossPackageSource.packageName}${exportInfo.crossPackageSource.exportPath === '.' ? '' : exportInfo.crossPackageSource.exportPath.slice(1)}`;
+        }
+      } else {
+        key = `${exportInfo.crossPackageSource.packageName}${exportInfo.crossPackageSource.exportPath === '.' ? '' : exportInfo.crossPackageSource.exportPath.slice(1)}`;
+      }
       if (!crossPackageGroups.has(key)) {
         crossPackageGroups.set(key, []);
       }
       crossPackageGroups.get(key).push({
         symbolName,
-        originalName: exportInfo.originalName,
+        originalName: tracedOriginalName,
         sourceFilePath: exportInfo.path,
         isTypeOnly: exportInfo.isTypeOnly,
-        crossPackageSource: exportInfo.crossPackageSource
+        crossPackageSource: exportInfo.crossPackageSource,
+        barrelBridgeExportPath
       });
       continue;
     }
@@ -876,6 +900,10 @@ const 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
@@ -894,9 +922,10 @@ export function createRule(fs) {
   return {
     meta: ruleMeta,
     create(context) {
-      var _options$applyToImpor;
+      var _options$applyToImpor, _options$preferImport;
       const options = context.options[0] || {};
       const applyToImportsFrom = (_options$applyToImpor = options.applyToImportsFrom) !== null && _options$applyToImpor !== void 0 ? _options$applyToImpor : DEFAULT_TARGET_FOLDERS;
+      const preferImportedPackageSubpath = (_options$preferImport = options.preferImportedPackageSubpath) !== null && _options$preferImport !== void 0 ? _options$preferImport : false;
       const workspaceRoot = findWorkspaceRoot({
         startPath: dirname(context.filename),
         fs,
@@ -985,7 +1014,9 @@ export function createRule(fs) {
               exportMap: raContext.exportMap,
               exportsMap: raContext.exportsMap,
               currentExportPath: raContext.currentExportPath,
-              fs
+              fs,
+              barrelPackageName: raContext.packageName,
+              preferImportedPackageSubpath
             });
             let newPath = null;
             if (groupedByExport.size === 1 && crossPackageGroups.size === 0) {
@@ -1079,7 +1110,9 @@ export function createRule(fs) {
             exportMap: mockContext.exportMap,
             exportsMap: mockContext.exportsMap,
             currentExportPath: mockContext.currentExportPath,
-            fs
+            fs,
+            barrelPackageName: mockContext.packageName,
+            preferImportedPackageSubpath
           });
 
           // If no symbols can be mapped to specific exports or cross-package sources,
@@ -1125,8 +1158,9 @@ export function createRule(fs) {
 
             // Get cross-package source info from the first symbol (all symbols in same group have same source)
             const crossPackageSource = symbols[0].crossPackageSource;
+            const bridgeExportPath = symbols[0].barrelBridgeExportPath;
             crossPackageMockGroups.push({
-              exportPath: crossPackageSource.exportPath,
+              exportPath: bridgeExportPath !== null && bridgeExportPath !== void 0 ? bridgeExportPath : crossPackageSource.exportPath,
               importPath,
               propertyNames: symbols.map(s => s.symbolName),
               propertyTexts: new Map(symbols.map(s => [s.symbolName, mockProperties.get(s.symbolName).text])),

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

@@ -135,10 +135,52 @@ export function parsePackageExports({
   });
   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) {
+  const 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.
+  const entryPointKebab = candidates.filter(c => {
+    const 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`.
@@ -153,14 +195,22 @@ export function findExportForSourceFile({
   fs,
   sourceExportName
 }) {
+  // --- Phase 1: direct matches (export value === sourceFilePath) ---
+  const directMatches = [];
   for (const [exportPath, resolvedPath] of exportsMap) {
     if (resolvedPath === sourceFilePath) {
-      return {
+      directMatches.push({
         exportPath
-      };
+      });
     }
   }
+  if (directMatches.length > 0) {
+    return pickBestMatch(directMatches, exportsMap);
+  }
+
+  // --- Phase 2: entry-point wrapper re-export matches ---
   if (fs) {
+    const entryPointMatches = [];
     for (const [exportPath, resolvedPath] of exportsMap) {
       if (isInEntryPointsFolder(resolvedPath)) {
         const reExports = resolveEntryPointReExports({
@@ -173,13 +223,78 @@ export function findExportForSourceFile({
             if (sourceExportName !== undefined && reExport.nameMap.has(sourceExportName)) {
               entryPointExportName = reExport.nameMap.get(sourceExportName);
             }
-            return {
+            entryPointMatches.push({
               exportPath,
               entryPointExportName
-            };
+            });
+          }
+        }
+      }
+    }
+    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({
+  exportsMap,
+  crossPackageName,
+  exportedName,
+  fs
+}) {
+  for (const [exportPath, resolvedPath] of exportsMap) {
+    const content = readFileContent({
+      filePath: resolvedPath,
+      fs
+    });
+    if (!content) {
+      continue;
+    }
+    try {
+      const sourceFile = ts.createSourceFile(resolvedPath, content, ts.ScriptTarget.Latest, true);
+      for (const statement of sourceFile.statements) {
+        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;
+        }
+        for (const element of statement.exportClause.elements) {
+          if (element.isTypeOnly) {
+            continue;
+          }
+          const publicName = element.name.text;
+          if (publicName !== exportedName) {
+            continue;
           }
+          const entryPointExportName = element.propertyName ? element.propertyName.text : undefined;
+          return {
+            exportPath,
+            entryPointExportName
+          };
         }
       }
+    } catch {
+      // Ignore parse errors for individual export entry files
     }
   }
   return null;

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

@@ -0,0 +1,47 @@
+// eslint-disable-next-line import/no-extraneous-dependencies
+
+const RESTRICTED_IMPORTS = {
+  '@atlassian/atl-context': ['isFedRamp', 'isIsolatedCloud'],
+  '@atlaskit/atlassian-context': ['isFedRamp', 'isIsolatedCloud'],
+  '@atlassian/teams-common': ['isFedramp']
+};
+const 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(context) {
+    return {
+      ImportDeclaration(node) {
+        const source = node.source.value;
+        if (typeof source !== 'string') {
+          return;
+        }
+        const restrictedNames = RESTRICTED_IMPORTS[source];
+        if (!restrictedNames) {
+          return;
+        }
+        for (const specifier of node.specifiers) {
+          if (specifier.type === 'ImportSpecifier' && restrictedNames.includes(specifier.imported.name)) {
+            context.report({
+              node: specifier,
+              messageId: 'noRestrictedFedrampImports',
+              data: {
+                name: specifier.imported.name,
+                source
+              }
+            });
+          }
+        }
+      }
+    };
+  }
+};
+export default rule;