@atlaskit/eslint-plugin-platform 2.9.0 → 2.9.2

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

@@ -6,7 +6,9 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.extractPackageNameFromImport = extractPackageNameFromImport;
+exports.findCrossPackageBridgeExportPath = findCrossPackageBridgeExportPath;
 exports.findExportForSourceFile = findExportForSourceFile;
+exports.isKebabCaseExportKey = isKebabCaseExportKey;
 exports.parsePackageExports = parsePackageExports;
 exports.resolveCrossPackageImport = resolveCrossPackageImport;
 var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));
@@ -173,10 +175,52 @@ 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.
+ */
+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`.
@@ -190,6 +234,8 @@ 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 {
@@ -198,9 +244,9 @@ function findExportForSourceFile(_ref3) {
         _exportPath = _step3$value[0],
         _resolvedPath = _step3$value[1];
       if (_resolvedPath === sourceFilePath) {
-        return {
+        directMatches.push({
           exportPath: _exportPath
-        };
+        });
       }
     }
   } catch (err) {
@@ -208,7 +254,13 @@ 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 {
@@ -231,10 +283,10 @@ function findExportForSourceFile(_ref3) {
                 if (sourceExportName !== undefined && reExport.nameMap.has(sourceExportName)) {
                   entryPointExportName = reExport.nameMap.get(sourceExportName);
                 }
-                return {
+                entryPointMatches.push({
                   exportPath: exportPath,
                   entryPointExportName: entryPointExportName
-                };
+                });
               }
             }
           } catch (err) {
@@ -249,6 +301,99 @@ 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`).
+ */
+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 = (0, _slicedToArray2.default)(_step6.value, 2),
+        exportPath = _step6$value[0],
+        resolvedPath = _step6$value[1];
+      var content = (0, _fileSystem.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;
 }
@@ -272,10 +417,10 @@ 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.
  */
-function resolveCrossPackageImport(_ref4) {
-  var moduleSpecifier = _ref4.moduleSpecifier,
-    workspaceRoot = _ref4.workspaceRoot,
-    fs = _ref4.fs;
+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/cjs/rules/no-restricted-fedramp-imports/index.js

@@ -0,0 +1,65 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+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();
+        }
+      }
+    };
+  }
+};
+var _default = exports.default = rule;

package/dist/cjs/rules/no-xcss-in-cx/index.js

