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

package/dist/esm/rules/no-invalid-css-map/utils.js

@@ -0,0 +1,186 @@
+import _slicedToArray from "@babel/runtime/helpers/slicedToArray";
+import _classCallCheck from "@babel/runtime/helpers/classCallCheck";
+import _createClass from "@babel/runtime/helpers/createClass";
+function _createForOfIteratorHelper(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, 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 normalCompletion = true, didErr = false, err; return { s: function s() { it = it.call(o); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it.return != null) it.return(); } finally { if (didErr) throw err; } } }; }
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; return arr2; }
+export var getCssMapObject = function getCssMapObject(node) {
+  // We assume the argument `node` is already a cssMap() call.
+
+  // Things like the number of arguments to cssMap and the type of
+  // cssMap's argument are handled by the TypeScript compiler, so
+  // we don't bother with creating eslint errors for these here
+
+  if (node.arguments.length !== 1 || node.arguments[0].type !== 'ObjectExpression') {
+    return;
+  }
+  return node.arguments[0];
+};
+var findNodeReference = function findNodeReference(references, node) {
+  return references.find(function (reference) {
+    return reference.identifier === node;
+  });
+};
+var getAllowedFunctionCalls = function getAllowedFunctionCalls(options) {
+  var _options$;
+  if (options.length === 0 || ((_options$ = options[0]) === null || _options$ === void 0 ? void 0 : _options$.allowedFunctionCalls) === undefined) {
+    return [];
+  }
+
+  // Beyond the basic check of "does allowedFunctionCalls exist?",
+  // we assume ESLint's rule checker type checks the contents of allowedFunctionCalls
+  // as it should
+  return options[0].allowedFunctionCalls;
+};
+export var CssMapObjectChecker = /*#__PURE__*/function () {
+  function CssMapObjectChecker(cssMapObject, context) {
+    _classCallCheck(this, CssMapObjectChecker);
+    this.allowedFunctionCalls = getAllowedFunctionCalls(context.options);
+    this.cssMapObject = cssMapObject;
+    this.report = context.report;
+    this.references = context.getScope().references;
+  }
+  _createClass(CssMapObjectChecker, [{
+    key: "isNotWhitelistedFunction",
+    value: function isNotWhitelistedFunction(callee) {
+      var _reference$resolved,
+        _this = this;
+      if (callee.type !== 'Identifier' || this.allowedFunctionCalls.length === 0) {
+        return true;
+      }
+      var reference = findNodeReference(this.references, callee);
+      var definitions = reference === null || reference === void 0 || (_reference$resolved = reference.resolved) === null || _reference$resolved === void 0 ? void 0 : _reference$resolved.defs;
+      if (!definitions) {
+        return true;
+      }
+      return definitions.some(function (definition) {
+        // We add some restrictions to keep this simple...
+        // Forbid non-imported functions
+        if (definition.type !== 'ImportBinding') {
+          return true;
+        }
+        // Forbid default imports (e.g. `import React from 'react'`)
+        if (definition.node.type !== 'ImportSpecifier') {
+          return true;
+        }
+        var packageName = definition.parent.source.value;
+        var importedFunctionName = definition.node.imported.name;
+        return !_this.allowedFunctionCalls.some(function (_ref) {
+          var _ref2 = _slicedToArray(_ref, 2),
+            allowedPackageName = _ref2[0],
+            allowedFunctionName = _ref2[1];
+          return allowedPackageName === packageName && allowedFunctionName === importedFunctionName;
+        });
+      });
+    }
+  }, {
+    key: "checkCssMapObjectValue",
+    value: function checkCssMapObjectValue(value) {
+      if (value.type === 'CallExpression' && this.isNotWhitelistedFunction(value.callee)) {
+        // object value is a function call in the style
+        // {
+        //     key: functionCall(), ...
+        // }
+        this.report({
+          node: value,
+          messageId: 'noFunctionCalls'
+        });
+      } else if (value.type === 'ArrowFunctionExpression' || value.type === 'FunctionExpression') {
+        // object value is a function call in the style
+        // {
+        //     key: (prop) => prop.color,       // ArrowFunctionExpression
+        //     get danger() { return { ... } }, // FunctionExpression
+        // }
+        this.report({
+          node: value,
+          messageId: 'noInlineFunctions'
+        });
+      } else if (value.type === 'BinaryExpression' || value.type === 'LogicalExpression') {
+        this.checkCssMapObjectValue(value.left);
+        this.checkCssMapObjectValue(value.right);
+      } else if (value.type === 'Identifier') {
+        var _reference$resolved2;
+        var reference = findNodeReference(this.references, value);
+
+        // Get the variable's definition when initialised. Assume that the last definition
+        // is the most recent one.
+        //
+        // Ideally we would try to get the variable's value at the point at which
+        // cssMap() is run, but ESLint doesn't seem to give us an easy way to
+        // do that...
+        var definitions = reference === null || reference === void 0 || (_reference$resolved2 = reference.resolved) === null || _reference$resolved2 === void 0 ? void 0 : _reference$resolved2.defs;
+        if (!definitions || definitions.length === 0) {
+          // Variable is not defined :thinking:
+          return;
+        }
+        var _iterator = _createForOfIteratorHelper(definitions),
+          _step;
+        try {
+          for (_iterator.s(); !(_step = _iterator.n()).done;) {
+            var definition = _step.value;
+            if (definition.type === 'Variable' && definition.node.init) {
+              return this.checkCssMapObjectValue(definition.node.init);
+            }
+          }
+        } catch (err) {
+          _iterator.e(err);
+        } finally {
+          _iterator.f();
+        }
+      } else if (value.type === 'ObjectExpression') {
+        // Object inside another object
+        this.checkCssMapObject(value);
+      } else if (value.type === 'TemplateLiteral') {
+        // object value is a template literal, something like
+        //     `hello world`
+        //     `hello ${functionCall()} world`
+        //     `hello ${someVariable} world`
+        // etc.
+        //
+        // where the expressions are the parts enclosed within the
+        // ${ ... }
+        var _iterator2 = _createForOfIteratorHelper(value.expressions),
+          _step2;
+        try {
+          for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+            var expression = _step2.value;
+            this.checkCssMapObjectValue(expression);
+          }
+        } catch (err) {
+          _iterator2.e(err);
+        } finally {
+          _iterator2.f();
+        }
+      }
+    }
+  }, {
+    key: "checkCssMapObject",
+    value: function checkCssMapObject(cssMapObject) {
+      var _iterator3 = _createForOfIteratorHelper(cssMapObject.properties),
+        _step3;
+      try {
+        for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
+          var property = _step3.value;
+          if (property.type === 'SpreadElement') {
+            this.report({
+              node: property,
+              messageId: 'noSpreadElement'
+            });
+            continue;
+          }
+          this.checkCssMapObjectValue(property.value);
+        }
+      } catch (err) {
+        _iterator3.e(err);
+      } finally {
+        _iterator3.f();
+      }
+    }
+  }, {
+    key: "run",
+    value: function run() {
+      this.checkCssMapObject(this.cssMapObject);
+    }
+  }]);
+  return CssMapObjectChecker;
+}();

