@atlaskit/eslint-plugin-platform 2.9.1 → 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/no-xcss-in-cx/index.js

@@ -0,0 +1,187 @@
+import { getImportSources, isCxFunction, isXcss } from '@atlaskit/eslint-utils/is-supported-import';
+import { getScope } from '../util/context-compat';
+
+/**
+ * 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.
+ */
+const 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(context) {
+    return {
+      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;
+        }
+        const 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}.
+        const isCallOrArray = expression.type === 'CallExpression' || expression.type === 'ArrayExpression';
+        if (!isCallOrArray) {
+          return;
+        }
+        const importSources = getImportSources(context);
+        const {
+          references
+        } = getScope(context, node);
+
+        /**
+         * 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.
+         */
+        const isXcssVariable = identNode => {
+          if (identNode.type !== 'Identifier') {
+            return false;
+          }
+          const name = identNode.name;
+          // Walk up the scope chain to find the variable definition
+          let currentScope = getScope(context, node);
+          while (currentScope) {
+            const variable = currentScope.set.get(name);
+            if (variable) {
+              for (const def of variable.defs) {
+                var _def$node$init;
+                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.
+                  const defScopeRefs = currentScope.references;
+                  if (isXcss(def.node.init.callee, defScopeRefs, importSources)) {
+                    return true;
+                  }
+                }
+              }
+              // Found the variable but it's not an xcss() call
+              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.
+         */
+        const checkArgForXcss = argNode => {
+          if (!argNode) {
+            return;
+          }
+          // Inline: cx(xcss({ color: 'red' }))
+          if (argNode.type === 'CallExpression' && 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.
+         */
+        const checkCxArgs = callNode => {
+          if (callNode.type !== 'CallExpression') {
+            return;
+          }
+          if (!isCxFunction(callNode.callee, references, importSources)) {
+            return;
+          }
+          for (const arg of callNode.arguments) {
+            if (arg) {
+              checkArgForXcss(arg.type === 'SpreadElement' ? arg.argument : arg);
+            }
+          }
+        };
+
+        // 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') {
+          for (const element of expression.elements) {
+            if (element) {
+              checkCxArgs(element.type === 'SpreadElement' ? element.argument : element);
+            }
+          }
+        }
+      }
+    };
+  }
+};
+export default rule;

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

