@atlaskit/eslint-plugin-design-system 14.0.0 → 14.2.0

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

@@ -1,5 +1,5 @@
 import { isNodeOfType } from 'eslint-codemod-utils';
-import * as ast from '../../ast-nodes';
+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 = {
@@ -76,7 +76,7 @@ var rule = createLintRule({
         if (!isNodeOfType(node, 'JSXElement')) {
           return false;
         }
-        var elName = ast.JSXElement.getName(node);
+        var elName = _JSXElement.getName(node);
         if (!elName) {
           return false;
         }

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

@@ -0,0 +1,139 @@
+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']
+};
+export var UNWANTED_HTML_ATTRIBUTES = ['disabled', 'readonly'];
+var isUnwantedHTMLAtrribute = function isUnwantedHTMLAtrribute(s) {
+  var attrs = UNWANTED_HTML_ATTRIBUTES;
+  return attrs.includes(s);
+};
+export var UNWANTED_ATLASKIT_ATTRIBUTES = ['isDisabled', 'isReadOnly'];
+var isUnwantedAtlaskitAtrribute = function isUnwantedAtlaskitAtrribute(s) {
+  var attrs = UNWANTED_ATLASKIT_ATTRIBUTES;
+  return attrs.includes(s);
+};
+var isUnwantedAttribute = function isUnwantedAttribute(s) {
+  return isUnwantedHTMLAtrribute(s) || isUnwantedAtlaskitAtrribute(s);
+};
+var hasUnwantedAttributes = function hasUnwantedAttributes(node, type) {
+  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(isUnwantedAttribute).filter(function (unwantedAttribute) {
+    return attrNames.includes(unwantedAttribute);
+  });
+  return unwantedAttrs;
+};
+var rule = createLintRule({
+  meta: {
+    name: 'no-readonly-or-disabled-inputs',
+    type: 'problem',
+    docs: {
+      description: 'Inputs should almost always be interactive. Disabled and read-only inputs can usually be replaced by a more user-friendly design pattern.',
+      recommended: true,
+      severity: 'warn'
+    },
+    messages: {
+      noDisabled: 'Inputs should almost always be interactive. Instead of disabling an input, consider removing it altogether, as it cannot be used anyway. Disabled inputs are much less accessible than a well labeled and described input with clear error, valid, and/or helper messages.',
+      noReadOnly: 'Inputs should almost always be interactive. Instead of making an input read-only, consider making it normal text. Read-only inputs do the same thing as normal text but appear as interactive elements and add themselves to the tab-order, which can be confusing for users.'
+    }
+  },
+  create: function create(context) {
+    var localComponentNames = [];
+    return {
+      ImportDeclaration: function ImportDeclaration(node) {
+        var source = node.source.value;
+        if (typeof source !== 'string') {
+          return;
+        }
+
+        // Ignore non-atlaskit input packages
+        if (!Object.keys(AFFECTED_ATLASKIT_PACKAGES).includes(source)) {
+          return;
+        }
+        if (!node.specifiers.length) {
+          return;
+        }
+        var defaultImport = node.specifiers.filter(function (spec) {
+          return spec.type === 'ImportDefaultSpecifier';
+        });
+        var namedImport = node.specifiers.filter(function (spec) {
+          return spec.type === 'ImportSpecifier';
+        });
+        var importNames = AFFECTED_ATLASKIT_PACKAGES[source];
+        var usesDefaultImport = importNames.includes('default');
+        var possibleNamedImports = importNames.filter(function (importName) {
+          return importName !== 'default';
+        });
+        if (usesDefaultImport && defaultImport.length && defaultImport[0].local) {
+          localComponentNames.push(defaultImport[0].local.name);
+        } else if (possibleNamedImports.length >= 1 && namedImport.length) {
+          namedImport.forEach(function (imp) {
+            if (imp.type === 'ImportSpecifier' && 'name' in imp.imported && possibleNamedImports.includes(imp.imported.name)) {
+              localComponentNames.push(imp.local.name);
+            }
+          });
+        }
+      },
+      JSXElement: function JSXElement(node) {
+        if (!isNodeOfType(node, 'JSXElement')) {
+          return false;
+        }
+        var elName = _JSXElement.getName(node);
+        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')) {
+            fixes.push(context.report({
+              node: node.openingElement,
+              messageId: 'noDisabled'
+            }));
+          }
+          if (unwantedAttributes.includes('readonly')) {
+            fixes.push(context.report({
+              node: node.openingElement,
+              messageId: 'noReadOnly'
+            }));
+          }
+          // Else, it is a React component
+        } else {
+          // if none of the affected packages is imported, return
+          if (localComponentNames.length === 0) {
+            return;
+          }
+          // if component name is not in the list, exit
+          if (!isNodeOfType(node.openingElement.name, 'JSXIdentifier') || !localComponentNames.includes(node.openingElement.name.name)) {
+            return;
+          }
+          var _unwantedAttributes = hasUnwantedAttributes(node, 'atlaskit');
+          if (_unwantedAttributes.includes('isDisabled')) {
+            fixes.push(context.report({
+              node: node.openingElement,
+              messageId: 'noDisabled'
+            }));
+          }
+          if (_unwantedAttributes.includes('isReadOnly')) {
+            fixes.push(context.report({
+              node: node.openingElement,
+              messageId: 'noReadOnly'
+            }));
+          }
+        }
+        return fixes;
+      }
+    };
+  }
+});
+export default rule;

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