package/dist/esm/rules/utils/create-no-exported-rule/check-if-supported-export.js

@@ -0,0 +1,151 @@
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
+function _createForOfIteratorHelper(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, 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 normalCompletion = true, didErr = false, err; return { s: function s() { it = it.call(o); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it.return != null) it.return(); } finally { if (didErr) throw err; } } }; }
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; return arr2; }
+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; }
+import { isStyledComponent } from './is-styled-component';
+var getStack = function getStack(context, node) {
+  var _scope;
+  var _context$getSourceCod = context.getSourceCode(),
+    scopeManager = _context$getSourceCod.scopeManager;
+  var stack = {
+    nodes: [],
+    root: node
+  };
+  var scope;
+  for (var current = node; current.type !== 'Program'; current = current.parent) {
+    if (!scope) {
+      var currentScope = scopeManager.acquire(current);
+      if (currentScope) {
+        scope = currentScope;
+      }
+    }
+    switch (current.type) {
+      case 'ExportDefaultDeclaration':
+      case 'ExportNamedDeclaration':
+        stack.root = current;
+        break;
+      case 'VariableDeclarator':
+        stack.root = current;
+        break;
+      case 'ExportSpecifier':
+      case 'ObjectExpression':
+      case 'VariableDeclaration':
+        break;
+      default:
+        stack.nodes.unshift(current);
+    }
+  }
+  return _objectSpread(_objectSpread({}, stack), {}, {
+    scope: (_scope = scope) !== null && _scope !== void 0 ? _scope : context.getScope()
+  });
+};
+var matches = function matches(defs, refs) {
+  // When there are no defs, the definition is inlined. This must be a match as we know the refs contain the initial
+  // definition.
+  if (!defs.length) {
+    return true;
+  }
+
+  // When there are no refs, the reference refers to the entire definition and therefore must be a match.
+  if (!refs.length) {
+    return true;
+  }
+
+  // When both the references and definitions exist, they should match in length
+  if (defs.length !== refs.length) {
+    return false;
+  }
+  return defs.every(function (def, i) {
+    var ref = refs[i];
+    if (def.type === 'Property') {
+      // There is a match between the def and the ref when both names match:
+      //
+      // const fooDef = { bar: '' };
+      // const barRef = fooDef.bar
+      //
+      // There is no match when the ref property does not match the definition key name:
+      //
+      // const barRef = fooDef.notFound
+      return def.key.type === 'Identifier' && ref.type === 'MemberExpression' && ref.property.type === 'Identifier' && ref.property.name === def.key.name;
+    }
+
+    // Anything here is either unsupported or should not match...
+    return false;
+  });
+};
+export var checkIfSupportedExport = function checkIfSupportedExport(context, node, importSources) {
+  var _resolved$references;
+  var scope = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : context.getScope();
+  // Ignore any expression defined outside of the global or module scope as we have no way of statically analysing them
+  if (scope.type !== 'global' && scope.type !== 'module') {
+    return {
+      isExport: false
+    };
+  }
+  var _getStack = getStack(context, node.parent),
+    root = _getStack.root,
+    nodes = _getStack.nodes;
+  // Exporting a component with a css reference should be allowed
+  if (isStyledComponent(nodes, context, importSources)) {
+    return {
+      isExport: false
+    };
+  }
+  if (root.type === 'ExportDefaultDeclaration' || root.type === 'ExportNamedDeclaration') {
+    return {
+      isExport: true,
+      node: root
+    };
+  }
+  if (root.type !== 'VariableDeclarator') {
+    return {
+      isExport: false
+    };
+  }
+
+  // Find the reference to the variable declarator
+  var reference = scope.references.find(function (_ref) {
+    var identifier = _ref.identifier;
+    return identifier === root.id;
+  });
+  if (!reference) {
+    return {
+      isExport: false
+    };
+  }
+
+  // Iterate through all of the references to the resolved variable declarator node
+  var resolved = reference.resolved;
+  var _iterator = _createForOfIteratorHelper((_resolved$references = resolved === null || resolved === void 0 ? void 0 : resolved.references) !== null && _resolved$references !== void 0 ? _resolved$references : []),
+    _step;
+  try {
+    for (_iterator.s(); !(_step = _iterator.n()).done;) {
+      var identifier = _step.value.identifier;
+      // Skip references to the root, since it has already been processed above
+      if (identifier === root.id) {
+        continue;
+      }
+      var _getStack2 = getStack(context, identifier.parent),
+        refs = _getStack2.nodes,
+        nextScope = _getStack2.scope;
+
+      // Only validate the resolved reference if it accesses the definition node
+      if (matches(nodes, refs.reverse())) {
+        // Now validate the identifier reference as a definition
+        var validity = checkIfSupportedExport(context, identifier, importSources, nextScope);
+        if (validity.isExport) {
+          return validity;
+        }
+      }
+    }
+  } catch (err) {
+    _iterator.e(err);
+  } finally {
+    _iterator.f();
+  }
+  return {
+    isExport: false
+  };
+};