@@ -0,0 +1,221 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _isSupportedImport = require("@atlaskit/eslint-utils/is-supported-import");
+var _contextCompat = require("../util/context-compat");
+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; }
+/**
+ * Disallows passing xcss() results into cx() when used in an xcss prop.
+ *
+ * xcss() from @atlaskit/primitives and cx() from @atlaskit/css / @compiled/react
+ * are incompatible — xcss() produces an opaque StyleRule object, while cx()
+ * expects Compiled atomic class name strings. Mixing them causes runtime errors.
+ * xcss() results must never be passed to cx(), whether inline or pre-defined.
+ *
+ * ❌ Wrong — xcss() called inline inside cx():
+ *   xcss={cx(xcss({ color: 'red' }), xcss({ fontWeight: 'bold' }))}
+ *
+ * ❌ Also wrong — xcss() results pre-defined but still passed into cx():
+ *   const baseStyles = xcss({ color: 'red' });
+ *   const boldStyles = xcss({ fontWeight: 'bold' });
+ *   xcss={cx(baseStyles, boldStyles)}
+ *
+ * ✅ Correct — pass xcss() results directly to the xcss prop (no cx()):
+ *   const baseStyles = xcss({ color: 'red' });
+ *   xcss={baseStyles}
+ *
+ * ✅ Correct — use cssMap() + cx() (cssMap is compatible with cx()):
+ *   const styles = cssMap({ base: { color: 'red' } });
+ *   xcss={cx(styles.base, condition && styles.focused)}
+ *
+ * This rule is import-aware: it only flags xcss() calls (inline or via variable)
+ * imported from @atlaskit/primitives inside cx() calls imported from @atlaskit/css
+ * or @compiled/react that appear inside an xcss prop.
+ */
+var rule = {
+  meta: {
+    type: 'problem',
+    docs: {
+      description: 'Disallow calling xcss() inline inside cx() in an xcss prop. Define styles at module level instead.'
+    },
+    messages: {
+      noXcssInCx: 'Do not pass xcss() results into cx(). ' + 'xcss() produces a StyleRule object that is incompatible with cx(), which expects Compiled atomic class names. ' + 'Pass xcss() results directly to the xcss prop instead: xcss={myStyles}. ' + 'To conditionally combine styles, use cssMap() + cx(): const styles = cssMap({...}); xcss={cx(styles.base, cond && styles.active)}'
+    },
+    schema: []
+  },
+  create: function create(context) {
+    return {
+      JSXAttribute: function JSXAttribute(node) {
+        // Narrow Rule.Node to JSXAttribute (estree-jsx augments the `estree` Node
+        // union with JSX members, so this discriminated narrowing is safe).
+        if (node.type !== 'JSXAttribute') {
+          return;
+        }
+
+        // Only check `xcss` props
+        if (node.name.type !== 'JSXIdentifier' || node.name.name !== 'xcss') {
+          return;
+        }
+        if (!node.value || node.value.type !== 'JSXExpressionContainer') {
+          return;
+        }
+        var expression = node.value.expression;
+        if (expression.type === 'JSXEmptyExpression') {
+          return;
+        }
+
+        // Early-return if the expression cannot possibly contain a cx() call —
+        // avoids the cost of getImportSources/getScope on simple references like xcss={baseStyles}.
+        var isCallOrArray = expression.type === 'CallExpression' || expression.type === 'ArrayExpression';
+        if (!isCallOrArray) {
+          return;
+        }
+        var importSources = (0, _isSupportedImport.getImportSources)(context);
+        var _getScope = (0, _contextCompat.getScope)(context, node),
+          references = _getScope.references;
+
+        /**
+         * Returns true if an Identifier node resolves to a variable whose
+         * initializer is a call to xcss() imported from @atlaskit/primitives.
+         *
+         * Walks up the scope chain from the current JSXAttribute scope to find
+         * the variable definition, since module-level variables are not in the
+         * local scope's references list.
+         *
+         * e.g. `const baseStyles = xcss({ color: 'red' })` — passing `baseStyles`
+         * here returns true.
+         */
+        var isXcssVariable = function isXcssVariable(identNode) {
+          if (identNode.type !== 'Identifier') {
+            return false;
+          }
+          var name = identNode.name;
+          // Walk up the scope chain to find the variable definition
+          var currentScope = (0, _contextCompat.getScope)(context, node);
+          while (currentScope) {
+            var variable = currentScope.set.get(name);
+            if (variable) {
+              var _iterator = _createForOfIteratorHelper(variable.defs),
+                _step;
+              try {
+                for (_iterator.s(); !(_step = _iterator.n()).done;) {
+                  var _def$node$init;
+                  var def = _step.value;
+                  if (def.type === 'Variable' && def.node.type === 'VariableDeclarator' && ((_def$node$init = def.node.init) === null || _def$node$init === void 0 ? void 0 : _def$node$init.type) === 'CallExpression') {
+                    // isXcss checks the callee identifier against referencesInScope to
+                    // find the import binding. The callee lives in the same scope as the
+                    // variable definition, so use all references from that scope.
+                    var defScopeRefs = currentScope.references;
+                    if ((0, _isSupportedImport.isXcss)(def.node.init.callee, defScopeRefs, importSources)) {
+                      return true;
+                    }
+                  }
+                }
+                // Found the variable but it's not an xcss() call
+              } catch (err) {
+                _iterator.e(err);
+              } finally {
+                _iterator.f();
+              }
+              return false;
+            }
+            currentScope = currentScope.upper;
+          }
+          return false;
+        };
+
+        /**
+         * Recursively check a node that is an argument to cx() for xcss() results —
+         * both inline calls and references to variables initialised with xcss().
+         * Recurses into LogicalExpression (&&, ||) and ConditionalExpression (? :) so that
+         * patterns like cx(cond && xcss({...})) and cx(cond ? baseStyles : a) are caught.
+         */
+        var _checkArgForXcss = function checkArgForXcss(argNode) {
+          if (!argNode) {
+            return;
+          }
+          // Inline: cx(xcss({ color: 'red' }))
+          if (argNode.type === 'CallExpression' && (0, _isSupportedImport.isXcss)(argNode.callee, references, importSources)) {
+            context.report({
+              node: argNode,
+              messageId: 'noXcssInCx'
+            });
+            return;
+          }
+          // Variable reference: cx(baseStyles) where baseStyles = xcss({...})
+          if (isXcssVariable(argNode)) {
+            context.report({
+              node: argNode,
+              messageId: 'noXcssInCx'
+            });
+            return;
+          }
+          // Recurse into `cond && xcss({...})` or `cond || xcss({...})`
+          if (argNode.type === 'LogicalExpression') {
+            _checkArgForXcss(argNode.left);
+            _checkArgForXcss(argNode.right);
+          }
+          // Recurse into `cond ? xcss({...}) : fallback`
+          if (argNode.type === 'ConditionalExpression') {
+            _checkArgForXcss(argNode.consequent);
+            _checkArgForXcss(argNode.alternate);
+          }
+        };
+
+        /**
+         * Check all arguments of a cx() call for inline xcss() calls.
+         * Reports each xcss() call found as a violation.
+         */
+        var checkCxArgs = function checkCxArgs(callNode) {
+          if (callNode.type !== 'CallExpression') {
+            return;
+          }
+          if (!(0, _isSupportedImport.isCxFunction)(callNode.callee, references, importSources)) {
+            return;
+          }
+          var _iterator2 = _createForOfIteratorHelper(callNode.arguments),
+            _step2;
+          try {
+            for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+              var arg = _step2.value;
+              if (arg) {
+                _checkArgForXcss(arg.type === 'SpreadElement' ? arg.argument : arg);
+              }
+            }
+          } catch (err) {
+            _iterator2.e(err);
+          } finally {
+            _iterator2.f();
+          }
+        };
+
+        // Case 1: xcss={cx(...)} — cx() directly as the xcss value
+        checkCxArgs(expression);
+
+        // Case 2: xcss={[..., cx(...), ...]} — cx() inside an xcss array
+        if (expression.type === 'ArrayExpression') {
+          var _iterator3 = _createForOfIteratorHelper(expression.elements),
+            _step3;
+          try {
+            for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
+              var element = _step3.value;
+              if (element) {
+                checkCxArgs(element.type === 'SpreadElement' ? element.argument : element);
+              }
+            }
+          } catch (err) {
+            _iterator3.e(err);
+          } finally {
+            _iterator3.f();
+          }
+        }
+      }
+    };
+  }
+};
+var _default = exports.default = rule;

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

