@atlaskit/eslint-plugin-design-system 4.6.0 → 4.7.2

package/CHANGELOG.md

@@ -1,5 +1,25 @@
 # @atlaskit/eslint-plugin-design-system
 
+## 4.7.2
+
+### Patch Changes
+
+- [`9f64ab9d5ea`](https://bitbucket.org/atlassian/atlassian-frontend/commits/9f64ab9d5ea) - Improvements / added robustness to edge cases previously unhandled.
+- [`8e848e3a4a6`](https://bitbucket.org/atlassian/atlassian-frontend/commits/8e848e3a4a6) - Internal updates to a number of rules. Introduced a custom formatter for the rule 'no-raw-spacing-values'.
+- [`31494c13aaa`](https://bitbucket.org/atlassian/atlassian-frontend/commits/31494c13aaa) - Type fixes to the internals of a number of rules.
+
+## 4.7.1
+
+### Patch Changes
+
+- [`37ac5652977`](https://bitbucket.org/atlassian/atlassian-frontend/commits/37ac5652977) - Mark `isOpen` and `innerRef` props on @atlaskit/banner as deprecated.
+
+## 4.7.0
+
+### Minor Changes
+
+- [`740057653f9`](https://bitbucket.org/atlassian/atlassian-frontend/commits/740057653f9) - Adds additional rule to restrict usage of banned imports from the design system.
+
 ## 4.6.0
 
 ### Minor Changes

package/dist/cjs/index.js

@@ -11,12 +11,16 @@ var _ensureDesignTokenUsage = _interopRequireDefault(require("./rules/ensure-des
 
 var _iconLabel = _interopRequireDefault(require("./rules/icon-label"));
 
+var _noBannedImports = _interopRequireDefault(require("./rules/no-banned-imports"));
+
 var _noDeprecatedApis = _interopRequireDefault(require("./rules/no-deprecated-apis"));
 
 var _noDeprecatedDesignTokenUsage = _interopRequireDefault(require("./rules/no-deprecated-design-token-usage"));
 
 var _noDeprecatedImports = _interopRequireDefault(require("./rules/no-deprecated-imports"));
 
+var _noRawSpacingValues = _interopRequireDefault(require("./rules/no-raw-spacing-values"));
+
 var _noUnsafeDesignTokenUsage = _interopRequireDefault(require("./rules/no-unsafe-design-token-usage"));
 
 var _useVisuallyHidden = _interopRequireDefault(require("./rules/use-visually-hidden"));
@@ -27,8 +31,10 @@ var rules = {
   'no-deprecated-apis': _noDeprecatedApis.default,
   'no-deprecated-design-token-usage': _noDeprecatedDesignTokenUsage.default,
   'no-deprecated-imports': _noDeprecatedImports.default,
+  'no-banned-imports': _noBannedImports.default,
   'no-unsafe-design-token-usage': _noUnsafeDesignTokenUsage.default,
-  'use-visually-hidden': _useVisuallyHidden.default
+  'use-visually-hidden': _useVisuallyHidden.default,
+  'no-raw-spacing-values': _noRawSpacingValues.default
 };
 exports.rules = rules;
 var configs = {
@@ -38,7 +44,20 @@ var configs = {
       '@atlaskit/design-system/icon-label': 'warn',
       '@atlaskit/design-system/no-deprecated-apis': 'warn',
       '@atlaskit/design-system/no-deprecated-imports': 'error',
-      '@atlaskit/design-system/use-visually-hidden': 'error'
+      '@atlaskit/design-system/use-visually-hidden': 'error',
+      '@atlaskit/design-system/no-banned-imports': 'error'
+    }
+  },
+  all: {
+    plugins: ['@atlaskit/design-system'],
+    rules: {
+      '@atlaskit/design-system/icon-label': 'error',
+      '@atlaskit/design-system/no-deprecated-apis': 'error',
+      '@atlaskit/design-system/no-deprecated-imports': 'error',
+      '@atlaskit/design-system/use-visually-hidden': 'error',
+      '@atlaskit/design-system/ensure-design-token-usage': 'error',
+      '@atlaskit/design-system/no-banned-imports': 'error',
+      '@atlaskit/design-system/no-raw-spacing-values': 'error'
     }
   }
 };

package/dist/cjs/rules/ensure-design-token-usage/index.js

@@ -45,7 +45,6 @@ var filterSuggestion = function filterSuggestion(_ref) {
 var rule = {
   meta: {
     // We need to upgrade the version of ESLint.
-    // @ts-expect-error
     hasSuggestions: true,
     docs: {
       recommended: true

package/dist/cjs/rules/icon-label/index.js

@@ -5,6 +5,8 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.default = void 0;
 
+var _eslintCodemodUtils = require("eslint-codemod-utils");
+
 var _jsx = require("../utils/jsx");
 
 var elements = ['AkButton', 'AKButton', 'Button', 'MenuItem', 'ButtonItem', 'CustomItem', 'CustomThemeButton', 'LoadingButton', 'BreadcrumbsItem'];
@@ -59,7 +61,11 @@ var rule = {
 
         return JSXElement;
       }(function (node) {
-        if (node.openingElement.name.type !== 'JSXIdentifier') {
+        if (!(0, _eslintCodemodUtils.isNodeOfType)(node, 'JSXElement')) {
+          return;
+        }
+
+        if (!(0, _eslintCodemodUtils.isNodeOfType)(node.openingElement.name, 'JSXIdentifier')) {
           return;
         }
 

package/dist/cjs/rules/no-banned-imports/index.js

@@ -0,0 +1,56 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _eslintCodemodUtils = require("eslint-codemod-utils");
+
+var _paths = require("./paths");
+
+var rule = {
+  meta: {
+    type: 'problem',
+    docs: {
+      description: 'Disallow specified modules when loaded by `import`',
+      recommended: true
+    },
+    messages: {
+      path: "The '{{importSource}}' import is restricted from being used. {{customMessage}}"
+    }
+  },
+  create: function create(context) {
+    function checkNode(node) {
+      if ((0, _eslintCodemodUtils.isNodeOfType)(node, 'ExportAllDeclaration') || (0, _eslintCodemodUtils.isNodeOfType)(node, 'ExportNamedDeclaration') || (0, _eslintCodemodUtils.isNodeOfType)(node, 'ImportDeclaration')) {
+        _paths.restrictedPaths.find(function (_ref) {
+          var _node$source, _node$source$value;
+
+          var path = _ref.path,
+              message = _ref.message;
+          var source = (_node$source = node.source) === null || _node$source === void 0 ? void 0 : (_node$source$value = _node$source.value) === null || _node$source$value === void 0 ? void 0 : _node$source$value.toString();
+
+          if (source && (source === path || source.startsWith(path))) {
+            context.report({
+              node: node,
+              messageId: 'path',
+              data: {
+                importSource: source,
+                customMessage: message
+              }
+            });
+          }
+        });
+      }
+    }
+
+    return {
+      ImportDeclaration: checkNode,
+      ExportAllDeclaration: checkNode,
+      ExportNamedDeclaration: checkNode,
+      ExportDefaultDeclaration: checkNode
+    };
+  }
+};
+var _default = rule;
+exports.default = _default;

package/dist/cjs/rules/no-banned-imports/paths.js

@@ -0,0 +1,14 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.restrictedPaths = void 0;
+var restrictedPaths = [{
+  path: '@atlaskit/ds-lib',
+  message: "The '@atlaskit/ds-lib' library has been designed as a utility library for internal usage. It should not be consumed directly."
+}, {
+  path: '@atlaskit/ds-explorations',
+  message: "The @atlaskit/ds-explorations package is currently in an experimental state and should not be consumed directly."
+}];
+exports.restrictedPaths = restrictedPaths;

package/dist/cjs/rules/no-deprecated-apis/index.js

@@ -11,9 +11,11 @@ var _getImportNodeBySource = require("../utils/get-import-node-by-source");
 
 var unsafeOverridesConfig = {
   cssFn: ['@atlaskit/menu', '@atlaskit/side-navigation'],
-  overrides: ['@atlaskit/drawer', '@atlaskit/menu', '@atlaskit/side-navigation']
+  overrides: ['@atlaskit/drawer', '@atlaskit/menu', '@atlaskit/side-navigation'],
+  innerRef: ['@atlaskit/banner'],
+  isOpen: ['@atlaskit/banner']
 };
-var unsafeOverrides = ['cssFn', 'overrides'];
+var unsafeOverrides = ['cssFn', 'overrides', 'innerRef', 'isOpen'];
 var rule = {
   meta: {
     type: 'suggestion',
@@ -28,19 +30,13 @@ var rule = {
   create: function create(context) {
     return {
       // find JSX atribute - find name of attribute - get source and find relevant identifiers.
-      JSXAttribute: function (_JSXAttribute) {
-        function JSXAttribute(_x) {
-          return _JSXAttribute.apply(this, arguments);
-        }
-
-        JSXAttribute.toString = function () {
-          return _JSXAttribute.toString();
-        };
-
-        return JSXAttribute;
-      }(function (node) {
+      JSXAttribute: function JSXAttribute(node) {
         var _node$name;
 
+        if (!(0, _eslintCodemodUtils.isNodeOfType)(node, 'JSXAttribute')) {
+          return;
+        }
+
         if (!unsafeOverrides.includes(node === null || node === void 0 ? void 0 : (_node$name = node.name) === null || _node$name === void 0 ? void 0 : _node$name.name)) {
           return;
         }
@@ -81,7 +77,7 @@ var rule = {
             }
           });
         });
-      })
+      }
     };
   }
 };

package/dist/cjs/rules/no-raw-spacing-values/index.js

@@ -0,0 +1,135 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));
+
+var _eslintCodemodUtils = require("eslint-codemod-utils");
+
+var _utils = require("./utils");
+
+var rule = {
+  meta: {
+    type: 'problem',
+    docs: {
+      description: 'No raw spacing values',
+      recommended: true
+    },
+    messages: {
+      noRawSpacingValues: 'Prefer the use of spacing primitives over the direct application of spacing properties.\n\n@meta <<{{payload}}>>'
+    }
+  },
+  create: function create(context) {
+    return {
+      // CSSObjectExpression
+      // const styles = css({ color: 'red', margin: '4px' })
+      'CallExpression[callee.name=css] > ObjectExpression': function CallExpressionCalleeNameCssObjectExpression(parentNode) {
+        if (!(0, _eslintCodemodUtils.isNodeOfType)(parentNode, 'ObjectExpression')) {
+          return;
+        }
+        /**
+         * We do this in case we the fontSize for a style object is declared alongside the `em` or `lineHeight` declaration
+         */
+
+
+        var fontSizeNode = parentNode.properties.find(function (node) {
+          if (!(0, _eslintCodemodUtils.isNodeOfType)(node, 'Property')) {
+            return;
+          }
+
+          if (!(0, _eslintCodemodUtils.isNodeOfType)(node.key, 'Identifier')) {
+            return;
+          }
+
+          return node.key.name === 'fontSize';
+        });
+        var fontSizeValue = (0, _utils.getValue)( // @ts-ignore
+        (fontSizeNode === null || fontSizeNode === void 0 ? void 0 : fontSizeNode.type) === 'Property' && fontSizeNode.value, context);
+        var fontSize = Array.isArray(fontSizeValue) ? fontSizeValue[0] : fontSizeValue;
+        parentNode.properties.forEach(function (node) {
+          if (!(0, _eslintCodemodUtils.isNodeOfType)(node, 'Property')) {
+            return;
+          }
+
+          if (!(0, _eslintCodemodUtils.isNodeOfType)(node.key, 'Identifier')) {
+            return;
+          }
+
+          if (!(0, _utils.isSpacingProperty)(node.key.name)) {
+            return;
+          }
+
+          var value = (0, _utils.getValue)(node.value, context);
+
+          if (value) {
+            var values = typeof value === 'number' || typeof value === 'string' ? [value] : value;
+            values.forEach(function (value) {
+              context.report({
+                node: node,
+                messageId: 'noRawSpacingValues',
+                data: {
+                  payload: "".concat(node.key.name, ":").concat((0, _utils.emToPixels)(value, fontSize))
+                }
+              });
+            });
+            return;
+          } else {
+            context.report({
+              node: node,
+              messageId: 'noRawSpacingValues',
+              data: {
+                payload: "".concat(node.key.name, ":NaN")
+              }
+            });
+          }
+        });
+      },
+      // CSSTemplateLiteral and StyledTemplateLiteral
+      // const cssTemplateLiteral = css`color: red; padding: 12px`;
+      // const styledTemplateLiteral = styled.p`color: red; padding: 8px`;
+      'TaggedTemplateExpression[tag.name="css"],TaggedTemplateExpression[tag.object.name="styled"]': function TaggedTemplateExpressionTagNameCssTaggedTemplateExpressionTagObjectNameStyled(node) {
+        if (node.type !== 'TaggedTemplateExpression') {
+          return;
+        }
+
+        var combinedString = node.quasi.quasis.map(function (q, i) {
+          return "".concat(q.value.raw).concat(node.quasi.expressions[i] ? (0, _utils.getValue)(node.quasi.expressions[i], context) : '');
+        }).join('');
+        /**
+         * Attempts to remove all non-essential words & characters from a style block.
+         * Including selectors and queries
+         * Adapted from ensure-design-token-usage
+         */
+
+        var cssProperties = combinedString.replace(/\n/g, '').split(/;|{|}/).map(function (el) {
+          return el.trim() || '';
+        });
+        cssProperties.map(function (style) {
+          var _style$split = style.split(':'),
+              _style$split2 = (0, _slicedToArray2.default)(_style$split, 2),
+              property = _style$split2[0],
+              value = _style$split2[1];
+
+          if ((0, _utils.isSpacingProperty)(property)) {
+            context.report({
+              node: node,
+              messageId: 'noRawSpacingValues',
+              data: {
+                payload: "".concat(property, ":").concat((0, _utils.removePixelSuffix)(value.trim()))
+              }
+            });
+          }
+
+          return;
+        });
+      }
+    };
+  }
+};
+var _default = rule;
+exports.default = _default;

package/dist/cjs/rules/no-raw-spacing-values/utils.js

@@ -0,0 +1,223 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.emToPixels = void 0;
+exports.findIdentifierInParentScope = findIdentifierInParentScope;
+exports.removePixelSuffix = exports.isSpacingProperty = exports.getValueFromShorthand = exports.getValue = void 0;
+
+var _eslintCodemodUtils = require("eslint-codemod-utils");
+
+var properties = ['padding', 'paddingLeft', 'paddingTop', 'paddingRight', 'paddingBottom', 'marginLeft', 'marginTop', 'marginRight', 'marginBottom', 'margin', 'gap', 'fontSize', 'lineHeight', 'width', 'height'];
+
+function findIdentifierInParentScope(_ref) {
+  var scope = _ref.scope,
+      identifierName = _ref.identifierName;
+  var traversingScope = scope;
+
+  while (traversingScope && traversingScope.type !== 'global') {
+    var matchedVariable = traversingScope.variables.find(function (variable) {
+      return variable.name === identifierName;
+    });
+
+    if (matchedVariable) {
+      return matchedVariable;
+    }
+
+    traversingScope = traversingScope.upper;
+  }
+
+  return null;
+}
+
+var isSpacingProperty = function isSpacingProperty(prop) {
+  return properties.includes(prop);
+};
+
+exports.isSpacingProperty = isSpacingProperty;
+
+var getValueFromShorthand = function getValueFromShorthand(str) {
+  // If we want to filter out NaN just add .filter(Boolean)
+  return String(str).trim().split(' ').map(removePixelSuffix);
+};
+
+exports.getValueFromShorthand = getValueFromShorthand;
+
+var isGridSize = function isGridSize(node) {
+  return (0, _eslintCodemodUtils.isNodeOfType)(node, 'CallExpression') && (0, _eslintCodemodUtils.isNodeOfType)(node.callee, 'Identifier') && (node.callee.name === 'gridSize' || node.callee.name === 'getGridSize');
+};
+
+var isFontSize = function isFontSize(node) {
+  return (0, _eslintCodemodUtils.isNodeOfType)(node, 'CallExpression') && (0, _eslintCodemodUtils.isNodeOfType)(node.callee, 'Identifier') && (node.callee.name === 'fontSize' || node.callee.name === 'getFontSize');
+};
+
+var isFontSizeSmall = function isFontSizeSmall(node) {
+  return (0, _eslintCodemodUtils.isNodeOfType)(node, 'CallExpression') && (0, _eslintCodemodUtils.isNodeOfType)(node.callee, 'Identifier') && node.callee.name === 'fontSizeSmall';
+};
+
+var getValueFromCallExpression = function getValueFromCallExpression(node, context) {
+  if (!(0, _eslintCodemodUtils.isNodeOfType)(node, 'CallExpression')) {
+    return null;
+  }
+
+  if (isGridSize(node)) {
+    return 8;
+  }
+
+  if (isFontSize(node)) {
+    return 14;
+  }
+
+  if (isFontSizeSmall(node)) {
+    return 11;
+  }
+
+  return null;
+};
+
+var getValue = function getValue(node, context) {
+  if ((0, _eslintCodemodUtils.isNodeOfType)(node, 'Literal')) {
+    return getValueFromShorthand(node.value);
+  }
+
+  if ((0, _eslintCodemodUtils.isNodeOfType)(node, 'BinaryExpression')) {
+    return getValueFromBinaryExpression(node, context);
+  }
+
+  if ((0, _eslintCodemodUtils.isNodeOfType)(node, 'UnaryExpression')) {
+    return getValueFromUnaryExpression(node, context);
+  }
+
+  if ((0, _eslintCodemodUtils.isNodeOfType)(node, 'CallExpression')) {
+    return getValueFromCallExpression(node, context);
+  }
+
+  if ((0, _eslintCodemodUtils.isNodeOfType)(node, 'Identifier')) {
+    return getValueFromIdentifier(node, context);
+  }
+
+  if ((0, _eslintCodemodUtils.isNodeOfType)(node, 'TemplateLiteral')) {
+    return getValueFromTemplateLiteral(node, context);
+  }
+
+  return null;
+};
+
+exports.getValue = getValue;
+
+var getValueFromIdentifier = function getValueFromIdentifier(node, context) {
+  if (!(0, _eslintCodemodUtils.isNodeOfType)(node, 'Identifier')) {
+    return null;
+  }
+
+  var scope = context.getScope();
+  var variable = findIdentifierInParentScope({
+    scope: scope,
+    identifierName: node.name
+  });
+
+  if (!variable) {
+    return null;
+  }
+
+  var definition = variable.defs[0];
+
+  if (!(0, _eslintCodemodUtils.isNodeOfType)(definition.node, 'VariableDeclarator')) {
+    return null;
+  }
+
+  if (!definition.node.init) {
+    return null;
+  }
+
+  return getValue(definition.node.init, context);
+};
+
+var getValueFromUnaryExpression = function getValueFromUnaryExpression(node, context) {
+  if (!(0, _eslintCodemodUtils.isNodeOfType)(node, 'UnaryExpression')) {
+    return null;
+  }
+
+  var value = getValue(node.argument, context);
+
+  if (!value) {
+    return null;
+  } // eslint-disable-next-line no-eval
+
+
+  return eval("".concat(node.operator).concat(value));
+};
+/**
+ * @example
+ * ```js
+ * `2 ${variable} 0`
+ *
+ * // results in [2, NaN, 0]
+ * ```
+ * ```js
+ * const variable = 4;
+ * `2 ${variable} 0`
+ *
+ * // results in [2, 4, 0]
+ * ```
+ */
+
+
+var getValueFromTemplateLiteral = function getValueFromTemplateLiteral(node, context) {
+  if (!(0, _eslintCodemodUtils.isNodeOfType)(node, "TemplateLiteral")) {
+    return null;
+  }
+
+  var combinedString = node.quasis.map(function (q, i) {
+    return "".concat(q.value.raw).concat(node.expressions[i] ? getValue(node.expressions[i], context) : '');
+  }).join('').trim().split(' ');
+  return combinedString.map(removePixelSuffix);
+};
+
+var getValueFromBinaryExpression = function getValueFromBinaryExpression(node, context) {
+  if (!(0, _eslintCodemodUtils.isNodeOfType)(node, 'BinaryExpression')) {
+    return null;
+  }
+
+  var left = node.left,
+      right = node.right,
+      operator = node.operator;
+  var leftValue = getValue(left, context);
+  var rightValue = getValue(right, context);
+  var final = rightValue && leftValue ? // eslint-disable-next-line no-eval
+  eval("".concat(leftValue).concat(operator).concat(rightValue)) : null;
+  return final;
+};
+
+var emRegex = /(.*\d+)em$/;
+
+var emToPixels = function emToPixels(value, fontSize) {
+  if (typeof value === 'string') {
+    var match = value.match(emRegex);
+
+    if (match && typeof fontSize === 'number') {
+      return Number(match[1]) * fontSize;
+    }
+
+    return 'NaN';
+  }
+
+  return value;
+};
+
+exports.emToPixels = emToPixels;
+var percentageOrEm = /(%$)|(\d+em$)/;
+
+var removePixelSuffix = function removePixelSuffix(value) {
+  var isString = typeof value === 'string'; // @ts-ignore This shouldn't be a type error but CI is complaining
+
+  if (isString && percentageOrEm.test(value)) {
+    return value;
+  } // @ts-ignore This shouldn't be a type error but CI is complaining
+
+
+  return Number(isString ? value.replace('px', '') : value);
+};
+
+exports.removePixelSuffix = removePixelSuffix;

package/dist/cjs/rules/use-visually-hidden/utils.js

@@ -4,7 +4,9 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.makeTemplateLiteralIntoEntries = exports.getObjectLikeness = exports.getFirstImport = exports.countMatchingKeyValues = void 0;
-// eslint-disable-next-line import/no-unresolved
+
+var _eslintCodemodUtils = require("eslint-codemod-utils");
+
 // eslint-disable-next-line @atlaskit/design-system/use-visually-hidden
 var referenceObject = {
   width: '1px',
@@ -53,12 +55,13 @@ var makeTemplateLiteralIntoEntries = function makeTemplateLiteralIntoEntries(tem
 exports.makeTemplateLiteralIntoEntries = makeTemplateLiteralIntoEntries;
 
 var getObjectLikeness = function getObjectLikeness(node) {
-  var styleEntries = node.properties.map(function (_ref) {
-    var type = _ref.type,
-        key = _ref.key,
+  var styleEntries = node.properties.filter(function (node) {
+    return (0, _eslintCodemodUtils.isNodeOfType)(node, 'Property');
+  }).map(function (_ref) {
+    var key = _ref.key,
         value = _ref.value;
 
-    if (type === 'Property' && key.type === 'Identifier') {
+    if (key.type === 'Identifier') {
       return {
         key: key.name,
         value: value.type === 'Literal' && value.value

package/dist/cjs/version.json

@@ -1,5 +1,5 @@
 {
 	"name": "@atlaskit/eslint-plugin-design-system",
-	"version": "4.6.0",
+	"version": "4.7.2",
 	"sideEffects": false
 }

package/dist/es2019/index.js

@@ -1,8 +1,10 @@
 import ensureTokenUsage from './rules/ensure-design-token-usage';
 import iconLabel from './rules/icon-label';
+import noBannedImports from './rules/no-banned-imports';
 import noDeprecatedAPIs from './rules/no-deprecated-apis';
 import noDeprecatedUsage from './rules/no-deprecated-design-token-usage';
 import noDeprecatedImports from './rules/no-deprecated-imports';
+import noRawSpacingValues from './rules/no-raw-spacing-values';
 import noUnsafeUsage from './rules/no-unsafe-design-token-usage';
 import useVisuallyHidden from './rules/use-visually-hidden';
 export const rules = {
@@ -11,8 +13,10 @@ export const rules = {
   'no-deprecated-apis': noDeprecatedAPIs,
   'no-deprecated-design-token-usage': noDeprecatedUsage,
   'no-deprecated-imports': noDeprecatedImports,
+  'no-banned-imports': noBannedImports,
   'no-unsafe-design-token-usage': noUnsafeUsage,
-  'use-visually-hidden': useVisuallyHidden
+  'use-visually-hidden': useVisuallyHidden,
+  'no-raw-spacing-values': noRawSpacingValues
 };
 export const configs = {
   recommended: {
@@ -21,7 +25,20 @@ export const configs = {
       '@atlaskit/design-system/icon-label': 'warn',
       '@atlaskit/design-system/no-deprecated-apis': 'warn',
       '@atlaskit/design-system/no-deprecated-imports': 'error',
-      '@atlaskit/design-system/use-visually-hidden': 'error'
+      '@atlaskit/design-system/use-visually-hidden': 'error',
+      '@atlaskit/design-system/no-banned-imports': 'error'
+    }
+  },
+  all: {
+    plugins: ['@atlaskit/design-system'],
+    rules: {
+      '@atlaskit/design-system/icon-label': 'error',
+      '@atlaskit/design-system/no-deprecated-apis': 'error',
+      '@atlaskit/design-system/no-deprecated-imports': 'error',
+      '@atlaskit/design-system/use-visually-hidden': 'error',
+      '@atlaskit/design-system/ensure-design-token-usage': 'error',
+      '@atlaskit/design-system/no-banned-imports': 'error',
+      '@atlaskit/design-system/no-raw-spacing-values': 'error'
     }
   }
 };

package/dist/es2019/rules/ensure-design-token-usage/index.js

@@ -25,7 +25,6 @@ const filterSuggestion = ({
 const rule = {
   meta: {
     // We need to upgrade the version of ESLint.
-    // @ts-expect-error
     hasSuggestions: true,
     docs: {
       recommended: true