package/dist/esm/rules/utils/create-no-exported-rule/is-styled-component.js

@@ -0,0 +1,78 @@
+import { isNodeOfType } from 'eslint-codemod-utils';
+/**
+ * Given a list of node, find and return the callee of the first Compiled or styled-components `styled` function call found in the list.
+ *
+ * For example, given `styled.div({ ... })`, we return the node corresponding to the
+ * `styled.div` part. Alternatively, given `styled(button)(style)`, we return the `styled`
+ * part.
+ *
+ * @param nodes
+ * @returns The callee of the first `styled` function call found.
+ */
+var findNode = function findNode(nodes) {
+  var node = nodes.find(function (n) {
+    return n.type === 'TaggedTemplateExpression' || n.type === 'CallExpression';
+  });
+  if (!node) {
+    return;
+  }
+  if (node.type === 'CallExpression') {
+    // Eg. const Component = styled.button(style)
+    if (node.callee.type === 'MemberExpression') {
+      return node.callee;
+    }
+
+    // Eg. const Component = styled(button)(style)
+    if (node.callee.type === 'CallExpression' && node.callee.callee.type === 'Identifier') {
+      return node.callee.callee;
+    }
+  }
+
+  // Eg. const Component = styled.div`${styles}`;
+  if (node.type === 'TaggedTemplateExpression' && node.tag.type === 'MemberExpression') {
+    return node.tag;
+  }
+  return;
+};
+
+/**
+ * Given a rule, return the local name used to import the `styled` API. (for Compiled or styled-components).
+ *
+ * @param context Rule context.
+ * @returns The local name used to import the `styled` API.
+ */
+var getStyledImportSpecifierName = function getStyledImportSpecifierName(context, importSources) {
+  var _supportedImports$0$s;
+  var isSupportedImport = function isSupportedImport(node) {
+    return isNodeOfType(node, 'ImportDeclaration') && typeof node.source.value === 'string' && importSources.includes(node.source.value);
+  };
+  var source = context.getSourceCode();
+  var supportedImports = source.ast.body.filter(isSupportedImport);
+  return (_supportedImports$0$s = supportedImports[0].specifiers.find(function (spec) {
+    return spec.type === 'ImportSpecifier' && spec.imported.name === 'styled';
+  })) === null || _supportedImports$0$s === void 0 ? void 0 : _supportedImports$0$s.local.name;
+};
+
+/**
+ * Returns whether the node is a usage of the `styled` API in the libraries we support.
+ *
+ * @param nodes Nodes to check.
+ * @param context Rule context.
+ * @param importSources A list of libraries we support.
+ * @returns Whether the node is a usage of the `styled` API.
+ */
+export var isStyledComponent = function isStyledComponent(nodes, context, importSources) {
+  var node = findNode(nodes);
+  if (!node) {
+    return false;
+  }
+  var styledImportSpecifierName = getStyledImportSpecifierName(context, importSources);
+  if (styledImportSpecifierName) {
+    if (node.type === 'Identifier') {
+      return node.name === styledImportSpecifierName;
+    } else {
+      return node.object.type === 'Identifier' && node.object.name === styledImportSpecifierName;
+    }
+  }
+  return false;
+};

