@atlaskit/eslint-plugin-platform 2.8.0 → 2.9.1

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

@@ -222,6 +222,7 @@ function getImportPathForSourceFile(_ref) {
     fs = _ref.fs;
   var crossPackageName = exportInfo === null || exportInfo === void 0 || (_exportInfo$crossPack = exportInfo.crossPackageSource) === null || _exportInfo$crossPack === void 0 ? void 0 : _exportInfo$crossPack.packageName;
   if (crossPackageName) {
+    var _findExportForSourceF;
     var sourcePackageExportsMaps = getSourcePackageExportsMaps(fs);
     var exportsMap = sourcePackageExportsMaps.get(crossPackageName);
     if (!exportsMap) {
@@ -238,10 +239,10 @@ function getImportPathForSourceFile(_ref) {
         sourcePackageExportsMaps.set(crossPackageName, exportsMap);
       }
     }
-    var targetExportPath = exportsMap ? findExportForSourceFile({
+    var targetExportPath = exportsMap ? (_findExportForSourceF = findExportForSourceFile({
       sourceFilePath: sourceFilePath,
       exportsMap: exportsMap
-    }) : null;
+    })) === null || _findExportForSourceF === void 0 ? void 0 : _findExportForSourceF.exportPath : null;
     return targetExportPath ? crossPackageName + targetExportPath.slice(1) : crossPackageName;
   }
   return getRelativeImportPath({

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

@@ -61,6 +61,7 @@ function getImportPathForSourceFile(_ref) {
     fs = _ref.fs;
   var crossPackageName = exportInfo === null || exportInfo === void 0 || (_exportInfo$crossPack = exportInfo.crossPackageSource) === null || _exportInfo$crossPack === void 0 ? void 0 : _exportInfo$crossPack.packageName;
   if (crossPackageName) {
+    var _findExportForSourceF;
     var sourcePackageExportsMaps = getSourcePackageExportsMaps(fs);
     var exportsMap = sourcePackageExportsMaps.get(crossPackageName);
     if (!exportsMap) {
@@ -77,10 +78,10 @@ function getImportPathForSourceFile(_ref) {
         sourcePackageExportsMaps.set(crossPackageName, exportsMap);
       }
     }
-    var targetExportPath = exportsMap ? findExportForSourceFile({
+    var targetExportPath = exportsMap ? (_findExportForSourceF = findExportForSourceFile({
       sourceFilePath: sourceFilePath,
       exportsMap: exportsMap
-    }) : null;
+    })) === null || _findExportForSourceF === void 0 ? void 0 : _findExportForSourceF.exportPath : null;
     return targetExportPath ? crossPackageName + targetExportPath.slice(1) : crossPackageName;
   }
   return getRelativeImportPath({
@@ -459,10 +460,13 @@ function transformExportSpecifiers(_ref1) {
   var specsWithOriginal = _ref1.specsWithOriginal;
   return specsWithOriginal.map(function (_ref10) {
     var originalName = _ref10.originalName,
+      nameInSource = _ref10.nameInSource,
       nameInLocal = _ref10.nameInLocal,
       kind = _ref10.kind;
     return {
-      nameInSource: originalName || 'default',
+      // Use originalName if available (means there was an alias in the barrel),
+      // otherwise use nameInSource (the direct export name from the barrel)
+      nameInSource: originalName !== null && originalName !== void 0 ? originalName : nameInSource,
       nameInLocal: nameInLocal,
       kind: kind
     };

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

@@ -124,6 +124,58 @@ export function findJestRequireMockCalls(_ref) {
   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.
@@ -132,20 +184,20 @@ export function findJestRequireMockCalls(_ref) {
  * @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(_ref2) {
-  var requireMockNode = _ref2.requireMockNode,
-    symbolToNewPath = _ref2.symbolToNewPath;
+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 _iterator2 = _createForOfIteratorHelper(declarator.id.properties),
-        _step2;
+      var _iterator3 = _createForOfIteratorHelper(declarator.id.properties),
+        _step3;
       try {
-        for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
-          var prop = _step2.value;
+        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) {
@@ -154,9 +206,9 @@ export function resolveNewPathForRequireMock(_ref2) {
           }
         }
       } catch (err) {
-        _iterator2.e(err);
+        _iterator3.e(err);
       } finally {
-        _iterator2.f();
+        _iterator3.f();
       }
     }
 

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

@@ -3,15 +3,93 @@ 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 { join } from 'path';
-import { readFileContent, resolveImportPath } from './file-system';
+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 the package.json exports field and return a map of export paths to resolved file paths.
+ * 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).
  */
-export function parsePackageExports(_ref) {
-  var packageDir = _ref.packageDir,
+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).
@@ -23,7 +101,7 @@ export function parsePackageExports(_ref) {
   try {
     var _fs$statSync$mtimeMs;
     currentMtimeMs = (_fs$statSync$mtimeMs = fs.statSync(packageJsonPath).mtimeMs) !== null && _fs$statSync$mtimeMs !== void 0 ? _fs$statSync$mtimeMs : null;
-  } catch (_unused) {
+  } catch (_unused2) {
     // If package.json can't be stat'ed (missing/inaccessible), use null to force re-read
     currentMtimeMs = null;
   }
@@ -72,7 +150,7 @@ export function parsePackageExports(_ref) {
         }
       }
     }
-  } catch (_unused2) {
+  } catch (_unused3) {
     // Ignore parsing errors
   }
 
@@ -83,29 +161,225 @@ export function parsePackageExports(_ref) {
   });
   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`.
+ *
+ * `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(_ref2) {
-  var sourceFilePath = _ref2.sourceFilePath,
-    exportsMap = _ref2.exportsMap;
-  var _iterator = _createForOfIteratorHelper(exportsMap),
-    _step;
+export function findExportForSourceFile(_ref3) {
+  var sourceFilePath = _ref3.sourceFilePath,
+    exportsMap = _ref3.exportsMap,
+    fs = _ref3.fs,
+    sourceExportName = _ref3.sourceExportName;
+  // --- Phase 1: direct matches (export value === sourceFilePath) ---
+  var directMatches = [];
+  var _iterator3 = _createForOfIteratorHelper(exportsMap),
+    _step3;
   try {
-    for (_iterator.s(); !(_step = _iterator.n()).done;) {
-      var _step$value = _slicedToArray(_step.value, 2),
-        exportPath = _step$value[0],
-        resolvedPath = _step$value[1];
-      if (resolvedPath === sourceFilePath) {
-        return exportPath;
+    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) {
+        directMatches.push({
+          exportPath: _exportPath
+        });
+      }
+    }
+  } catch (err) {
+    _iterator3.e(err);
+  } 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 {
+      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);
+                }
+                entryPointMatches.push({
+                  exportPath: exportPath,
+                  entryPointExportName: entryPointExportName
+                });
+              }
+            }
+          } catch (err) {
+            _iterator5.e(err);
+          } finally {
+            _iterator5.f();
+          }
+        }
+      }
+    } catch (err) {
+      _iterator4.e(err);
+    } 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) {
-    _iterator.e(err);
+    _iterator6.e(err);
   } finally {
-    _iterator.f();
+    _iterator6.f();
   }
   return null;
 }
@@ -129,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(_ref3) {
-  var moduleSpecifier = _ref3.moduleSpecifier,
-    workspaceRoot = _ref3.workspaceRoot,
-    fs = _ref3.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;