@@ -91,8 +91,8 @@ function resolveVariableToConstant(programBody, variableName, cache) {
  * Each argument may be a string literal or a reference to a top-level const string variable.
  * Returns null for any argument that can't be statically resolved.
  */
-function extractCallArgs(node, programBody, variableCache) {
-  if (node.arguments.length < 3) {
+function extractCallArgs(node, programBody, variableCache, argOffset = 0) {
+  if (node.arguments.length < argOffset + 3) {
     return null;
   }
   function resolveArg(arg) {
@@ -104,9 +104,9 @@ function extractCallArgs(node, programBody, variableCache) {
     }
     return null;
   }
-  const groupId = resolveArg(node.arguments[0]);
-  const packageId = resolveArg(node.arguments[1]);
-  const exampleId = resolveArg(node.arguments[2]);
+  const groupId = resolveArg(node.arguments[argOffset]);
+  const packageId = resolveArg(node.arguments[argOffset + 1]);
+  const exampleId = resolveArg(node.arguments[argOffset + 2]);
   if (!groupId || !packageId || !exampleId) {
     return null;
   }
@@ -152,8 +152,13 @@ function resolveExamplePathFromArgs(groupId, packageId, exampleId, testFilePath)
   const examplesDir = path.resolve(packagesBase.basePath, groupId, packageId, 'examples');
   const fallback = path.resolve(examplesDir, `${exampleId}.tsx`);
 
-  // Match: exact name OR numeric-prefixed variant, with optional `.examples` infix
-  const candidateRe = new RegExp(`^(?:\\d+-)?${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).
+  const escapedId = exampleId.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+  const candidateRe = new RegExp(`^(?:\\d+-)?${escapedId}(?:\\.[A-Za-z][A-Za-z0-9_]*){0,3}\\.tsx$`);
   try {
     const match = fs.readdirSync(examplesDir).find(f => candidateRe.test(f));
     if (match) {
@@ -248,20 +253,24 @@ const rule = {
           return;
         }
         const node = estreeNode;
-        // Only handle `<anything>.visitExample(...)` calls
-        if (node.callee.type !== AST_NODE_TYPES.MemberExpression || node.callee.property.type !== AST_NODE_TYPES.Identifier || node.callee.property.name !== 'visitExample') {
+        let calleeIdentifier = null;
+        let argOffset = 0;
+        if (node.callee.type === AST_NODE_TYPES.MemberExpression && node.callee.property.type === AST_NODE_TYPES.Identifier && node.callee.property.name === 'visitExample') {
+          calleeIdentifier = node.callee.property;
+        } else if (node.callee.type === 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
-        const callee = node.callee;
         // reportCallee is typed as estree.Node for context.report compatibility
         const reportCallee = estreeNode.callee;
         const genericType = extractGenericType(node);
 
         // ── Case 1: No generic type parameter ────────────────────────────────
         if (genericType === null) {
-          const args = extractCallArgs(node, programBody, variableCache);
+          const args = extractCallArgs(node, programBody, variableCache, argOffset);
           context.report({
             node: reportCallee,
             messageId: 'missingTypeofImport',
@@ -274,7 +283,7 @@ const rule = {
                 return null;
               }
               const importPath = computeRelativeImportPath(filename, examplePath);
-              const [start, end] = callee.property.range;
+              const [start, end] = calleeIdentifier.range;
               return fixer.insertTextAfterRange([start, end], `<typeof import('${importPath}')>`);
             }
           });
@@ -333,7 +342,7 @@ const rule = {
         }
 
         // Validate that the import path matches the arguments
-        const args = extractCallArgs(node, programBody, variableCache);
+        const args = extractCallArgs(node, programBody, variableCache, argOffset);
         if (!args) {
           // Dynamic arguments — can't validate statically
           return;

package/dist/esm/index.js

@@ -28,6 +28,7 @@ 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';
@@ -40,6 +41,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';
 var jiraRoot;
@@ -70,6 +72,7 @@ var 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,
@@ -96,6 +99,7 @@ var rules = {
   '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
 };
 var commonConfig = {
@@ -108,10 +112,12 @@ var 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,
@@ -153,7 +159,6 @@ var 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
@@ -170,7 +175,6 @@ var 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

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

@@ -0,0 +1,156 @@
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+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 { getScope, getSourceCode } from '../../util/context-compat';
+
+/**
+ * Returns the `css` Property node from an ObjectExpression, or null if not found.
+ */
+function getCssProperty(objectExpression) {
+  var _iterator = _createForOfIteratorHelper(objectExpression.properties),
+    _step;
+  try {
+    for (_iterator.s(); !(_step = _iterator.n()).done;) {
+      var prop = _step.value;
+      if (prop.type !== 'Property') {
+        continue;
+      }
+      var key = prop.key;
+      if (key.type === 'Identifier' && key.name === 'css' || key.type === 'Literal' && key.value === 'css') {
+        return prop;
+      }
+    }
+  } catch (err) {
+    _iterator.e(err);
+  } finally {
+    _iterator.f();
+  }
+  return null;
+}
+export var 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: function create(context) {
+    return {
+      JSXSpreadAttribute: function JSXSpreadAttribute(node) {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        var spreadNode = node;
+        var arg = spreadNode.argument;
+
+        // Case 1: inline object literal — <div {...{ css: styles, id: 'foo' }} />
+        if (arg.type === 'ObjectExpression') {
+          var objectArg = arg;
+          var cssProp = getCssProperty(objectArg);
+          if (!cssProp) {
+            return;
+          }
+          context.report({
+            node: node,
+            messageId: 'noCssPropInObjectSpread',
+            fix: function fix(fixer) {
+              var sourceCode = getSourceCode(context);
+              var cssValueText = sourceCode.getText(cssProp.value);
+              var remainingProps = objectArg.properties.filter(function (p) {
+                return p !== cssProp;
+              });
+              var directCssProp = "css={".concat(cssValueText, "}");
+              if (remainingProps.length === 0) {
+                return fixer.replaceText(node, directCssProp);
+              }
+              var remainingText = remainingProps.map(function (p) {
+                return sourceCode.getText(p);
+              }).join(', ');
+              return fixer.replaceText(node, "".concat(directCssProp, " {...{ ").concat(remainingText, " }}"));
+            }
+          });
+          return;
+        }
+
+        // Case 2: variable reference — <div {...props} />
+        if (arg.type === 'Identifier') {
+          var scope = getScope(context, arg);
+          var currentScope = scope;
+          var variable = null;
+          while (currentScope) {
+            var found = currentScope.variables.find(function (v) {
+              return v.name === arg.name;
+            });
+            if (found) {
+              variable = found;
+              break;
+            }
+            currentScope = currentScope.upper;
+          }
+          if (!variable || variable.defs.length === 0) {
+            return;
+          }
+          var def = variable.defs[0];
+          if (def.type !== 'Variable' || !def.node.init || def.node.init.type !== 'ObjectExpression') {
+            return;
+          }
+          var initObject = def.node.init;
+          var _cssProp = getCssProperty(initObject);
+          if (!_cssProp) {
+            return;
+          }
+
+          // Only auto-fix when there is exactly one JSX spread site for this variable
+          var spreadCount = variable.references.filter(function (ref) {
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            var refParent = ref.identifier.parent;
+            return (refParent === null || refParent === void 0 ? void 0 : refParent.type) === 'JSXSpreadAttribute';
+          }).length;
+          context.report(_objectSpread({
+            node: node,
+            messageId: 'noCssPropInObjectSpread'
+          }, spreadCount === 1 ? {
+            fix: function fix(fixer) {
+              var sourceCode = getSourceCode(context);
+              var cssValueText = sourceCode.getText(_cssProp.value);
+              var fixes = [];
+              var remainingProps = initObject.properties.filter(function (p) {
+                return p !== _cssProp;
+              });
+              if (remainingProps.length === 0) {
+                fixes.push(fixer.replaceText(initObject, '{}'));
+              } else {
+                var propIndex = initObject.properties.indexOf(_cssProp);
+                var isLast = propIndex === initObject.properties.length - 1;
+                var tokenBefore = sourceCode.getTokenBefore(_cssProp);
+                var tokenAfter = sourceCode.getTokenAfter(_cssProp);
+                if (!isLast && tokenAfter && tokenAfter.value === ',') {
+                  var src = sourceCode.getText();
+                  var afterEnd = tokenAfter.range[1];
+                  var 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={".concat(cssValueText, "} ")));
+              return fixes;
+            }
+          } : {}));
+        }
+      }
+    };
+  }
+};
+export default noCssPropInObjectSpread;