package/dist/esm/rules/utils/create-no-exported-rule/main.js

@@ -0,0 +1,60 @@
+import { getImportSources } from '../is-supported-import';
+import { checkIfSupportedExport } from './check-if-supported-export';
+/**
+ * Creates a new ESLint rule for banning exporting certain function calls, e.g.
+ * `css` and `keyframes`.
+ *
+ * Copied from the `utils/create-no-exported-rule/` folder in @compiled/eslint-plugin.
+ *
+ * Requires an importSources option defined on the rule, which is used to define additional
+ * packages which should be checked as part of this rule.
+ *
+ * @param isUsage A function that checks whether the current node matches the desired
+ *                function call to check.
+ * @param messageId The ESLint error message to use for lint violations.
+ * @returns An eslint rule.
+ */
+export var createNoExportedRule = function createNoExportedRule(isUsage, messageId) {
+  return function (context) {
+    var importSources = getImportSources(context);
+    var _context$getSourceCod = context.getSourceCode(),
+      text = _context$getSourceCod.text;
+    if (importSources.every(function (importSource) {
+      return !text.includes(importSource);
+    })) {
+      return {};
+    }
+    return {
+      CallExpression: function CallExpression(node) {
+        var _context$getScope = context.getScope(),
+          references = _context$getScope.references;
+        if (!isUsage(node.callee, references, importSources)) {
+          return;
+        }
+        var state = checkIfSupportedExport(context, node, importSources);
+        if (!state.isExport) {
+          return;
+        }
+        context.report({
+          messageId: messageId,
+          node: state.node
+        });
+      },
+      TaggedTemplateExpression: function TaggedTemplateExpression(node) {
+        var _context$getScope2 = context.getScope(),
+          references = _context$getScope2.references;
+        if (!isUsage(node.tag, references, importSources)) {
+          return;
+        }
+        var state = checkIfSupportedExport(context, node, importSources);
+        if (!state.isExport) {
+          return;
+        }
+        context.report({
+          messageId: messageId,
+          node: state.node
+        });
+      }
+    };
+  };
+};

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