@@ -24,7 +24,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');
 }
 
 /**
@@ -118,7 +118,8 @@ function resolveVariableToConstant(programBody, variableName, cache) {
  * Returns null for any argument that can't be statically resolved.
  */
 function extractCallArgs(node, programBody, variableCache) {
-  if (node.arguments.length < 3) {
+  var argOffset = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : 0;
+  if (node.arguments.length < argOffset + 3) {
     return null;
   }
   function resolveArg(arg) {
@@ -130,9 +131,9 @@ function extractCallArgs(node, programBody, variableCache) {
     }
     return null;
   }
-  var groupId = resolveArg(node.arguments[0]);
-  var packageId = resolveArg(node.arguments[1]);
-  var exampleId = resolveArg(node.arguments[2]);
+  var groupId = resolveArg(node.arguments[argOffset]);
+  var packageId = resolveArg(node.arguments[argOffset + 1]);
+  var exampleId = resolveArg(node.arguments[argOffset + 2]);
   if (!groupId || !packageId || !exampleId) {
     return null;
   }
@@ -180,8 +181,13 @@ function resolveExamplePathFromArgs(groupId, packageId, exampleId, testFilePath)
   var examplesDir = _path.default.resolve(packagesBase.basePath, groupId, packageId, 'examples');
   var fallback = _path.default.resolve(examplesDir, "".concat(exampleId, ".tsx"));
 
-  // Match: exact name OR numeric-prefixed variant, with optional `.examples` infix
-  var candidateRe = new RegExp("^(?:\\d+-)?".concat(exampleId, "(?:\\.examples?)?\\.tsx$"));
+  // Phase 4: loosen candidateRe to match both pre- and post-rename filename shapes.
+  // Pre-rename:  ^(\d+-)?<id>(\.(examples?))?\.tsx$
+  // Post-rename: ^(\d+-)?<id>(\.<ident>){0,3}\.tsx$   (Volt prefix, optional .dup<N>, optional role)
+  // The {0,3} cap prevents matching arbitrary strings (e.g. 4-component names).
+  // Escape regex metacharacters in exampleId (ids are kebab-case today, but defensive).
+  var escapedId = exampleId.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+  var candidateRe = new RegExp("^(?:\\d+-)?".concat(escapedId, "(?:\\.[A-Za-z][A-Za-z0-9_]*){0,3}\\.tsx$"));
   try {
     var match = _fs.default.readdirSync(examplesDir).find(function (f) {
       return candidateRe.test(f);
@@ -279,20 +285,24 @@ var rule = {
           return;
         }
         var node = estreeNode;
-        // Only handle `<anything>.visitExample(...)` calls
-        if (node.callee.type !== _utils.AST_NODE_TYPES.MemberExpression || node.callee.property.type !== _utils.AST_NODE_TYPES.Identifier || node.callee.property.name !== 'visitExample') {
+        var calleeIdentifier = null;
+        var argOffset = 0;
+        if (node.callee.type === _utils.AST_NODE_TYPES.MemberExpression && node.callee.property.type === _utils.AST_NODE_TYPES.Identifier && node.callee.property.name === 'visitExample') {
+          calleeIdentifier = node.callee.property;
+        } else if (node.callee.type === _utils.AST_NODE_TYPES.Identifier && node.callee.name === 'visitMockedExample') {
+          calleeIdentifier = node.callee;
+          argOffset = 1; // first arg is `page`
+        } else {
           return;
         }
 
-        // Narrow callee — we've confirmed property is an Identifier above
-        var callee = node.callee;
         // reportCallee is typed as estree.Node for context.report compatibility
         var reportCallee = estreeNode.callee;
         var genericType = extractGenericType(node);
 
         // ── Case 1: No generic type parameter ────────────────────────────────
         if (genericType === null) {
-          var _args = extractCallArgs(node, programBody, variableCache);
+          var _args = extractCallArgs(node, programBody, variableCache, argOffset);
           context.report({
             node: reportCallee,
             messageId: 'missingTypeofImport',
@@ -305,7 +315,7 @@ var rule = {
                 return null;
               }
               var importPath = computeRelativeImportPath(filename, examplePath);
-              var _ref2 = callee.property.range,
+              var _ref2 = calleeIdentifier.range,
                 _ref3 = (0, _slicedToArray2.default)(_ref2, 2),
                 start = _ref3[0],
                 end = _ref3[1];
@@ -367,7 +377,7 @@ var rule = {
         }
 
         // Validate that the import path matches the arguments
-        var args = extractCallArgs(node, programBody, variableCache);
+        var args = extractCallArgs(node, programBody, variableCache, argOffset);
         if (!args) {
           // Dynamic arguments — can't validate statically
           return;

package/dist/es2019/index.js

@@ -25,10 +25,12 @@ import useRecommendedUtils from './rules/feature-gating/use-recommended-utils';
 import validGateName from './rules/feature-gating/valid-gate-name';
 import expandBackgroundShorthand from './rules/compiled/expand-background-shorthand';
 import expandSpacingShorthand from './rules/compiled/expand-spacing-shorthand';
+import noCssPropInObjectSpread from './rules/compiled/no-css-prop-in-object-spread';
 import noSparseCheckout from './rules/no-sparse-checkout';
 import noDirectDocumentUsage from './rules/no-direct-document-usage';
 import noSetImmediate from './rules/no-set-immediate';
 import preferCryptoRandomUuid from './rules/prefer-crypto-random-uuid';
+import noRestrictedFedrampImports from './rules/no-restricted-fedramp-imports';
 import noBarrelEntryImports from './rules/import/no-barrel-entry-imports';
 import noBarrelEntryJestMock from './rules/import/no-barrel-entry-jest-mock';
 import noJestMockBarrelFiles from './rules/import/no-jest-mock-barrel-files';
@@ -36,6 +38,7 @@ import noRelativeBarrelFileImports from './rules/import/no-relative-barrel-file-
 import noConversationAssistantBarrelImports from './rules/import/no-conversation-assistant-barrel-imports';
 import visitExampleTypeImportRequired from './rules/visit-example-type-import-required';
 import ensureUseSyncExternalStoreServerSnapshot from './rules/ensure-use-sync-external-store-server-snapshot';
+import noXcssInCx from './rules/no-xcss-in-cx';
 import { join, normalize } from 'node:path';
 import { readFileSync } from 'node:fs';
 let jiraRoot;
@@ -66,6 +69,7 @@ const rules = {
   'expand-border-shorthand': expandBorderShorthand,
   'expand-background-shorthand': expandBackgroundShorthand,
   'expand-spacing-shorthand': expandSpacingShorthand,
+  'no-css-prop-in-object-spread': noCssPropInObjectSpread,
   'no-duplicate-dependencies': noDuplicateDependencies,
   'no-invalid-feature-flag-usage': noInvalidFeatureFlagUsage,
   'no-pre-post-install-scripts': noPreAndPostInstallScripts,
@@ -85,12 +89,14 @@ const rules = {
   'no-direct-document-usage': noDirectDocumentUsage,
   'no-set-immediate': noSetImmediate,
   'prefer-crypto-random-uuid': preferCryptoRandomUuid,
+  'no-restricted-fedramp-imports': noRestrictedFedrampImports,
   'no-barrel-entry-imports': noBarrelEntryImports,
   'no-barrel-entry-jest-mock': noBarrelEntryJestMock,
   'no-jest-mock-barrel-files': noJestMockBarrelFiles,
   'no-relative-barrel-file-imports': noRelativeBarrelFileImports,
   'no-conversation-assistant-barrel-imports': noConversationAssistantBarrelImports,
   'visit-example-type-import-required': visitExampleTypeImportRequired,
+  'no-xcss-in-cx': noXcssInCx,
   'ensure-use-sync-external-store-server-snapshot': ensureUseSyncExternalStoreServerSnapshot
 };
 const commonConfig = {
@@ -103,10 +109,12 @@ const commonConfig = {
   '@atlaskit/platform/no-module-level-eval-nav4': 'error',
   '@atlaskit/platform/no-direct-document-usage': 'warn',
   '@atlaskit/platform/no-set-immediate': 'error',
+  '@atlaskit/platform/no-xcss-in-cx': 'error',
   // Compiled: rules that are not included via `@compiled/recommended
   '@atlaskit/platform/expand-border-shorthand': 'error',
   '@atlaskit/platform/expand-background-shorthand': 'error',
   '@atlaskit/platform/expand-spacing-shorthand': 'error',
+  '@atlaskit/platform/no-css-prop-in-object-spread': 'error',
   '@compiled/jsx-pragma': ['error', {
     importSources: ['@atlaskit/css'],
     onlyRunIfImportingCompiled: true,
@@ -151,7 +159,6 @@ const plugin = {
         get '@atlaskit/platform'() {
           return plugin;
         },
-        // @ts-expect-error there's an issue with the types for @compiled/eslint-plugin ('no-css-prop-without-css-function' specifically)
         '@compiled': {
           meta: compiledPlugin.meta,
           rules: compiledPlugin.rules
@@ -168,7 +175,6 @@ const plugin = {
         get '@atlaskit/platform'() {
           return plugin;
         },
-        // @ts-expect-error there's an issue with the types for @compiled/eslint-plugin ('no-css-prop-without-css-function' specifically)
         '@compiled': {
           meta: compiledPlugin.meta,
           rules: compiledPlugin.rules