@atlaskit/eslint-plugin-design-system 14.1.0 → 14.3.0

package/dist/esm/rules/no-html-text-input/node-types/supported.js

@@ -1,5 +1,5 @@
 import { isNodeOfType } from 'eslint-codemod-utils';
-import { JSXElement } from '../../../ast-nodes/jsx-element';
+import { JSXElementHelper as JSXElement } from '../../../ast-nodes/jsx-element-helper';
 var supportedElements = [{
   name: 'input',
   attributes: [{

package/dist/esm/rules/no-html-textarea/index.js

@@ -1,4 +1,4 @@
-import { createLintRule } from '../utils/create-rule';
+import { createLintRule } from '../utils/create-lint-rule';
 import { JSXElement as _JSXElement } from './node-types/jsx-element';
 import { StyledComponent } from './node-types/styled-component';
 var rule = createLintRule({

package/dist/esm/rules/no-html-textarea/node-types/jsx-element/index.js

@@ -2,7 +2,7 @@ function _createForOfIteratorHelper(r, e) { var t = "undefined" != typeof Symbol
 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 { getSourceCode } from '@atlaskit/eslint-utils/context-compat';
-import { JSXElement as JSXElementHelper } from '../../../../ast-nodes/jsx-element';
+import { JSXElementHelper } from '../../../../ast-nodes/jsx-element-helper';
 import { isSupportedForLint } from '../supported';
 function isImportDeclaration(node) {
   return node.type === 'ImportDeclaration';

package/dist/esm/rules/no-html-textarea/node-types/supported.js

@@ -1,5 +1,5 @@
 import { isNodeOfType } from 'eslint-codemod-utils';
-import { JSXElement } from '../../../ast-nodes/jsx-element';
+import { JSXElementHelper as JSXElement } from '../../../ast-nodes/jsx-element-helper';
 var supportedElements = [{
   name: 'textarea'
 }];

package/dist/esm/rules/no-icon-spacing-prop/index.js

@@ -1,5 +1,5 @@
 import { createIsFromImportSourceFor } from '../../common/is-from-import-source';
-import { createLintRule } from '../utils/create-rule';
+import { createLintRule } from '../utils/create-lint-rule';
 import { errorBoundary } from '../utils/error-boundary';
 import { getCssMapKey } from './get-css-map-key';
 import { getIconSize } from './get-icon-size';

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

@@ -1,7 +1,7 @@
 import { getScope, getSourceCode } from '@atlaskit/eslint-utils/context-compat';
 import { CSS_IN_JS_IMPORTS, isCssMap } from '@atlaskit/eslint-utils/is-supported-import';
+import { createLintRule } from '../utils/create-lint-rule';
 import { checkIfSupportedExport } from '../utils/create-no-exported-rule/check-if-supported-export';
-import { createLintRule } from '../utils/create-rule';
 import { getCssMapObject } from './get-css-map-object';
 import { CssMapObjectChecker } from './utils';
 var IMPORT_SOURCES = [CSS_IN_JS_IMPORTS.compiled, CSS_IN_JS_IMPORTS.atlaskitCss];

package/dist/esm/rules/no-keyframes-tagged-template-expression/index.js

@@ -1,6 +1,7 @@
 import { isKeyframes } from '@atlaskit/eslint-utils/is-supported-import';
-import { createNoTaggedTemplateExpressionRule, noTaggedTemplateExpressionRuleSchema } from '../utils/create-no-tagged-template-expression-rule';
-import { createLintRule } from '../utils/create-rule';
+import { createLintRule } from '../utils/create-lint-rule';
+import { createNoTaggedTemplateExpressionRule } from '../utils/create-no-tagged-template-expression-rule/create-no-tagged-template-expression-rule';
+import { noTaggedTemplateExpressionRuleSchema } from '../utils/create-no-tagged-template-expression-rule/no-tagged-template-expression-rule-schema';
 var rule = createLintRule({
   meta: {
     name: 'no-keyframes-tagged-template-expression',

package/dist/esm/rules/no-margin/index.js

@@ -1,5 +1,5 @@
 import { isNodeOfType } from 'eslint-codemod-utils';
-import { createLintRule } from '../utils/create-rule';
+import { createLintRule } from '../utils/create-lint-rule';
 var rule = createLintRule({
   meta: {
     name: 'no-margin',

package/dist/esm/rules/no-nested-styles/index.js

@@ -1,6 +1,6 @@
 import { isNodeOfType } from 'eslint-codemod-utils';
 import { getScope } from '@atlaskit/eslint-utils/context-compat';
-import { createLintRule } from '../utils/create-rule';
+import { createLintRule } from '../utils/create-lint-rule';
 import { findIdentifierInParentScope } from '../utils/find-in-parent';
 var allowedPrefix = [':', '&:'];
 var allowedResponsiveImports = ['@atlaskit/primitives/responsive', '@atlaskit/primitives'];

package/dist/esm/rules/no-physical-properties/index.js

@@ -1,5 +1,5 @@
 import { isNodeOfType } from 'eslint-codemod-utils';
-import { createLintRule } from '../utils/create-rule';
+import { createLintRule } from '../utils/create-lint-rule';
 import { physicalLogicalMap } from './physical-logical-map';
 var rule = createLintRule({
   meta: {

package/dist/esm/rules/no-placeholder/affected-atlaskit-packages.js

@@ -0,0 +1,6 @@
+export var AFFECTED_ATLASKIT_PACKAGES = {
+  '@atlaskit/datetime-picker': ['DatePicker', 'TimePicker', 'DateTimePicker'],
+  '@atlaskit/select': ['default', 'AsyncCreatableSelect', 'CheckboxSelect', 'CountrySelect', 'CreatableSelect', 'PopupSelect', 'RadioSelect'],
+  '@atlaskit/textarea': ['default'],
+  '@atlaskit/textfield': ['default']
+};

package/dist/esm/rules/no-placeholder/affected-html-elements.js

@@ -0,0 +1 @@
+export var AFFECTED_HTML_ELEMENTS = ['input', 'textarea'];

package/dist/esm/rules/no-placeholder/index.js

@@ -1,15 +1,10 @@
 import { isNodeOfType } from 'eslint-codemod-utils';
-import { JSXElement as _JSXElement } from '../../ast-nodes/jsx-element';
-import { createLintRule } from '../utils/create-rule';
-export var AFFECTED_HTML_ELEMENTS = ['input', 'textarea'];
-export var AFFECTED_ATLASKIT_PACKAGES = {
-  '@atlaskit/datetime-picker': ['DatePicker', 'TimePicker', 'DateTimePicker'],
-  '@atlaskit/select': ['default', 'AsyncCreatableSelect', 'CheckboxSelect', 'CountrySelect', 'CreatableSelect', 'PopupSelect', 'RadioSelect'],
-  '@atlaskit/textarea': ['default'],
-  '@atlaskit/textfield': ['default']
-};
-export var ATLASKIT_FORM_PACKAGE = '@atlaskit/form';
-export var ATLASKIT_FIELD_IMPORT = 'Field';
+import { JSXElementHelper as _JSXElement } from '../../ast-nodes/jsx-element-helper';
+import { createLintRule } from '../utils/create-lint-rule';
+import { AFFECTED_ATLASKIT_PACKAGES } from './affected-atlaskit-packages';
+import { AFFECTED_HTML_ELEMENTS } from './affected-html-elements';
+var ATLASKIT_FORM_PACKAGE = '@atlaskit/form';
+var ATLASKIT_FIELD_IMPORT = 'Field';
 var rule = createLintRule({
   meta: {
     name: 'no-placeholder',

package/dist/esm/rules/no-readonly-or-disabled-inputs/affected-atlaskit-packages.js

@@ -0,0 +1,4 @@
+export var AFFECTED_ATLASKIT_PACKAGES = {
+  '@atlaskit/textarea': ['default'],
+  '@atlaskit/textfield': ['default']
+};

package/dist/esm/rules/no-readonly-or-disabled-inputs/affected-html-elements.js

@@ -0,0 +1 @@
+export var AFFECTED_HTML_ELEMENTS = ['input', 'textarea'];

package/dist/esm/rules/no-readonly-or-disabled-inputs/index.js

@@ -1,21 +1,30 @@
+import _toConsumableArray from "@babel/runtime/helpers/toConsumableArray";
 import { isNodeOfType } from 'eslint-codemod-utils';
-import { JSXElement as _JSXElement } from '../../ast-nodes/jsx-element';
-import { createLintRule } from '../utils/create-rule';
-export var AFFECTED_HTML_ELEMENTS = ['input', 'textarea'];
-export var AFFECTED_ATLASKIT_PACKAGES = {
-  '@atlaskit/textarea': ['default'],
-  '@atlaskit/textfield': ['default']
+import { JSXElementHelper as _JSXElement } from '../../ast-nodes/jsx-element-helper';
+import { createLintRule } from '../utils/create-lint-rule';
+import { AFFECTED_ATLASKIT_PACKAGES } from './affected-atlaskit-packages';
+import { AFFECTED_HTML_ELEMENTS } from './affected-html-elements';
+import { UNWANTED_ATLASKIT_ATTRIBUTES } from './unwanted-atlaskit-attributes';
+import { UNWANTED_HTML_ATTRIBUTES } from './unwanted-html-attributes';
+var isUnwantedHTMLAtrribute = function isUnwantedHTMLAtrribute(s) {
+  var attrs = UNWANTED_HTML_ATTRIBUTES;
+  return attrs.includes(s);
+};
+var isUnwantedAtlaskitAtrribute = function isUnwantedAtlaskitAtrribute(s) {
+  var attrs = UNWANTED_ATLASKIT_ATTRIBUTES;
+  return attrs.includes(s);
+};
+var isUnwantedAttribute = function isUnwantedAttribute(s) {
+  return isUnwantedHTMLAtrribute(s) || isUnwantedAtlaskitAtrribute(s);
 };
-export var UNWANTED_HTML_ATTRIBUTES = ['disabled', 'readonly'];
-export var UNWANTED_ATLASKIT_ATTRIBUTES = ['isDisabled', 'isReadOnly'];
 var hasUnwantedAttributes = function hasUnwantedAttributes(node, type) {
-  var attrNames = type === 'html' ? UNWANTED_HTML_ATTRIBUTES : UNWANTED_ATLASKIT_ATTRIBUTES;
+  var attrNames = _toConsumableArray(type === 'html' ? UNWANTED_HTML_ATTRIBUTES : UNWANTED_ATLASKIT_ATTRIBUTES);
   var unwantedAttrs = node.openingElement.attributes.filter(function (attr) {
     return isNodeOfType(attr, 'JSXAttribute');
   }).map(function (attr) {
     return String(attr.name.name);
-  }).filter(function (attrName) {
-    return attrNames.includes(attrName);
+  }).filter(isUnwantedAttribute).filter(function (unwantedAttribute) {
+    return attrNames.includes(unwantedAttribute);
   });
   return unwantedAttrs;
 };
@@ -62,7 +71,6 @@ var rule = createLintRule({
         });
         if (usesDefaultImport && defaultImport.length && defaultImport[0].local) {
           localComponentNames.push(defaultImport[0].local.name);
-          // or if popup and using a named import
         } else if (possibleNamedImports.length >= 1 && namedImport.length) {
           namedImport.forEach(function (imp) {
             if (imp.type === 'ImportSpecifier' && 'name' in imp.imported && possibleNamedImports.includes(imp.imported.name)) {
@@ -79,20 +87,22 @@ var rule = createLintRule({
         if (!elName) {
           return false;
         }
+        var fixes = [];
 
         // If it is one of the affected native HTML elements
         if (AFFECTED_HTML_ELEMENTS.includes(elName)) {
           var unwantedAttributes = hasUnwantedAttributes(node, 'html');
           if (unwantedAttributes.includes('disabled')) {
-            return context.report({
+            fixes.push(context.report({
               node: node.openingElement,
               messageId: 'noDisabled'
-            });
-          } else if (unwantedAttributes.includes('readonly')) {
-            return context.report({
+            }));
+          }
+          if (unwantedAttributes.includes('readonly')) {
+            fixes.push(context.report({
               node: node.openingElement,
               messageId: 'noReadOnly'
-            });
+            }));
           }
           // Else, it is a React component
         } else {
@@ -106,17 +116,19 @@ var rule = createLintRule({
           }
           var _unwantedAttributes = hasUnwantedAttributes(node, 'atlaskit');
           if (_unwantedAttributes.includes('isDisabled')) {
-            return context.report({
+            fixes.push(context.report({
               node: node.openingElement,
               messageId: 'noDisabled'
-            });
-          } else if (_unwantedAttributes.includes('isReadOnly')) {
-            return context.report({
+            }));
+          }
+          if (_unwantedAttributes.includes('isReadOnly')) {
+            fixes.push(context.report({
               node: node.openingElement,
               messageId: 'noReadOnly'
-            });
+            }));
           }
         }
+        return fixes;
       }
     };
   }

package/dist/esm/rules/no-readonly-or-disabled-inputs/unwanted-atlaskit-attributes.js

@@ -0,0 +1 @@
+export var UNWANTED_ATLASKIT_ATTRIBUTES = ['isDisabled', 'isReadOnly'];

package/dist/esm/rules/no-readonly-or-disabled-inputs/unwanted-html-attributes.js

@@ -0,0 +1 @@
+export var UNWANTED_HTML_ATTRIBUTES = ['disabled', 'readonly'];

package/dist/esm/rules/no-separator-with-list-elements/index.js

@@ -1,5 +1,5 @@
 import { isNodeOfType } from 'eslint-codemod-utils';
-import { createLintRule } from '../utils/create-rule';
+import { createLintRule } from '../utils/create-lint-rule';
 var separatorAsCombinationNotAllowed = 'The combination of `separator` with `as="li"`, `as="ol"`, or `as="dl"` is not allowed.';
 var rule = createLintRule({
   meta: {

package/dist/esm/rules/no-styled-tagged-template-expression/index.js

@@ -1,6 +1,7 @@
 import { isStyled } from '@atlaskit/eslint-utils/is-supported-import';
-import { createNoTaggedTemplateExpressionRule, noTaggedTemplateExpressionRuleSchema } from '../utils/create-no-tagged-template-expression-rule';
-import { createLintRule } from '../utils/create-rule';
+import { createLintRule } from '../utils/create-lint-rule';
+import { createNoTaggedTemplateExpressionRule } from '../utils/create-no-tagged-template-expression-rule/create-no-tagged-template-expression-rule';
+import { noTaggedTemplateExpressionRuleSchema } from '../utils/create-no-tagged-template-expression-rule/no-tagged-template-expression-rule-schema';
 var rule = createLintRule({
   meta: {
     name: 'no-styled-tagged-template-expression',

package/dist/esm/rules/no-to-match-snapshot/index.js

@@ -1,5 +1,5 @@
 import { isNodeOfType } from 'eslint-codemod-utils';
-import { createLintRule } from '../utils/create-rule';
+import { createLintRule } from '../utils/create-lint-rule';
 export var name = 'no-to-match-snapshot';
 var rule = createLintRule({
   meta: {

package/dist/esm/rules/no-unsafe-design-token-usage/index.js

@@ -6,9 +6,9 @@ import renameMapping from '@atlaskit/tokens/rename-mapping';
 import tokenDefaultValues from '@atlaskit/tokens/token-default-values';
 import { getTokenId } from '@atlaskit/tokens/token-ids';
 import tokens from '@atlaskit/tokens/token-names';
-import { createLintRule } from '../utils/create-rule';
+import { createLintRule } from '../utils/create-lint-rule';
+import { isDecendantOfStyleBlock } from '../utils/is-decendant-of-style-block';
 import { isDecendantOfStyleJsxAttribute } from '../utils/is-decendant-of-style-jsx-attribute';
-import { isDecendantOfStyleBlock } from '../utils/is-node';
 import { isToken } from '../utils/is-token';
 var rule = createLintRule({
   meta: {

package/dist/esm/rules/no-unsafe-inline-snapshot/index.js

@@ -1,6 +1,6 @@
 import { isNodeOfType } from 'eslint-codemod-utils';
 import { getSourceCode } from '@atlaskit/eslint-utils/context-compat';
-import { createLintRule } from '../utils/create-rule';
+import { createLintRule } from '../utils/create-lint-rule';
 export var name = 'no-unsafe-inline-snapshot';
 var MAX_LINES = 100;
 

package/dist/esm/rules/no-unsafe-style-overrides/index.js

@@ -1,6 +1,6 @@
 import { isNodeOfType } from 'eslint-codemod-utils';
 import { getSourceCode } from '@atlaskit/eslint-utils/context-compat';
-import { createLintRule } from '../utils/create-rule';
+import { createLintRule } from '../utils/create-lint-rule';
 import { getModuleOfIdentifier } from '../utils/get-module-of-identifier';
 import { getJSXElementName } from '../utils/jsx';
 var unsafeOverrides = ['css', 'className', 'theme', 'cssFn', 'styles'];

package/dist/esm/rules/no-unsupported-drag-and-drop-libraries/index.js

@@ -1,5 +1,5 @@
 import { isNodeOfType } from 'eslint-codemod-utils';
-import { createLintRule } from '../utils/create-rule';
+import { createLintRule } from '../utils/create-lint-rule';
 import { restrictedPaths } from './paths';
 var rule = createLintRule({
   meta: {

package/dist/esm/rules/no-unused-css-map/get-css-map-object.js

@@ -0,0 +1,12 @@
+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];
+};

package/dist/esm/rules/no-unused-css-map/index.js

@@ -1,7 +1,8 @@
 import { getScope, getSourceCode } from '@atlaskit/eslint-utils/context-compat';
 import { CSS_IN_JS_IMPORTS, isCssMap } from '@atlaskit/eslint-utils/is-supported-import';
-import { createLintRule } from '../utils/create-rule';
-import { getCssMapObject, UnusedCssMapChecker } from './utils';
+import { createLintRule } from '../utils/create-lint-rule';
+import { getCssMapObject } from './get-css-map-object';
+import { UnusedCssMapChecker } from './unused-css-map-checker';
 var IMPORT_SOURCES = [CSS_IN_JS_IMPORTS.compiled, CSS_IN_JS_IMPORTS.atlaskitCss];
 var createUnusedCssMapRule = function createUnusedCssMapRule(context) {
   var _getSourceCode = getSourceCode(context),

package/dist/esm/rules/no-unused-css-map/unused-css-map-checker.js

@@ -0,0 +1,143 @@
+import _slicedToArray from "@babel/runtime/helpers/slicedToArray";
+import _classCallCheck from "@babel/runtime/helpers/classCallCheck";
+import _createClass from "@babel/runtime/helpers/createClass";
+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 { getSourceCode } from '@atlaskit/eslint-utils/context-compat';
+import { findVariable } from '@atlaskit/eslint-utils/find-variable';
+export var UnusedCssMapChecker = /*#__PURE__*/function () {
+  function UnusedCssMapChecker(cssMapObject, context, cssMapCallNode) {
+    _classCallCheck(this, UnusedCssMapChecker);
+    this.cssMapObject = cssMapObject;
+    this.cssMapCallNode = cssMapCallNode;
+    this.report = context.report;
+    this.context = context;
+  }
+  return _createClass(UnusedCssMapChecker, [{
+    key: "checkForUnusedStyles",
+    value: function checkForUnusedStyles() {
+      // Get all defined style keys
+      var definedStyles = new Map();
+      var _iterator = _createForOfIteratorHelper(this.cssMapObject.properties),
+        _step;
+      try {
+        for (_iterator.s(); !(_step = _iterator.n()).done;) {
+          var _property = _step.value;
+          if (_property.type === 'Property' && _property.key.type === 'Identifier') {
+            definedStyles.set(_property.key.name, _property);
+          }
+        }
+      } catch (err) {
+        _iterator.e(err);
+      } finally {
+        _iterator.f();
+      }
+      if (definedStyles.size === 0) {
+        return;
+      }
+
+      // Find the variable that holds the cssMap result
+      var cssMapVariable = this.findCssMapVariable();
+      if (!cssMapVariable) {
+        return;
+      }
+
+      // Early return if no references - all styles are unused
+      if (cssMapVariable.references.length === 0) {
+        var _iterator2 = _createForOfIteratorHelper(definedStyles),
+          _step2;
+        try {
+          for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+            var _step2$value = _slicedToArray(_step2.value, 2),
+              styleName = _step2$value[0],
+              property = _step2$value[1];
+            this.report({
+              node: property.key,
+              messageId: 'unusedCssMapStyle',
+              data: {
+                styleName: styleName
+              }
+            });
+          }
+        } catch (err) {
+          _iterator2.e(err);
+        } finally {
+          _iterator2.f();
+        }
+        return;
+      }
+      var usedStyles = new Set();
+      var _iterator3 = _createForOfIteratorHelper(cssMapVariable.references),
+        _step3;
+      try {
+        for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
+          var ref = _step3.value;
+          var node = ref.identifier;
+          var parent = node.parent;
+          if ((parent === null || parent === void 0 ? void 0 : parent.type) === 'MemberExpression') {
+            if (!parent.computed && parent.property.type === 'Identifier') {
+              // Static access: styles.danger (not computed)
+              usedStyles.add(parent.property.name);
+
+              // Early exit if all styles are found
+              if (usedStyles.size === definedStyles.size) {
+                return;
+              }
+            } else {
+              // Dynamic access: styles[key], styles['danger'], etc. (computed)
+              // Immediately exit - no styles will be reported as unused
+              return;
+            }
+          }
+        }
+
+        // No dynamic access - report all unused styles
+      } catch (err) {
+        _iterator3.e(err);
+      } finally {
+        _iterator3.f();
+      }
+      var _iterator4 = _createForOfIteratorHelper(definedStyles),
+        _step4;
+      try {
+        for (_iterator4.s(); !(_step4 = _iterator4.n()).done;) {
+          var _step4$value = _slicedToArray(_step4.value, 2),
+            _styleName = _step4$value[0],
+            _property2 = _step4$value[1];
+          if (!usedStyles.has(_styleName)) {
+            this.report({
+              node: _property2.key,
+              messageId: 'unusedCssMapStyle',
+              data: {
+                styleName: _styleName
+              }
+            });
+          }
+        }
+      } catch (err) {
+        _iterator4.e(err);
+      } finally {
+        _iterator4.f();
+      }
+    }
+  }, {
+    key: "findCssMapVariable",
+    value: function findCssMapVariable() {
+      var callNode = this.cssMapCallNode;
+      var parent = callNode.parent;
+      if ((parent === null || parent === void 0 ? void 0 : parent.type) === 'VariableDeclarator' && parent.id.type === 'Identifier') {
+        return findVariable({
+          identifier: parent.id,
+          sourceCode: getSourceCode(this.context)
+        });
+      }
+      return null;
+    }
+  }, {
+    key: "run",
+    value: function run() {
+      this.checkForUnusedStyles();
+    }
+  }]);
+}();

package/dist/esm/rules/prefer-primitives/index.js

@@ -1,4 +1,4 @@
-import { createLintRule } from '../utils/create-rule';
+import { createLintRule } from '../utils/create-lint-rule';
 var primitiveDocsUrl = 'https://go.atlassian.com/dst-prefer-primitives';
 var rule = createLintRule({
   meta: {

package/dist/esm/rules/use-button-group-label/index.js

@@ -1,5 +1,5 @@
 import { isNodeOfType } from 'eslint-codemod-utils';
-import { createLintRule } from '../utils/create-rule';
+import { createLintRule } from '../utils/create-lint-rule';
 var elementsAccessibleNameProps = ['label', 'titleId'];
 var rule = createLintRule({
   meta: {

package/dist/esm/rules/use-character-counter-field/index.js

@@ -1,6 +1,6 @@
 import { isNodeOfType } from 'eslint-codemod-utils';
-import { JSXElementHelper } from '../../ast-nodes/jsx-element';
-import { createLintRule } from '../utils/create-rule';
+import { JSXElementHelper } from '../../ast-nodes/jsx-element-helper';
+import { createLintRule } from '../utils/create-lint-rule';
 var TEXTFIELD_PACKAGE = '@atlaskit/textfield';
 var TEXTAREA_PACKAGE = '@atlaskit/textarea';
 var FORM_PACKAGE = '@atlaskit/form';
@@ -137,4 +137,6 @@ var rule = createLintRule({
     };
   }
 });
+
+// eslint-disable-next-line @atlaskit/volt-strict-mode/no-multiple-exports
 export default rule;

package/dist/esm/rules/use-correct-field/index.js

@@ -2,7 +2,7 @@ function _createForOfIteratorHelper(r, e) { var t = "undefined" != typeof Symbol
 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 { isNodeOfType } from 'eslint-codemod-utils';
-import { createLintRule } from '../utils/create-rule';
+import { createLintRule } from '../utils/create-lint-rule';
 var specialFieldsByImport = {
   '@atlaskit/checkbox': {
     component: 'Checkbox',

package/dist/esm/rules/use-cx-function-in-xcss/index.js

@@ -2,7 +2,7 @@ function _createForOfIteratorHelper(r, e) { var t = "undefined" != typeof Symbol
 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 { isNodeOfType } from 'eslint-codemod-utils';
-import { createLintRule } from '../utils/create-rule';
+import { createLintRule } from '../utils/create-lint-rule';
 var rule = createLintRule({
   meta: {
     name: 'use-cx-function-in-xcss',

package/dist/esm/rules/use-datetime-picker-calendar-button/index.js

@@ -1,7 +1,7 @@
 import { isNodeOfType } from 'eslint-codemod-utils';
 import { JSXAttribute } from '../../ast-nodes/jsx-attribute';
-import { JSXElementHelper } from '../../ast-nodes/jsx-element';
-import { createLintRule } from '../utils/create-rule';
+import { JSXElementHelper } from '../../ast-nodes/jsx-element-helper';
+import { createLintRule } from '../utils/create-lint-rule';
 var DATE_PICKER = 'DatePicker';
 var DATETIME_PICKER = 'DateTimePicker';
 var PROP_NAME = 'shouldShowCalendarButton';

package/dist/esm/rules/use-drawer-label/index.js

@@ -1,5 +1,5 @@
 import { isNodeOfType } from 'eslint-codemod-utils';
-import { createLintRule } from '../utils/create-rule';
+import { createLintRule } from '../utils/create-lint-rule';
 var elementsAccessibleNameProps = ['label', 'titleId'];
 var rule = createLintRule({
   meta: {

package/dist/esm/rules/use-field-message-wrapper/index.js

@@ -1,5 +1,5 @@
 import { isNodeOfType } from 'eslint-codemod-utils';
-import { createLintRule } from '../utils/create-rule';
+import { createLintRule } from '../utils/create-lint-rule';
 var FORM_PACKAGE = '@atlaskit/form';
 var MESSAGE_COMPONENTS = ['ErrorMessage', 'HelperMessage', 'ValidMessage'];
 var rule = createLintRule({

package/dist/esm/rules/use-heading/index.js

@@ -1,4 +1,4 @@
-import { createLintRule } from '../utils/create-rule';
+import { createLintRule } from '../utils/create-lint-rule';
 import { errorBoundary } from '../utils/error-boundary';
 import { getConfig } from './config';
 import { NativeElements } from './transformers/native-elements';

package/dist/esm/rules/use-heading/transformers/native-elements.js

@@ -5,7 +5,7 @@ function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t =
 /* eslint-disable @repo/internal/react/require-jsdoc */
 
 import { isNodeOfType } from 'eslint-codemod-utils';
-import { JSXElement as JSXElementHelper } from '../../../ast-nodes/jsx-element';
+import { JSXElementHelper } from '../../../ast-nodes/jsx-element-helper';
 import { Root } from '../../../ast-nodes/root';
 import { allowedAttrs } from './allowed-attrs';
 import { updateTestIdAttributeFix } from './update-test-id-attribute-fix';

package/dist/esm/rules/use-heading/transformers/update-test-id-attribute-fix.js

@@ -1,5 +1,5 @@
 import { JSXAttribute } from '../../../ast-nodes/jsx-attribute';
-import { JSXElement as JSXElementHelper } from '../../../ast-nodes/jsx-element';
+import { JSXElementHelper } from '../../../ast-nodes/jsx-element-helper';
 
 // Rename data-testid prop to testId if present
 export function updateTestIdAttributeFix(node, fixer) {

package/dist/esm/rules/use-heading-level-in-spotlight-card/index.js

@@ -1,6 +1,6 @@
 import { isNodeOfType } from 'eslint-codemod-utils';
 import { getScope } from '@atlaskit/eslint-utils/context-compat';
-import { createLintRule } from '../utils/create-rule';
+import { createLintRule } from '../utils/create-lint-rule';
 import { getImportName } from '../utils/get-import-name';
 export var headingLevelRequiredSuggestionText = 'Add a `headingLevel` that is of a contextually relevant level.';
 var rule = createLintRule({

package/dist/esm/rules/use-href-in-link-item/index.js

@@ -1,6 +1,6 @@
 import { isNodeOfType } from 'eslint-codemod-utils';
 import { getScope } from '@atlaskit/eslint-utils/context-compat';
-import { createLintRule } from '../utils/create-rule';
+import { createLintRule } from '../utils/create-lint-rule';
 import { getImportName } from '../utils/get-import-name';
 import { getUniqueButtonItemName } from './get-unique-button-item-name';
 import { hasImportOfName } from './has-import-of-name';

package/dist/esm/rules/use-latest-xcss-syntax/index.js

@@ -1,4 +1,4 @@
-import { createLintRule } from '../utils/create-rule';
+import { createLintRule } from '../utils/create-lint-rule';
 import { StyleProperty } from './transformers/style-property';
 export var noRawSpacingValues = "Don't use non-token values in padding or margin. There is ongoing work to make this a TypeScript error. Once that happens, you will have to delete/refactor anyway. Atlassians: See https://go.atlassian.com/xcss-spacing for details.";
 var rule = createLintRule({

package/dist/esm/rules/use-latest-xcss-syntax-typography/config/get-config.js

@@ -0,0 +1,9 @@
+import _toConsumableArray from "@babel/runtime/helpers/toConsumableArray";
+import { PATTERNS } from './patterns';
+var defaults = {
+  failSilently: false,
+  patterns: _toConsumableArray(PATTERNS)
+};
+export var getConfig = function getConfig(overrides) {
+  return Object.assign({}, defaults, overrides);
+};