@@ -1,3 +1,4 @@
+import _toConsumableArray from "@babel/runtime/helpers/toConsumableArray";
 // eslint-disable-next-line import/no-extraneous-dependencies
 
 export var CSS_IN_JS_IMPORTS = {
@@ -8,31 +9,64 @@ export var CSS_IN_JS_IMPORTS = {
   atlaskitCss: '@atlaskit/css'
 };
 
-// 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.
+export var 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.
+ */
+export var 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, _toConsumableArray(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) {
@@ -50,5 +84,6 @@ var isSupportedImportWrapper = function isSupportedImportWrapper(functionName) {
 //
 export var isCss = isSupportedImportWrapper('css');
 export var isCxFunction = isSupportedImportWrapper('cx');
-// export const isCssMap = isLibraryImportWrapper('cssMap');
-// export const isKeyframes = isLibraryImportWrapper('keyframes');
+export var isCssMap = isSupportedImportWrapper('cssMap');
+export var isKeyframes = isSupportedImportWrapper('keyframes');
+export var isStyled = isSupportedImportWrapper('styled');

package/dist/types/index.codegen.d.ts

@@ -13,6 +13,10 @@ export declare const configs: {
             '@atlaskit/design-system/no-deprecated-apis': string;
             '@atlaskit/design-system/no-deprecated-design-token-usage': string;
             '@atlaskit/design-system/no-deprecated-imports': string;
+            '@atlaskit/design-system/no-empty-styled-expression': string;
+            '@atlaskit/design-system/no-exported-css': string;
+            '@atlaskit/design-system/no-exported-keyframes': string;
+            '@atlaskit/design-system/no-invalid-css-map': string;
             '@atlaskit/design-system/no-margin': string;
             '@atlaskit/design-system/no-nested-styles': string;
             '@atlaskit/design-system/no-physical-properties': string;
@@ -39,6 +43,10 @@ export declare const configs: {
             '@atlaskit/design-system/no-deprecated-apis': string;
             '@atlaskit/design-system/no-deprecated-design-token-usage': string;
             '@atlaskit/design-system/no-deprecated-imports': string;
+            '@atlaskit/design-system/no-empty-styled-expression': string;
+            '@atlaskit/design-system/no-exported-css': string;
+            '@atlaskit/design-system/no-exported-keyframes': string;
+            '@atlaskit/design-system/no-invalid-css-map': string;
             '@atlaskit/design-system/no-nested-styles': string;
             '@atlaskit/design-system/no-unsafe-design-token-usage': string;
             '@atlaskit/design-system/no-unsafe-style-overrides': string;

package/dist/types/presets/all.codegen.d.ts

@@ -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
  */
 declare const _default: {
@@ -16,6 +16,10 @@ declare const _default: {
         '@atlaskit/design-system/no-deprecated-apis': string;
         '@atlaskit/design-system/no-deprecated-design-token-usage': string;
         '@atlaskit/design-system/no-deprecated-imports': string;
+        '@atlaskit/design-system/no-empty-styled-expression': string;
+        '@atlaskit/design-system/no-exported-css': string;
+        '@atlaskit/design-system/no-exported-keyframes': string;
+        '@atlaskit/design-system/no-invalid-css-map': string;
         '@atlaskit/design-system/no-margin': string;
         '@atlaskit/design-system/no-nested-styles': string;
         '@atlaskit/design-system/no-physical-properties': string;

package/dist/types/presets/recommended.codegen.d.ts

@@ -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
  */
 declare const _default: {
@@ -14,6 +14,10 @@ declare const _default: {
         '@atlaskit/design-system/no-deprecated-apis': string;
         '@atlaskit/design-system/no-deprecated-design-token-usage': string;
         '@atlaskit/design-system/no-deprecated-imports': string;
+        '@atlaskit/design-system/no-empty-styled-expression': string;
+        '@atlaskit/design-system/no-exported-css': string;
+        '@atlaskit/design-system/no-exported-keyframes': string;
+        '@atlaskit/design-system/no-invalid-css-map': string;
         '@atlaskit/design-system/no-nested-styles': string;
         '@atlaskit/design-system/no-unsafe-design-token-usage': string;
         '@atlaskit/design-system/no-unsafe-style-overrides': string;

package/dist/types/rules/index.codegen.d.ts

@@ -13,6 +13,10 @@ declare const _default: {
     'no-deprecated-imports': import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleModule<string, [{
         deprecatedConfig: import("./utils/types").DeprecatedConfig;
     }], import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleListener>;
+    'no-empty-styled-expression': import("eslint").Rule.RuleModule;
+    'no-exported-css': import("eslint").Rule.RuleModule;
+    'no-exported-keyframes': import("eslint").Rule.RuleModule;
+    'no-invalid-css-map': import("eslint").Rule.RuleModule;
     'no-margin': import("eslint").Rule.RuleModule;
     'no-nested-styles': import("eslint").Rule.RuleModule;
     'no-physical-properties': import("eslint").Rule.RuleModule;

package/dist/types/rules/no-empty-styled-expression/index.d.ts

@@ -0,0 +1,3 @@
+import type { Rule } from 'eslint';
+declare const noEmptyStyledExpressionRule: Rule.RuleModule;
+export default noEmptyStyledExpressionRule;

package/dist/types/rules/no-exported-css/index.d.ts

@@ -0,0 +1,3 @@
+import type { Rule } from 'eslint';
+declare const noExportedCssRule: Rule.RuleModule;
+export default noExportedCssRule;

package/dist/types/rules/no-exported-keyframes/index.d.ts

@@ -0,0 +1,3 @@
+import type { Rule } from 'eslint';
+declare const noExportedKeyframesRule: Rule.RuleModule;
+export default noExportedKeyframesRule;

package/dist/types/rules/no-invalid-css-map/index.d.ts

@@ -0,0 +1,3 @@
+import type { Rule } from 'eslint';
+declare const noInvalidCssMapRule: Rule.RuleModule;
+export default noInvalidCssMapRule;