@atlaskit/eslint-plugin-design-system 8.25.2 → 8.27.0

package/dist/cjs/rules/utils/is-supported-import.js

@@ -1,9 +1,11 @@
 "use strict";
 
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.isCxFunction = exports.isCss = exports.CSS_IN_JS_IMPORTS = void 0;
+exports.isStyled = exports.isKeyframes = exports.isCxFunction = exports.isCssMap = exports.isCss = exports.getImportSources = exports.DEFAULT_IMPORT_SOURCES = exports.CSS_IN_JS_IMPORTS = void 0;
+var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
 // eslint-disable-next-line import/no-extraneous-dependencies
 
 var CSS_IN_JS_IMPORTS = exports.CSS_IN_JS_IMPORTS = {
@@ -11,35 +13,69 @@ var CSS_IN_JS_IMPORTS = exports.CSS_IN_JS_IMPORTS = {
   emotionReact: '@emotion/react',
   emotionCore: '@emotion/core',
   styledComponents: 'styled-components',
-  atlaskitCss: '@atlaskit/css'
+  atlaskitCss: '@atlaskit/css',
+  atlaskitPrimitives: '@atlaskit/primitives'
 };
 
-// List of CSS-in-JS libraries an import of a valid css, cx, cssMap, etc.
+// A CSS-in-JS library an import of a valid css, cx, cssMap, etc.
 // function might originate from, e.g. @compiled/react, @emotion/core.
 
+// All ESLint rules originating from `@compiled/eslint-plugin` should apply to these libraries.
+var DEFAULT_IMPORT_SOURCES = exports.DEFAULT_IMPORT_SOURCES = [CSS_IN_JS_IMPORTS.compiled, CSS_IN_JS_IMPORTS.atlaskitCss];
+
+/**
+ * Given the ESLint rule context, extract and parse the value of the importSources rule option.
+ * The importSources option is used to define additional libraries for which an ESLint rule
+ * should apply to.
+ *
+ * Note that `@compiled/react` and `@atlaskit/css` are always included in importSources, regardless
+ * of what importSources is configured to by the user.
+ *
+ * @param context The rule context.
+ * @returns An array of strings representing what CSS-in-JS packages that should be checked, based
+ *          on the rule options configuration.
+ */
+var getImportSources = exports.getImportSources = function getImportSources(context) {
+  var options = context.options;
+  if (!options.length) {
+    return DEFAULT_IMPORT_SOURCES;
+  }
+  if (options[0].importSources && Array.isArray(options[0].importSources)) {
+    return [].concat(DEFAULT_IMPORT_SOURCES, (0, _toConsumableArray2.default)(options[0].importSources));
+  }
+  return DEFAULT_IMPORT_SOURCES;
+};
 var isSupportedImportWrapper = function isSupportedImportWrapper(functionName) {
-  // This will need to be extended to support default imports once we start
-  // checking cases like `import css from '@emotion/css'`
   var checkDefinitionHasImport = function checkDefinitionHasImport(def, importSources) {
-    var _def$parent, _def$parent2;
-    return def.node.type === 'ImportSpecifier' && def.node.imported.type === 'Identifier' && def.node.imported.name === functionName && ((_def$parent = def.parent) === null || _def$parent === void 0 ? void 0 : _def$parent.type) === 'ImportDeclaration' && importSources.includes((_def$parent2 = def.parent) === null || _def$parent2 === void 0 ? void 0 : _def$parent2.source.value);
+    if (def.type !== 'ImportBinding') {
+      return false;
+    }
+    if (!def.parent || !importSources.includes(def.parent.source.value)) {
+      return false;
+    }
+    return (
+      // import { functionName } from 'import-source';
+      def.node.type === 'ImportSpecifier' && def.node.imported.name === functionName ||
+      // import functionName from 'import-source';
+      def.node.type === 'ImportDefaultSpecifier' && def.node.local.name === functionName
+    );
   };
 
   /**
    * Checks whether:
    *
-   * 1. a function name `nodeToCheck` matches the name of the function we
+   * 1. A function name `nodeToCheck` matches the name of the function we
    *    want to check for (e.g. `cx`, `css`, `cssMap`, or `keyframes`), and
-   * 2. whether `nodeToCheck` originates from one of the libraries listed
+   * 2. Whether `nodeToCheck` originates from one of the libraries listed
    *     in `importSources`.
    *
-   * @param nodeToCheck the function callee we are checking (e.g. the `css` in `css()`)
-   * @param referencesInScope list of references that are in scope. We'll use this
+   * @param nodeToCheck The function callee we are checking (e.g. The `css` in `css()`).
+   * @param referencesInScope List of references that are in scope. We'll use this
    *                          to check where the function callee is imported from.
-   * @param importSources list of libraries that we want to ensure `nodeToCheck`
-   *                      comes from
+   * @param importSources List of libraries that we want to ensure `nodeToCheck`
+   *                      comes from.
    *
-   * @returns whether the above conditions are true
+   * @returns Whether the above conditions are true.
    */
   var isSupportedImport = function isSupportedImport(nodeToCheck, referencesInScope, importSources) {
     return nodeToCheck.type === 'Identifier' && referencesInScope.some(function (reference) {
@@ -57,5 +93,6 @@ var isSupportedImportWrapper = function isSupportedImportWrapper(functionName) {
 //
 var isCss = exports.isCss = isSupportedImportWrapper('css');
 var isCxFunction = exports.isCxFunction = isSupportedImportWrapper('cx');
-// export const isCssMap = isLibraryImportWrapper('cssMap');
-// export const isKeyframes = isLibraryImportWrapper('keyframes');
+var isCssMap = exports.isCssMap = isSupportedImportWrapper('cssMap');
+var isKeyframes = exports.isKeyframes = isSupportedImportWrapper('keyframes');
+var isStyled = exports.isStyled = isSupportedImportWrapper('styled');

package/dist/es2019/presets/all.codegen.js

@@ -1,6 +1,6 @@
 /**
  * THIS FILE WAS CREATED VIA CODEGEN DO NOT MODIFY {@see http://go/af-codegen}
- * @codegen <<SignedSource::5026ba2cb55b3c1bcacbfe7fb7728a6c>>
+ * @codegen <<SignedSource::914085544778f4543f43e3e30d0982e0>>
  * @codegenCommand yarn workspace @atlaskit/eslint-plugin-design-system codegen
  */
 export default {
@@ -16,6 +16,10 @@ export default {
     '@atlaskit/design-system/no-deprecated-apis': 'error',
     '@atlaskit/design-system/no-deprecated-design-token-usage': 'warn',
     '@atlaskit/design-system/no-deprecated-imports': 'error',
+    '@atlaskit/design-system/no-empty-styled-expression': 'warn',
+    '@atlaskit/design-system/no-exported-css': 'warn',
+    '@atlaskit/design-system/no-exported-keyframes': 'warn',
+    '@atlaskit/design-system/no-invalid-css-map': 'error',
     '@atlaskit/design-system/no-margin': 'warn',
     '@atlaskit/design-system/no-nested-styles': 'error',
     '@atlaskit/design-system/no-physical-properties': 'error',

package/dist/es2019/presets/recommended.codegen.js

@@ -1,6 +1,6 @@
 /**
  * THIS FILE WAS CREATED VIA CODEGEN DO NOT MODIFY {@see http://go/af-codegen}
- * @codegen <<SignedSource::839224bfab98c1ddf6018dec5320968e>>
+ * @codegen <<SignedSource::577269c832952ce359cde6a50f26f4e0>>
  * @codegenCommand yarn workspace @atlaskit/eslint-plugin-design-system codegen
  */
 export default {
@@ -14,6 +14,10 @@ export default {
     '@atlaskit/design-system/no-deprecated-apis': 'error',
     '@atlaskit/design-system/no-deprecated-design-token-usage': 'warn',
     '@atlaskit/design-system/no-deprecated-imports': 'error',
+    '@atlaskit/design-system/no-empty-styled-expression': 'warn',
+    '@atlaskit/design-system/no-exported-css': 'warn',
+    '@atlaskit/design-system/no-exported-keyframes': 'warn',
+    '@atlaskit/design-system/no-invalid-css-map': 'error',
     '@atlaskit/design-system/no-nested-styles': 'error',
     '@atlaskit/design-system/no-unsafe-design-token-usage': 'error',
     '@atlaskit/design-system/no-unsafe-style-overrides': 'warn',

package/dist/es2019/rules/consistent-css-prop-usage/index.js

@@ -1,18 +1,23 @@
 // eslint-disable-next-line import/no-extraneous-dependencies
 
-import { getIdentifierInParentScope, isNodeOfType } from 'eslint-codemod-utils';
+import { getIdentifierInParentScope, insertAtStartOfFile, insertImportDeclaration, isNodeOfType } from 'eslint-codemod-utils';
+import estraverse from 'estraverse';
 import assign from 'lodash/assign';
+import { Import } from '../../ast-nodes';
 import { createLintRule } from '../utils/create-rule';
-// File-level tracking of styles hoisted from the cssOnTopOfModule/cssAtBottomOfModule fixers
+import { getFirstSupportedImport } from '../utils/get-first-supported-import';
+import { getModuleOfIdentifier } from '../utils/get-import-node-by-source';
+import { CSS_IN_JS_IMPORTS } from '../utils/is-supported-import';
+// File-level tracking of styles hoisted from the cssAtTopOfModule/cssAtBottomOfModule fixers
 let hoistedCss = [];
+const isDOMElementName = elementName => elementName.charAt(0) !== elementName.charAt(0).toUpperCase() && elementName.charAt(0) === elementName.charAt(0).toLowerCase();
 function isCssCallExpression(node, cssFunctions) {
   cssFunctions = [...cssFunctions, 'cssMap'];
   return !!(isNodeOfType(node, 'CallExpression') && node.callee && node.callee.type === 'Identifier' && cssFunctions.includes(node.callee.name) && node.arguments.length && node.arguments[0].type === 'ObjectExpression');
 }
 function findSpreadProperties(node) {
-  // @ts-ignore
   return node.properties.filter(property => property.type === 'SpreadElement' ||
-  // @ts-ignore
+  // @ts-expect-error
   property.type === 'ExperimentalSpreadProperty');
 }
 const getProgramNode = expression => {
@@ -22,9 +27,8 @@ const getProgramNode = expression => {
   return expression.parent;
 };
 
-// TODO: This can be optimised by implementing a fixer at the very end (Program:exit) and handling all validations at once
 /**
- * Generates the declarator string when fixing the cssOnTopOfModule/cssAtBottomOfModule cases.
+ * Generates the declarator string when fixing the cssAtTopOfModule/cssAtBottomOfModule cases.
  * When `styles` already exists, `styles_1, styles_2, ..., styles_X` are incrementally created for each unhoisted style.
  * The generated `styles` varibale declaration names must be manually modified to be more informative at the discretion of owning teams.
  */
@@ -54,7 +58,7 @@ const getDeclaratorString = context => {
   hoistedCss = [...hoistedCss, `${declaratorName}${count}`];
   return `${declaratorName}${count}`;
 };
-function analyzeIdentifier(context, sourceIdentifier, configuration) {
+function analyzeIdentifier(context, sourceIdentifier, configuration, cssAttributeName) {
   var _getIdentifierInParen, _getIdentifierInParen2;
   const scope = context.getScope();
   const [identifier] = (_getIdentifierInParen = (_getIdentifierInParen2 = getIdentifierInParentScope(scope, sourceIdentifier.name)) === null || _getIdentifierInParen2 === void 0 ? void 0 : _getIdentifierInParen2.identifiers) !== null && _getIdentifierInParen !== void 0 ? _getIdentifierInParen : [];
@@ -74,8 +78,11 @@ function analyzeIdentifier(context, sourceIdentifier, configuration) {
     // When variable is declared inside the component
     context.report({
       node: sourceIdentifier,
-      messageId: configuration.stylesPlacement === 'bottom' ? 'cssAtBottomOfModule' : 'cssOnTopOfModule',
+      messageId: configuration.stylesPlacement === 'bottom' ? 'cssAtBottomOfModule' : 'cssAtTopOfModule',
       fix: fixer => {
+        if (configuration.fixNamesOnly) {
+          return [];
+        }
         return fixCssNotInModuleScope(fixer, context, configuration, identifier);
       }
     });
@@ -83,10 +90,30 @@ function analyzeIdentifier(context, sourceIdentifier, configuration) {
   }
   if (identifier.parent && identifier.parent.init && !isCssCallExpression(identifier.parent.init, configuration.cssFunctions)) {
     // When variable value is not of type css({})
-    context.report({
-      node: identifier,
-      messageId: 'cssObjectTypeOnly'
-    });
+    const value = identifier.parent.init;
+    if (!value) {
+      return;
+    }
+    const valueExpression =
+    // @ts-expect-error remove once eslint types are switched to @typescript-eslint
+    value.type === 'TSAsExpression' ? value.expression : value;
+    if (['ObjectExpression', 'TemplateLiteral'].includes(valueExpression.type)) {
+      context.report({
+        node: identifier,
+        messageId: 'cssObjectTypeOnly',
+        fix: fixer => {
+          if (configuration.fixNamesOnly) {
+            return [];
+          }
+          return addCssFunctionCall(fixer, context, identifier.parent, configuration, cssAttributeName);
+        }
+      });
+    } else {
+      context.report({
+        node: identifier,
+        messageId: 'cssObjectTypeOnly'
+      });
+    }
     return;
   }
   const spreadProperties = isNodeOfType(identifier.parent.init, 'CallExpression') && findSpreadProperties(identifier.parent.init.arguments[0]);
@@ -102,12 +129,131 @@ function analyzeIdentifier(context, sourceIdentifier, configuration) {
 }
 
 /**
- * Fixer for the cssOnTopOfModule/cssAtBottomOfModule violation cases.
+ * Returns a fixer that adds `import { css } from 'import-source'` or
+ * `import { xcss } from 'import-source'` to the start of the file, depending
+ * on the value of cssAttributeName and importSource.
+ */
+const addImportSource = (context, fixer, configuration, cssAttributeName) => {
+  const importSource = cssAttributeName === 'xcss' ? configuration.xcssImportSource : configuration.cssImportSource;
+
+  // Add the `import { css } from 'my-css-in-js-library';` statement
+  const packageImport = getFirstSupportedImport(context, [importSource]);
+  if (packageImport) {
+    const addCssImport = Import.insertNamedSpecifiers(packageImport, [cssAttributeName], fixer);
+    if (addCssImport) {
+      return addCssImport;
+    }
+  } else {
+    return insertAtStartOfFile(fixer, `${insertImportDeclaration(importSource, [cssAttributeName])};\n`);
+  }
+};
+
+/**
+ * Returns a list of fixes that:
+ * - add the `css` or `xcss` function call around the current node.
+ * - add an import statement for the package from which `css` is imported
+ */
+const addCssFunctionCall = (fixer, context, node, configuration, cssAttributeName) => {
+  const fixes = [];
+  const sourceCode = context.getSourceCode();
+  if (node.type !== 'VariableDeclarator' || !node.init || !cssAttributeName) {
+    return [];
+  }
+  const compiledImportFix = addImportSource(context, fixer, configuration, cssAttributeName);
+  if (compiledImportFix) {
+    fixes.push(compiledImportFix);
+  }
+  const init = node.init;
+  const initString = sourceCode.getText(init);
+  if (node.init.type === 'TemplateLiteral') {
+    fixes.push(fixer.replaceText(init, `${cssAttributeName}${initString}`));
+  } else {
+    fixes.push(fixer.replaceText(init, `${cssAttributeName}(${initString})`));
+  }
+  return fixes;
+};
+
+/**
+ * Check if the expression has or potentially has a local variable
+ * (as opposed to an imported one), erring on the side ot "yes"
+ * when an expression is too complicated to analyse.
+ *
+ * This is useful because expressions containing local variables
+ * cannot be easily hoisted, whereas this is not a problem with imported
+ * variables.
+ *
+ * @param context Context of the rule.
+ * @param node Any node that is potentially hoistable.
+ * @returns Whether the node potentially has a local variable (and thus is not safe to hoist).
+ */
+const potentiallyHasLocalVariable = (context, node) => {
+  let hasPotentiallyLocalVariable = false;
+  const isImportedVariable = identifier => !!getModuleOfIdentifier(context.getSourceCode(), identifier);
+  estraverse.traverse(node, {
+    enter: function (node, _parent) {
+      if (isNodeOfType(node, 'SpreadElement') ||
+      // @ts-expect-error remove once we can be sure that no parser interprets
+      // the spread operator as ExperimentalSpreadProperty anymore
+      isNodeOfType(node, 'ExperimentalSpreadProperty')) {
+        // Spread elements could contain anything... so we don't bother.
+        //
+        // e.g. <div css={css({ ...(!height && { visibility: 'hidden' })} />
+        hasPotentiallyLocalVariable = true;
+        this.break();
+      }
+      if (!isNodeOfType(node, 'Property')) {
+        return;
+      }
+      switch (node.value.type) {
+        case 'Literal':
+          break;
+        case 'Identifier':
+          // e.g. css({ margin: myVariable })
+          if (!isImportedVariable(node.value.name)) {
+            hasPotentiallyLocalVariable = true;
+          }
+          this.break();
+          break;
+        case 'MemberExpression':
+          // e.g. css({ margin: props.color })
+          //      css({ margin: props.media.color })
+          if (node.value.object.type === 'Identifier' && isImportedVariable(node.value.object.name)) {
+            // We found an imported variable, don't do anything.
+          } else {
+            // e.g. css({ margin: [some complicated expression].media.color })
+            // This can potentially get too complex, so we assume there's a local
+            // variable in there somewhere.
+            hasPotentiallyLocalVariable = true;
+          }
+          this.break();
+          break;
+        case 'TemplateLiteral':
+          if (!!node.value.expressions.length) {
+            // Too many edge cases here, don't bother...
+            // e.g. css({ animation: `${expandStyles(right, rightExpanded, isExpanded)} 0.2s ease-in-out` });
+            hasPotentiallyLocalVariable = true;
+            this.break();
+          }
+          break;
+        default:
+          // Catch-all for values such as "A && B", "A ? B : C"
+          hasPotentiallyLocalVariable = true;
+          this.break();
+          break;
+      }
+    }
+  });
+  return hasPotentiallyLocalVariable;
+};
+
+/**
+ * Fixer for the cssAtTopOfModule/cssAtBottomOfModule violation cases.
  * This deals with Identifiers and Expressions passed from the traverseExpressionWithConfig() function.
+ *
  * @param fixer The ESLint RuleFixer object
- * @param context The context of the node
+ * @param context The context of the rule
  * @param configuration The configuration of the rule, determining whether the fix is implmeneted at the top or bottom of the module
- * @param node Either an IdentifierWithParent node. Expression, or SpreadElement that we handle
+ * @param node Any potentially hoistable node, or an identifier.
  * @param cssAttributeName An optional parameter only added when we fix an ObjectExpression
  */
 const fixCssNotInModuleScope = (fixer, context, configuration, node, cssAttributeName) => {
@@ -124,35 +270,42 @@ const fixCssNotInModuleScope = (fixer, context, configuration, node, cssAttribut
     fixerNodePlacement = programNode.body.length === 1 ? programNode.body[0] : programNode.body.find(node => node.type !== 'ImportDeclaration');
   }
   let moduleString;
-  let implementFixer = [];
+  let fixes = [];
   if (node.type === 'Identifier') {
     const identifier = node;
     const declarator = identifier.parent.parent;
     moduleString = sourceCode.getText(declarator);
-    implementFixer.push(fixer.remove(declarator));
+    fixes.push(fixer.remove(declarator));
   } else {
+    if (potentiallyHasLocalVariable(context, node)) {
+      return [];
+    }
     const declarator = getDeclaratorString(context);
     const text = sourceCode.getText(node);
 
     // If this has been passed, then we know it's an ObjectExpression
     if (cssAttributeName) {
       moduleString = `const ${declarator} = ${cssAttributeName}(${text});`;
+      const compiledImportFix = addImportSource(context, fixer, configuration, cssAttributeName);
+      if (compiledImportFix) {
+        fixes.push(compiledImportFix);
+      }
     } else {
-      moduleString = moduleString = `const ${declarator} = ${text};`;
+      moduleString = `const ${declarator} = ${text};`;
     }
-    implementFixer.push(fixer.replaceText(node, declarator));
+    fixes.push(fixer.replaceText(node, declarator));
   }
-  return [...implementFixer,
-  // Insert the node either before or after
+  return [...fixes,
+  // Insert the node either before or after, depending on the rule configuration
   configuration.stylesPlacement === 'bottom' ? fixer.insertTextAfter(fixerNodePlacement, '\n' + moduleString) : fixer.insertTextBefore(fixerNodePlacement, moduleString + '\n')];
 };
 
 /**
  * Handle different cases based on what's been passed in the css-related JSXAttribute
- * @param context the context of the node
+ * @param context the context of the rule
  * @param expression the expression of the JSXAttribute value
  * @param configuration what css-related functions to account for (eg. css, xcss, cssMap), and whether to detect bottom vs top expressions
- * @param cssAttributeName used to encapsulate ObjectExpressions when cssOnTopOfModule/cssAtBottomOfModule violations are triggered
+ * @param cssAttributeName used to encapsulate ObjectExpressions when cssAtTopOfModule/cssAtBottomOfModule violations are triggered
  */
 const traverseExpressionWithConfig = (context, expression, configuration, cssAttributeName) => {
   function traverseExpression(expression) {
@@ -160,7 +313,7 @@ const traverseExpressionWithConfig = (context, expression, configuration, cssAtt
       case 'Identifier':
         // {styles}
         // We've found an identifier - time to analyze it!
-        analyzeIdentifier(context, expression, configuration);
+        analyzeIdentifier(context, expression, configuration, cssAttributeName);
         break;
       case 'ArrayExpression':
         // {[styles, moreStyles]}
@@ -187,8 +340,12 @@ const traverseExpressionWithConfig = (context, expression, configuration, cssAtt
         // We've found elements that shouldn't be here! Report an error.
         context.report({
           node: expression,
-          messageId: configuration.stylesPlacement === 'bottom' ? 'cssAtBottomOfModule' : 'cssOnTopOfModule',
+          messageId: configuration.stylesPlacement === 'bottom' ? 'cssAtBottomOfModule' : 'cssAtTopOfModule',
           fix: fixer => {
+            if (configuration.fixNamesOnly) {
+              return [];
+            }
+
             // Don't fix CallExpressions unless they're from cssFunctions or cssMap
             if (expression.type === 'CallExpression' && !isCssCallExpression(expression, configuration.cssFunctions)) {
               return [];
@@ -200,6 +357,17 @@ const traverseExpressionWithConfig = (context, expression, configuration, cssAtt
           }
         });
         break;
+
+      // @ts-expect-error - our ESLint-related types assume vanilla JS, when in fact
+      // it is running @typescript-eslint
+      //
+      // Switching to the more accurate @typescript-eslint types would break
+      // eslint-codemod-utils and all ESLint rules in packages/design-system,
+      // so we just leave this as-is.
+      case 'TSAsExpression':
+        // @ts-expect-error
+        traverseExpression(expression.expression);
+        break;
       default:
         // Do nothing!
         break;
@@ -209,10 +377,15 @@ const traverseExpressionWithConfig = (context, expression, configuration, cssAtt
 };
 const defaultConfig = {
   cssFunctions: ['css', 'xcss'],
-  stylesPlacement: 'top'
+  stylesPlacement: 'top',
+  cssImportSource: CSS_IN_JS_IMPORTS.compiled,
+  xcssImportSource: CSS_IN_JS_IMPORTS.atlaskitPrimitives,
+  excludeReactComponents: false,
+  fixNamesOnly: false
 };
 const rule = createLintRule({
   meta: {
+    type: 'problem',
     name: 'consistent-css-prop-usage',
     docs: {
       description: 'Ensures consistency with `css` and `xcss` prop usages',
@@ -222,13 +395,42 @@ const rule = createLintRule({
     },
     fixable: 'code',
     messages: {
-      cssOnTopOfModule: `Create styles at the top of the module scope using the respective css function.`,
+      cssAtTopOfModule: `Create styles at the top of the module scope using the respective css function.`,
       cssAtBottomOfModule: `Create styles at the bottom of the module scope using the respective css function.`,
-      cssObjectTypeOnly: `Create styles using objects passed to the css function.`,
-      cssInModule: `Imported styles should not be used, instead define in the module, import a component, or use a design token.`,
+      cssObjectTypeOnly: `Create styles using objects passed to a css function call, e.g. \`css({ textAlign: 'center'; })\`.`,
+      cssInModule: `Imported styles should not be used; instead define in the module, import a component, or use a design token.`,
       cssArrayStylesOnly: `Compose styles with an array on the css prop instead of using object spread.`,
+      noMemberExpressions: `Styles should be a regular variable (e.g. 'buttonStyles'), not a member of an object (e.g. 'myObject.styles').`,
       shouldEndInStyles: 'Declared styles should end in "styles".'
-    }
+    },
+    schema: [{
+      type: 'object',
+      properties: {
+        cssFunctions: {
+          type: 'array',
+          items: [{
+            type: 'string'
+          }]
+        },
+        stylesPlacement: {
+          type: 'string',
+          enum: ['top', 'bottom']
+        },
+        cssImportSource: {
+          type: 'string'
+        },
+        xcssImportSource: {
+          type: 'string'
+        },
+        excludeReactComponents: {
+          type: 'boolean'
+        },
+        fixNamesOnly: {
+          type: 'boolean'
+        }
+      },
+      additionalProperties: false
+    }]
   },
   create(context) {
     const mergedConfig = assign({}, defaultConfig, context.options[0]);
@@ -265,11 +467,22 @@ const rule = createLintRule({
           }
         });
       },
-      JSXAttribute(node) {
+      JSXAttribute(nodeOriginal) {
+        const node = nodeOriginal;
         const {
           name,
           value
         } = node;
+        if (mergedConfig.excludeReactComponents && node.parent.type === 'JSXOpeningElement') {
+          // e.g. <item.before />
+          if (node.parent.name.type === 'JSXMemberExpression') {
+            return;
+          }
+          // e.g. <div />, <MenuItem />
+          if (node.parent.name.type === 'JSXIdentifier' && !isDOMElementName(node.parent.name.name)) {
+            return;
+          }
+        }
 
         // Always reset to empty array
         hoistedCss = [];
@@ -277,11 +490,16 @@ const rule = createLintRule({
           // When not a jsx expression. For eg. css=""
           if ((value === null || value === void 0 ? void 0 : value.type) !== 'JSXExpressionContainer') {
             context.report({
-              node: value,
-              messageId: mergedConfig.stylesPlacement === 'bottom' ? 'cssAtBottomOfModule' : 'cssOnTopOfModule'
+              node,
+              messageId: mergedConfig.stylesPlacement === 'bottom' ? 'cssAtBottomOfModule' : 'cssAtTopOfModule'
             });
             return;
           }
+          if (value.expression.type === 'JSXEmptyExpression') {
+            // e.g. the comment in
+            //      <div css={/* Hello there */} />
+            return;
+          }
           traverseExpressionWithConfig(context, value.expression, mergedConfig, name.name);
         }
       }

package/dist/es2019/rules/index.codegen.js

@@ -1,6 +1,6 @@
 /**
  * THIS FILE WAS CREATED VIA CODEGEN DO NOT MODIFY {@see http://go/af-codegen}
- * @codegen <<SignedSource::a67afc33adf50db651edb1cf12e16ef3>>
+ * @codegen <<SignedSource::0a2d88c9772eb438048415f13550f592>>
  * @codegenCommand yarn workspace @atlaskit/eslint-plugin-design-system codegen
  */
 import consistentCssPropUsage from './consistent-css-prop-usage';
@@ -13,6 +13,10 @@ import noCssTaggedTemplateExpression from './no-css-tagged-template-expression';
 import noDeprecatedApis from './no-deprecated-apis';
 import noDeprecatedDesignTokenUsage from './no-deprecated-design-token-usage';
 import noDeprecatedImports from './no-deprecated-imports';
+import noEmptyStyledExpression from './no-empty-styled-expression';
+import noExportedCss from './no-exported-css';
+import noExportedKeyframes from './no-exported-keyframes';
+import noInvalidCssMap from './no-invalid-css-map';
 import noMargin from './no-margin';
 import noNestedStyles from './no-nested-styles';
 import noPhysicalProperties from './no-physical-properties';
@@ -37,6 +41,10 @@ export default {
   'no-deprecated-apis': noDeprecatedApis,
   'no-deprecated-design-token-usage': noDeprecatedDesignTokenUsage,
   'no-deprecated-imports': noDeprecatedImports,
+  'no-empty-styled-expression': noEmptyStyledExpression,
+  'no-exported-css': noExportedCss,
+  'no-exported-keyframes': noExportedKeyframes,
+  'no-invalid-css-map': noInvalidCssMap,
   'no-margin': noMargin,
   'no-nested-styles': noNestedStyles,
   'no-physical-properties': noPhysicalProperties,

package/dist/es2019/rules/no-empty-styled-expression/index.js

@@ -0,0 +1,65 @@
+import { createLintRule } from '../utils/create-rule';
+import { getImportSources, isStyled } from '../utils/is-supported-import';
+const isEmptyStyledExpression = node => {
+  const [firstArg] = node.arguments;
+  if (node.arguments.length === 0) {
+    return true;
+  } else if (node.arguments.length === 1 && (firstArg === null || firstArg === void 0 ? void 0 : firstArg.type) === 'ArrayExpression') {
+    return firstArg.elements.length === 0;
+  } else if (node.arguments.length === 1 && (firstArg === null || firstArg === void 0 ? void 0 : firstArg.type) === 'ObjectExpression') {
+    return firstArg.properties.length === 0;
+  }
+  return false;
+};
+const createNoEmptyStyledExpressionRule = (isEmptyStyledExpression, messageId) => context => {
+  const importSources = getImportSources(context);
+  return {
+    'CallExpression[callee.type="MemberExpression"]': node => {
+      const {
+        references
+      } = context.getScope();
+
+      // If we have styled.div(...), make sure `callee` only refers to the
+      // `styled` part instead of the whole `styled.div` expression.
+      const callee = node.callee.type === 'MemberExpression' ? node.callee.object : node.callee;
+      if (!isStyled(callee, references, importSources)) {
+        return;
+      }
+      if (!isEmptyStyledExpression(node)) {
+        return;
+      }
+      context.report({
+        messageId,
+        node
+      });
+    }
+  };
+};
+const noEmptyStyledExpressionRule = createLintRule({
+  meta: {
+    name: 'no-empty-styled-expression',
+    docs: {
+      description: 'Forbids any styled expression to be used when passing empty arguments to styled.div() (or other JSX elements).',
+      recommended: true,
+      severity: 'warn'
+    },
+    messages: {
+      unexpected: 'Found an empty expression, or empty object argument passed to `styled` function call. This unnecessarily causes a major performance penalty - please use a plain JSX element or a React fragment instead (e.g. `<div>Hello</div>` or `<>Hello</>`).'
+    },
+    type: 'problem',
+    schema: [{
+      type: 'object',
+      properties: {
+        importSources: {
+          type: 'array',
+          items: [{
+            type: 'string'
+          }]
+        }
+      },
+      additionalProperties: false
+    }]
+  },
+  create: createNoEmptyStyledExpressionRule(isEmptyStyledExpression, 'unexpected')
+});
+export default noEmptyStyledExpressionRule;