@@ -7,7 +7,8 @@ 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 { isDecendantOfStyleBlock, isDecendantOfStyleJsxAttribute } from '../utils/is-node';
+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-style-overrides/index.js

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

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

@@ -1,5 +1,5 @@
 import { isNodeOfType } from 'eslint-codemod-utils';
-export var validPrimitiveElements = new Set(['div', 'span', 'article', 'aside', 'dialog', 'footer', 'header', 'li', 'main', 'nav', 'ol', 'section', 'ul', 'button']);
+import { validPrimitiveElements } from './valid-primitive-elements';
 var getChildrenByType = function getChildrenByType(node, types) {
   return node.children.filter(function (child) {
     return types.find(function (type) {

package/dist/esm/rules/prefer-primitives/valid-primitive-elements.js

@@ -0,0 +1 @@
+export var validPrimitiveElements = new Set(['div', 'span', 'article', 'aside', 'dialog', 'footer', 'header', 'li', 'main', 'nav', 'ol', 'section', 'ul', 'button']);

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

@@ -1,7 +1,7 @@
 import { createLintRule } from '../utils/create-rule';
 import { errorBoundary } from '../utils/error-boundary';
 import { getConfig } from './config';
-import { NativeElements } from './transformers';
+import { NativeElements } from './transformers/native-elements';
 var docsUrl = 'https://atlassian.design/components/heading';
 var rule = createLintRule({
   meta: {

package/dist/esm/rules/use-heading/transformers/allowed-attrs.js

@@ -0,0 +1 @@
+export var allowedAttrs = ['id', 'data-testid', 'key'];

package/dist/esm/rules/use-heading/transformers/common.js

@@ -1,9 +1 @@
-import * as ast from '../../../ast-nodes';
-// Rename data-testid prop to testId if present
-export function updateTestIdAttributeFix(node, fixer) {
-  var testIdAttr = ast.JSXElement.getAttributeByName(node, 'data-testid');
-  if (testIdAttr) {
-    return ast.JSXAttribute.updateName(testIdAttr, 'testId', fixer);
-  }
-}
-export var allowedAttrs = ['id', 'data-testid', 'key'];
+export {};

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

@@ -5,8 +5,10 @@ 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 * as ast from '../../../ast-nodes';
-import { allowedAttrs, updateTestIdAttributeFix } from './common';
+import { JSXElement as JSXElementHelper } from '../../../ast-nodes/jsx-element';
+import { Root } from '../../../ast-nodes/root';
+import { allowedAttrs } from './allowed-attrs';
+import { updateTestIdAttributeFix } from './update-test-id-attribute-fix';
 var tagSizeMap = {
   h1: 'xlarge',
   h2: 'large',
@@ -66,7 +68,7 @@ export var NativeElements = {
         success: false
       };
     }
-    var elementName = ast.JSXElement.getName(node);
+    var elementName = JSXElementHelper.getName(node);
     if (!Object.keys(tagSizeMap).includes(elementName)) {
       return {
         success: false
@@ -86,7 +88,7 @@ export var NativeElements = {
         autoFixable: false
       };
     }
-    var siblings = ast.JSXElement.getChildren(node.parent);
+    var siblings = JSXElementHelper.getChildren(node.parent);
     if (siblings.length > 1) {
       var _siblings$0$range, _node$range, _siblings$0$range2, _node$range2;
       // Only report if element is first child element
@@ -97,7 +99,7 @@ export var NativeElements = {
         };
       }
     }
-    if (!ast.JSXElement.hasAllowedAttrsOnly(node, allowedAttrs)) {
+    if (!JSXElementHelper.hasAllowedAttrsOnly(node, allowedAttrs)) {
       return {
         success: true,
         autoFixable: false
@@ -112,14 +114,14 @@ export var NativeElements = {
     var context = _ref3.context;
     return function (fixer) {
       // change to default import
-      var importFix = ast.Root.upsertDefaultImportDeclaration({
+      var importFix = Root.upsertDefaultImportDeclaration({
         module: '@atlaskit/heading',
         localName: 'Heading'
       }, context, fixer);
-      var elementName = ast.JSXElement.getName(node);
-      var elementNameFixes = ast.JSXElement.updateName(node, 'Heading', fixer);
+      var elementName = JSXElementHelper.getName(node);
+      var elementNameFixes = JSXElementHelper.updateName(node, 'Heading', fixer);
       var size = tagSizeMap[elementName];
-      var asAttributeFix = ast.JSXElement.addAttribute(node, 'size', size, fixer);
+      var asAttributeFix = JSXElementHelper.addAttribute(node, 'size', size, fixer);
       var testAttributeFix = updateTestIdAttributeFix(node, fixer);
       return [importFix].concat(_toConsumableArray(elementNameFixes), [asAttributeFix, testAttributeFix]).filter(function (fix) {
         return Boolean(fix);

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

@@ -0,0 +1,10 @@
+import { JSXAttribute } from '../../../ast-nodes/jsx-attribute';
+import { JSXElement as JSXElementHelper } from '../../../ast-nodes/jsx-element';
+
+// Rename data-testid prop to testId if present
+export function updateTestIdAttributeFix(node, fixer) {
+  var testIdAttr = JSXElementHelper.getAttributeByName(node, 'data-testid');
+  if (testIdAttr) {
+    return JSXAttribute.updateName(testIdAttr, 'testId', fixer);
+  }
+}

package/dist/esm/rules/use-href-in-link-item/get-unique-button-item-name.js

@@ -0,0 +1,22 @@
+import { hasImportOfName } from './has-import-of-name';
+export var getUniqueButtonItemName = function getUniqueButtonItemName(menuNode, importDeclarations) {
+  // Remove menu import node from array
+  var allImportDeclarationsButMenu = importDeclarations.filter(function (i) {
+    return i !== menuNode;
+  });
+  var currentButtonItemNameExistsOtherThanMenu = allImportDeclarationsButMenu.reduce(function (acc, importNode) {
+    return acc || hasImportOfName(importNode, 'ButtonItem');
+  }, false);
+  if (currentButtonItemNameExistsOtherThanMenu) {
+    var suffix = 1;
+    while (currentButtonItemNameExistsOtherThanMenu) {
+      suffix += 1;
+      currentButtonItemNameExistsOtherThanMenu = allImportDeclarationsButMenu.reduce(function (acc, importNode) {
+        return acc || hasImportOfName(importNode, "ButtonItem".concat(suffix));
+      }, false);
+    }
+    return "ButtonItem".concat(suffix);
+  } else {
+    return 'ButtonItem';
+  }
+};

package/dist/esm/rules/use-href-in-link-item/has-import-of-name.js

@@ -0,0 +1,11 @@
+export var hasImportOfName = function hasImportOfName(node, name) {
+  return node.specifiers.some(
+  // This should not be an `any`. This is an array of `ImportSpecifier |
+  // ImportDefaultSpecifier`. For some reason, filtering this way still
+  // results in an error of `specifier.imported` doesn't exist on
+  // ImportDefaultSpecifier, which is exactly what I'm filtering for
+  function (specifier) {
+    var _specifier$imported;
+    return (specifier === null || specifier === void 0 || (_specifier$imported = specifier.imported) === null || _specifier$imported === void 0 ? void 0 : _specifier$imported.name) === name;
+  });
+};

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

@@ -2,7 +2,11 @@ import { isNodeOfType } from 'eslint-codemod-utils';
 import { getScope } from '@atlaskit/eslint-utils/context-compat';
 import { createLintRule } from '../utils/create-rule';
 import { getImportName } from '../utils/get-import-name';
-import { getUniqueButtonItemName, hasImportOfName, hrefHasInvalidValue, insertButtonItemDefaultImport, insertButtonItemImport } from './utils';
+import { getUniqueButtonItemName } from './get-unique-button-item-name';
+import { hasImportOfName } from './has-import-of-name';
+import { insertButtonItemDefaultImport } from './insert-button-item-default-import';
+import { insertButtonItemImport } from './insert-button-item-import';
+import { hrefHasInvalidValue } from './utils';
 export var hrefRequiredSuggestionText = 'Convert LinkItem to ButtonItem';
 var rule = createLintRule({
   meta: {

package/dist/esm/rules/use-href-in-link-item/insert-button-item-default-import.js

@@ -0,0 +1,3 @@
+export var insertButtonItemDefaultImport = function insertButtonItemDefaultImport(fixer, node) {
+  return fixer.insertTextBefore(node, "import ButtonItem from '@atlaskit/menu/button-item';\n");
+};

package/dist/esm/rules/use-href-in-link-item/insert-button-item-import.js

@@ -0,0 +1,4 @@
+export var insertButtonItemImport = function insertButtonItemImport(fixer, node, uniqueButtonItemName) {
+  var insertedImport = uniqueButtonItemName !== 'ButtonItem' ? ", ButtonItem as ".concat(uniqueButtonItemName) : ', ButtonItem';
+  return fixer.insertTextAfter(node.specifiers.slice(-1)[0], insertedImport);
+};

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

@@ -40,43 +40,4 @@ export var hrefHasInvalidValue = function hrefHasInvalidValue(scope, href) {
     }
   }
   return false;
-};
-export var hasImportOfName = function hasImportOfName(node, name) {
-  return node.specifiers.some(
-  // This should not be an `any`. This is an array of `ImportSpecifier |
-  // ImportDefaultSpecifier`. For some reason, filtering this way still
-  // results in an error of `specifier.imported` doesn't exist on
-  // ImportDefaultSpecifier, which is exactly what I'm filtering for
-  function (specifier) {
-    var _specifier$imported;
-    return (specifier === null || specifier === void 0 || (_specifier$imported = specifier.imported) === null || _specifier$imported === void 0 ? void 0 : _specifier$imported.name) === name;
-  });
-};
-export var insertButtonItemDefaultImport = function insertButtonItemDefaultImport(fixer, node) {
-  return fixer.insertTextBefore(node, "import ButtonItem from '@atlaskit/menu/button-item';\n");
-};
-export var getUniqueButtonItemName = function getUniqueButtonItemName(menuNode, importDeclarations) {
-  // Remove menu import node from array
-  var allImportDeclarationsButMenu = importDeclarations.filter(function (i) {
-    return i !== menuNode;
-  });
-  var currentButtonItemNameExistsOtherThanMenu = allImportDeclarationsButMenu.reduce(function (acc, importNode) {
-    return acc || hasImportOfName(importNode, 'ButtonItem');
-  }, false);
-  if (currentButtonItemNameExistsOtherThanMenu) {
-    var suffix = 1;
-    while (currentButtonItemNameExistsOtherThanMenu) {
-      suffix += 1;
-      currentButtonItemNameExistsOtherThanMenu = allImportDeclarationsButMenu.reduce(function (acc, importNode) {
-        return acc || hasImportOfName(importNode, "ButtonItem".concat(suffix));
-      }, false);
-    }
-    return "ButtonItem".concat(suffix);
-  } else {
-    return 'ButtonItem';
-  }
-};
-export var insertButtonItemImport = function insertButtonItemImport(fixer, node, uniqueButtonItemName) {
-  var insertedImport = uniqueButtonItemName !== 'ButtonItem' ? ", ButtonItem as ".concat(uniqueButtonItemName) : ', ButtonItem';
-  return fixer.insertTextAfter(node.specifiers.slice(-1)[0], insertedImport);
 };

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

@@ -1,5 +1,5 @@
 import { createLintRule } from '../utils/create-rule';
-import { StyleProperty } from './transformers';
+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({
   meta: {

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

@@ -2,7 +2,9 @@
 
 import { isNodeOfType } from 'eslint-codemod-utils';
 import { getSourceCode } from '@atlaskit/eslint-utils/context-compat';
-import * as ast from '../../../../ast-nodes';
+import { Import } from '../../../../ast-nodes/import';
+import { ObjectEntry as ObjectEntryHelper } from '../../../../ast-nodes/object-entry';
+import { Root } from '../../../../ast-nodes/root';
 import { styleMap } from './style-map';
 import supported from './supported';
 var messageId = 'noRawSpacingValues';
@@ -30,9 +32,9 @@ export var StyleProperty = {
         ref: undefined
       };
     }
-    var importDeclarations = ast.Root.findImportsByModule(getSourceCode(context).ast.body, '@atlaskit/primitives');
+    var importDeclarations = Root.findImportsByModule(getSourceCode(context).ast.body, '@atlaskit/primitives');
     var isXcssImported = importDeclarations.some(function (importDeclaration) {
-      return ast.Import.containsNamedSpecifier(importDeclaration, 'xcss');
+      return Import.containsNamedSpecifier(importDeclaration, 'xcss');
     });
     if (!isXcssImported) {
       return {
@@ -63,8 +65,8 @@ export var StyleProperty = {
         ref: undefined
       };
     }
-    var _ast$ObjectEntry$getP = ast.ObjectEntry.getProperty(node),
-      property = _ast$ObjectEntry$getP.value;
+    var _ObjectEntryHelper$ge = ObjectEntryHelper.getProperty(node),
+      property = _ObjectEntryHelper$ge.value;
 
     // Bail if the property is not `padding`, `margin`, etc
     if (!property || !styleMap.includes(property)) {
@@ -73,7 +75,7 @@ export var StyleProperty = {
         ref: undefined
       };
     }
-    var value = ast.ObjectEntry.getValue(node);
+    var value = ObjectEntryHelper.getValue(node);
     if (typeof value !== 'string') {
       return {
         success: false,

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

@@ -1,7 +1,9 @@
 import { createLintRule } from '../utils/create-rule';
 import { errorBoundary } from '../utils/error-boundary';
 import { getConfig, PATTERNS } from './config';
-import { RestrictedCapitalisation, RestrictedProperty, WrappedTokenValue } from './linters';
+import { RestrictedCapitalisation } from './linters/restricted-capitalisation';
+import { RestrictedProperty } from './linters/restricted-property';
+import { WrappedTokenValue } from './linters/wrapped-token-value';
 var typescriptErrorMessage = 'There is ongoing work to make this a TypeScript error. Once that happens, you will have to delete/refactor anyway.';
 var rule = createLintRule({
   meta: {

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

@@ -1,6 +1,7 @@
 import { createLintRule } from '../utils/create-rule';
 import { getConfig, VALID_PATTERNS } from './config';
-import { CompiledStyled, EmotionCSS } from './transformers';
+import { CompiledStyled } from './transformers/compiled-styled';
+import { EmotionCSS } from './transformers/emotion-css';
 var boxDocsUrl = 'https://atlassian.design/components/primitives/box';
 var rule = createLintRule({
   meta: {

package/dist/esm/rules/use-primitives/transformers/compiled-styled/{supported.js → attributes.js}

@@ -1,4 +1,3 @@
-export var elements = ['div'];
 export var attributes = ['css'
 // 'data-testid'
 ];

package/dist/esm/rules/use-primitives/transformers/compiled-styled/convert-jsx-call-site.js

@@ -1,6 +1,6 @@
 import _toConsumableArray from "@babel/runtime/helpers/toConsumableArray";
 import { isNodeOfType } from 'eslint-codemod-utils';
-import * as ast from '../../../../ast-nodes';
+import { JSXElement as JSXElementHelper } from '../../../../ast-nodes/jsx-element';
 
 /**
  * Transforms a JSXElement from:
@@ -21,7 +21,7 @@ export var convertJsxCallSite = function convertJsxCallSite(jsxElement, newStyle
 
   // renames the JSX call site
   if (isNodeOfType(jsxElement, 'JSXElement')) {
-    fixes.push.apply(fixes, _toConsumableArray(ast.JSXElement.updateName(jsxElement, 'Box', fixer)));
+    fixes.push.apply(fixes, _toConsumableArray(JSXElementHelper.updateName(jsxElement, 'Box', fixer)));
   }
 
   // adds xcss prop

package/dist/esm/rules/use-primitives/transformers/compiled-styled/elements.js

@@ -0,0 +1 @@
+export var elements = ['div'];

package/dist/esm/rules/use-primitives/transformers/compiled-styled/find-valid-styled-component-call.js

@@ -1,5 +1,5 @@
 import { closestOfType, isNodeOfType } from 'eslint-codemod-utils';
-import * as supported from './supported';
+import { elements } from './elements';
 
 /**
  * returns a variable reference if preconditions are favourable for
@@ -41,7 +41,7 @@ var isStyledCallExpression = function isStyledCallExpression(call) {
   if (!isNodeOfType(call.callee.object, 'Identifier') || !isNodeOfType(call.callee.property, 'Identifier')) {
     return false;
   }
-  if (/^styled2?$/.test(call.callee.object.name) && supported.elements.includes(call.callee.property.name)) {
+  if (/^styled2?$/.test(call.callee.object.name) && elements.includes(call.callee.property.name)) {
     return true;
   }
   return false;

package/dist/esm/rules/use-primitives/transformers/compiled-styled/index.js

@@ -3,8 +3,9 @@ import _toConsumableArray from "@babel/runtime/helpers/toConsumableArray";
 
 import { isNodeOfType } from 'eslint-codemod-utils';
 import { getScope, getSourceCode } from '@atlaskit/eslint-utils/context-compat';
-import * as ast from '../../../../ast-nodes';
-import { isValidCssPropertiesToTransform } from '../../utils';
+import { JSXElement as JSXElementHelper } from '../../../../ast-nodes/jsx-element';
+import { Root } from '../../../../ast-nodes/root';
+import { isValidCssPropertiesToTransform } from '../../utils/is-valid-css-properties-to-transform';
 import { validateStyles } from '../../utils/validate-styles';
 import { convertJsxCallSite } from './convert-jsx-call-site';
 import { convertStyledComponentToXcss } from './convert-styled-component-call-to-jsx';
@@ -32,7 +33,7 @@ export var CompiledStyled = {
       node: refs.styles,
       messageId: 'preferPrimitivesBox',
       suggest: [{
-        desc: "Convert ".concat(ast.JSXElement.getName(refs.jsxElement), " to Box"),
+        desc: "Convert ".concat(JSXElementHelper.getName(refs.jsxElement), " to Box"),
         fix: CompiledStyled._fix(refs, context)
       }]
     });
@@ -68,7 +69,7 @@ export var CompiledStyled = {
         success: false
       };
     }
-    var importDeclaration = ast.Root.findImportsByModule(getSourceCode(context).ast.body, '@atlaskit/primitives');
+    var importDeclaration = Root.findImportsByModule(getSourceCode(context).ast.body, '@atlaskit/primitives');
 
     // If there is more than one `@atlaskit/primitives` import, then it becomes difficult to determine which import to transform
     if (importDeclaration.length > 1) {
@@ -95,7 +96,7 @@ export var CompiledStyled = {
       if (!calculatedStylesVariableName) {
         return [];
       }
-      var importFixes = ast.Root.upsertNamedImportDeclaration({
+      var importFixes = Root.upsertNamedImportDeclaration({
         module: '@atlaskit/primitives',
         specifiers: ['Box', 'xcss']
       }, context, fixer);

package/dist/esm/rules/use-primitives/transformers/css-to-xcss.js

@@ -4,8 +4,13 @@ function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbol
 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 { getIdentifierInParentScope, identifier, isNodeOfType, literal } from 'eslint-codemod-utils';
 import { getScope } from '@atlaskit/eslint-utils/context-compat';
-import { allSpaceMap, positiveSpaceMap } from '../../../common/token-maps.partial';
-import { getAttributeValueIdentifier, getFunctionArgumentAtPos, getJSXAttributeByName, getVariableDefinitionValue } from '../utils';
+import { getAttributeValueIdentifier } from '../utils/get-attribute-value-identifier';
+import { getFunctionArgumentAtPos } from '../utils/get-function-argument-at-pos';
+import { getJSXAttributeByName } from '../utils/get-jsx-attribute-by-name';
+import { getVariableDefinitionValue } from '../utils/get-variable-definition-value';
+import { spaceTokenMap } from './space-token-map';
+import { spaceTokenPositiveMap } from './space-token-positive-map';
+import { supportedDimensionAttributesMap } from './supported-dimension-attributes-map';
 export var cssToXcssTransformer = function cssToXcssTransformer(node, context, fixer) {
   /**
    * Note: The logic here is very similar to the logic in `shouldSuggestBox`. i.e.
@@ -70,19 +75,6 @@ export var styledObjectToXcssTokens = function styledObjectToXcssTokens(styles,
     }
   });
 };
-export var spaceTokenMap = allSpaceMap;
-export var spaceTokenPositiveMap = positiveSpaceMap;
-export var dimensionsMap = {
-  '100%': '100%'
-};
-export var supportedDimensionAttributesMap = {
-  width: dimensionsMap,
-  height: dimensionsMap,
-  minWidth: dimensionsMap,
-  minHeight: dimensionsMap,
-  maxWidth: dimensionsMap,
-  maxHeight: dimensionsMap
-};
 export var supportedStylesMap = _objectSpread({
   padding: spaceTokenPositiveMap,
   paddingBlock: spaceTokenPositiveMap,

package/dist/esm/rules/use-primitives/transformers/dimensions-map.js

@@ -0,0 +1,3 @@
+export var dimensionsMap = {
+  '100%': '100%'
+};

package/dist/esm/rules/use-primitives/transformers/emotion-css/{supported.js → attributes.js}

@@ -1,4 +1,3 @@
-export var elements = ['div'];
 export var attributes = ['css'
 // 'data-testid'
 ];

package/dist/esm/rules/use-primitives/transformers/emotion-css/elements.js

@@ -0,0 +1 @@
+export var elements = ['div'];