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

package/dist/esm/rules/use-should-render-to-parent/index.js

@@ -7,7 +7,23 @@ var PROP_NAME = 'shouldRenderToParent';
 var message = "Setting the `".concat(PROP_NAME, "` prop to anything other than `true` causes accessibility issues. Only set to `false` as a last resort.");
 export var addProp = "Add `".concat(PROP_NAME, "` prop.");
 export var setPropToTrue = "Set `".concat(PROP_NAME, "` prop to `true`.");
-var components = ['@atlaskit/popup', '@atlaskit/dropdown-menu'];
+var components = {
+  '@atlaskit/popup': {
+    default: true,
+    named: 'Popup'
+  },
+  '@atlaskit/dropdown-menu': {
+    default: true
+  },
+  '@atlassian/entry-points/dropdown-trigger': {
+    default: false,
+    named: 'DropdownTrigger'
+  },
+  '@atlassian/entry-points/popup-trigger': {
+    default: false,
+    named: 'PopupTrigger'
+  }
+};
 var rule = createLintRule({
   meta: {
     name: RULE_NAME,
@@ -27,11 +43,12 @@ var rule = createLintRule({
     var componentLocalName;
     return {
       ImportDeclaration: function ImportDeclaration(node) {
+        var _components$source;
         var source = node.source.value;
         if (typeof source !== 'string') {
           return;
         }
-        if (!components.includes(source)) {
+        if (!(source in components)) {
           return;
         }
         if (!node.specifiers.length) {
@@ -40,17 +57,23 @@ var rule = createLintRule({
         var defaultImport = node.specifiers.filter(function (spec) {
           return spec.type === 'ImportDefaultSpecifier';
         });
-        var namedImport = node.specifiers.filter(function (spec) {
+        var namedImports = node.specifiers.filter(function (spec) {
           return spec.type === 'ImportSpecifier';
         });
-
-        // If popup or dropdown menu and using a default import
-        if (defaultImport.length && defaultImport[0].local) {
+        if (defaultImport.length && defaultImport[0].local && (_components$source = components[source]) !== null && _components$source !== void 0 && _components$source.default) {
           componentLocalName = defaultImport[0].local.name;
-          // or if popup and using a named import
-        } else if (namedImport.length && namedImport[0].type === 'ImportSpecifier' && 'name' in namedImport[0].imported && namedImport[0].imported.name === 'Popup') {
-          componentLocalName = namedImport[0].local.name;
         }
+        if (!namedImports.length) {
+          return;
+        }
+
+        // Iterate through all of them, only one should ever be found
+        namedImports.forEach(function (namedImport) {
+          var _components$source2;
+          if (namedImport.type === 'ImportSpecifier' && 'name' in namedImport.imported && namedImport.imported.name === ((_components$source2 = components[source]) === null || _components$source2 === void 0 ? void 0 : _components$source2.named)) {
+            componentLocalName = namedImport.local.name;
+          }
+        });
       },
       JSXElement: function JSXElement(node) {
         if (!isNodeOfType(node, 'JSXElement')) {

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

@@ -1,6 +1,6 @@
 import _defineProperty from "@babel/runtime/helpers/defineProperty";
 import { createLintRule } from '../utils/create-rule';
-import { ImportDeclaration } from './linters';
+import { ImportDeclaration } from './linters/import-declaration';
 var rule = createLintRule({
   meta: {
     name: 'use-spotlight-package',

package/dist/esm/rules/use-tokens-shape/transformers/index.js

@@ -1,8 +1,9 @@
 /* eslint-disable @repo/internal/react/require-jsdoc */
 
 import { isNodeOfType } from 'eslint-codemod-utils';
-import * as ast from '../../../ast-nodes';
-import { isStringOrNumber } from '../../use-tokens-space/utils';
+import { ObjectEntry } from '../../../ast-nodes/object-entry';
+import { Root } from '../../../ast-nodes/root';
+import { isStringOrNumber } from '../../use-tokens-space/utils/is-string-or-number';
 import { styleMap } from './style-map';
 import supported from './supported';
 var messageId = 'noRawShapeValues';
@@ -45,8 +46,8 @@ export var StyleProperty = {
         ref: undefined
       };
     }
-    var _ast$ObjectEntry$getP = ast.ObjectEntry.getProperty(node),
-      property = _ast$ObjectEntry$getP.value;
+    var _ObjectEntry$getPrope = ObjectEntry.getProperty(node),
+      property = _ObjectEntry$getPrope.value;
 
     // Bail if the property is not `borderRadius`, `borderWidth`, etc
     if (!property || !styleMap[property]) {
@@ -55,7 +56,7 @@ export var StyleProperty = {
         ref: undefined
       };
     }
-    var value = ast.ObjectEntry.getValue(node);
+    var value = ObjectEntry.getValue(node);
 
     // This is mainly useful as a type guard, so the checks after don't have to have duplicate checks for other types.
     if (!isStringOrNumber(value)) {
@@ -105,7 +106,7 @@ export var StyleProperty = {
    */
   _fix: function _fix(ref, context) {
     return function (fixer) {
-      var importFix = ast.Root.upsertNamedImportDeclaration({
+      var importFix = Root.upsertNamedImportDeclaration({
         module: '@atlaskit/tokens',
         specifiers: ['token']
       }, context, fixer);

package/dist/esm/rules/use-tokens-space/index.js

@@ -1,5 +1,5 @@
 import { createLintRule } from '../utils/create-rule';
-import { StyleProperty } from './transformers';
+import { StyleProperty } from './transformers/style-property';
 var rule = createLintRule({
   meta: {
     name: 'use-tokens-space',

package/dist/esm/rules/use-tokens-space/transformers/style-property/index.js

@@ -1,8 +1,9 @@
 /* eslint-disable @repo/internal/react/require-jsdoc */
 
 import { isNodeOfType } from 'eslint-codemod-utils';
-import * as ast from '../../../../ast-nodes';
-import { isStringOrNumber } from '../../utils';
+import { ObjectEntry } from '../../../../ast-nodes/object-entry';
+import { Root } from '../../../../ast-nodes/root';
+import { isStringOrNumber } from '../../utils/is-string-or-number';
 import { styleMap } from './style-map';
 import supported from './supported';
 var messageId = 'noRawSpacingValues';
@@ -45,8 +46,8 @@ export var StyleProperty = {
         ref: undefined
       };
     }
-    var _ast$ObjectEntry$getP = ast.ObjectEntry.getProperty(node),
-      property = _ast$ObjectEntry$getP.value;
+    var _ObjectEntry$getPrope = ObjectEntry.getProperty(node),
+      property = _ObjectEntry$getPrope.value;
 
     // Bail if the property is not `padding`, `margin`, etc
     if (!property || !styleMap[property]) {
@@ -55,7 +56,7 @@ export var StyleProperty = {
         ref: undefined
       };
     }
-    var value = ast.ObjectEntry.getValue(node);
+    var value = ObjectEntry.getValue(node);
 
     // This is mainly useful as a type guard, so the checks after don't have to have duplicate checks for other types.
     if (!isStringOrNumber(value)) {
@@ -105,7 +106,7 @@ export var StyleProperty = {
    */
   _fix: function _fix(ref, context) {
     return function (fixer) {
-      var importFix = ast.Root.upsertNamedImportDeclaration({
+      var importFix = Root.upsertNamedImportDeclaration({
         module: '@atlaskit/tokens',
         specifiers: ['token']
       }, context, fixer);

package/dist/esm/rules/use-tokens-typography/convert-property-node-to-stringable-node.js

@@ -0,0 +1,7 @@
+import { property } from 'eslint-codemod-utils';
+export function convertPropertyNodeToStringableNode(node) {
+  return property({
+    key: node.key,
+    value: node.value
+  });
+}

package/dist/esm/rules/use-tokens-typography/find-font-family-token-for-value.js

@@ -0,0 +1,11 @@
+export function findFontFamilyTokenForValue(value) {
+  if (/charlie[\s-]?display/i.test(value)) {
+    return 'font.family.brand.heading';
+  } else if (/charlie[\s-]?text/i.test(value)) {
+    return 'font.family.brand.body';
+  } else if (/sans[\s-]?serif/i.test(value)) {
+    return 'font.family.body';
+  } else if (/monospace/i.test(value)) {
+    return 'font.family.code';
+  }
+}

package/dist/esm/rules/use-tokens-typography/get-literal-property.js

@@ -0,0 +1,7 @@
+import { identifier, literal, property } from 'eslint-codemod-utils';
+export function getLiteralProperty(propertyName, propertyValue) {
+  return property({
+    key: identifier(propertyName),
+    value: literal(propertyValue)
+  });
+}

package/dist/esm/rules/use-tokens-typography/insert-tokens-import.js

@@ -0,0 +1,7 @@
+import { Root } from '../../ast-nodes/root';
+export function insertTokensImport(root, fixer) {
+  return Root.insertImport(root, {
+    module: '@atlaskit/tokens',
+    specifiers: ['token']
+  }, fixer);
+}

package/dist/esm/rules/use-tokens-typography/is-code-font-family.js

@@ -0,0 +1,4 @@
+import { isNodeOfType } from 'eslint-codemod-utils';
+export var isCodeFontFamily = function isCodeFontFamily(node) {
+  return isNodeOfType(node, 'CallExpression') && isNodeOfType(node.callee, 'Identifier') && (node.callee.name === 'codeFontFamily' || node.callee.name === 'getCodeFontFamily');
+};

package/dist/esm/rules/use-tokens-typography/is-font-family.js

@@ -0,0 +1,4 @@
+import { isNodeOfType } from 'eslint-codemod-utils';
+export var isFontFamily = function isFontFamily(node) {
+  return isNodeOfType(node, 'CallExpression') && isNodeOfType(node.callee, 'Identifier') && (node.callee.name === 'fontFamily' || node.callee.name === 'getFontFamily');
+};

package/dist/esm/rules/use-tokens-typography/is-font-size-small.js

@@ -0,0 +1,4 @@
+import { isNodeOfType } from 'eslint-codemod-utils';
+export var isFontSizeSmall = function isFontSizeSmall(node) {
+  return isNodeOfType(node, 'CallExpression') && isNodeOfType(node.callee, 'Identifier') && node.callee.name === 'fontSizeSmall';
+};

package/dist/esm/rules/use-tokens-typography/is-font-size.js

@@ -0,0 +1,4 @@
+import { isNodeOfType } from 'eslint-codemod-utils';
+export var isFontSize = function isFontSize(node) {
+  return isNodeOfType(node, 'CallExpression') && isNodeOfType(node.callee, 'Identifier') && (node.callee.name === 'fontSize' || node.callee.name === 'getFontSize');
+};

package/dist/esm/rules/use-tokens-typography/is-typography-property.js

@@ -0,0 +1,4 @@
+import { typographyProperties } from './typography-properties';
+export var isTypographyProperty = function isTypographyProperty(propertyName) {
+  return typographyProperties.includes(propertyName);
+};

package/dist/esm/rules/use-tokens-typography/is-valid-property-node.js

@@ -0,0 +1,7 @@
+import { isNodeOfType } from 'eslint-codemod-utils';
+export function isValidPropertyNode(node) {
+  if (!isNodeOfType(node.key, 'Identifier') && !isNodeOfType(node.key, 'Literal')) {
+    return false;
+  }
+  return true;
+}

package/dist/esm/rules/use-tokens-typography/is-valid-typography-token.js

@@ -0,0 +1,10 @@
+import { typography as typographyTokens } from '@atlaskit/tokens/tokens-raw';
+export function isValidTypographyToken(tokenName) {
+  return typographyTokens.filter(function (t) {
+    return t.attributes.group === 'typography';
+  }).filter(function (t) {
+    return t.cleanName.includes('font.heading') || t.cleanName.includes('font.body') || t.cleanName.includes('font.code');
+  }).find(function (t) {
+    return t.cleanName === tokenName;
+  });
+}

package/dist/esm/rules/use-tokens-typography/not-undefined.js

@@ -0,0 +1,3 @@
+export function notUndefined(value) {
+  return value !== undefined;
+}

package/dist/esm/rules/use-tokens-typography/transformers/banned-properties.js

@@ -1,7 +1,8 @@
 /* eslint-disable @repo/internal/react/require-jsdoc */
 
 import { isNodeOfType } from 'eslint-codemod-utils';
-import { isDecendantOfStyleBlock, isDecendantOfType } from '../../utils/is-node';
+import { isDecendantOfType } from '../../utils/is-decendant-of-type';
+import { isDecendantOfStyleBlock } from '../../utils/is-node';
 export var BannedProperties = {
   lint: function lint(node, _ref) {
     var context = _ref.context,

package/dist/esm/rules/use-tokens-typography/transformers/font-family.js

@@ -2,10 +2,12 @@
 
 import { isNodeOfType } from 'eslint-codemod-utils';
 import { getSourceCode } from '@atlaskit/eslint-utils/context-compat';
-import { Root } from '../../../ast-nodes';
+import { Root } from '../../../ast-nodes/root';
 import { getNodeSource } from '../../utils/get-node-source';
-import { isDecendantOfStyleBlock, isDecendantOfType } from '../../utils/is-node';
-import { findFontFamilyTokenForValue, insertTokensImport } from '../utils';
+import { isDecendantOfType } from '../../utils/is-decendant-of-type';
+import { isDecendantOfStyleBlock } from '../../utils/is-node';
+import { findFontFamilyTokenForValue } from '../find-font-family-token-for-value';
+import { insertTokensImport } from '../insert-tokens-import';
 export var FontFamily = {
   lint: function lint(node, _ref) {
     var context = _ref.context,

package/dist/esm/rules/use-tokens-typography/transformers/font-weight.js

@@ -2,10 +2,12 @@
 
 import { isNodeOfType } from 'eslint-codemod-utils';
 import { getSourceCode } from '@atlaskit/eslint-utils/context-compat';
-import { Root } from '../../../ast-nodes';
+import { Root } from '../../../ast-nodes/root';
 import { getNodeSource } from '../../utils/get-node-source';
-import { isDecendantOfStyleBlock, isDecendantOfType } from '../../utils/is-node';
-import { findFontWeightTokenForValue, insertTokensImport } from '../utils';
+import { isDecendantOfType } from '../../utils/is-decendant-of-type';
+import { isDecendantOfStyleBlock } from '../../utils/is-node';
+import { insertTokensImport } from '../insert-tokens-import';
+import { findFontWeightTokenForValue } from '../utils';
 export var FontWeight = {
   lint: function lint(node, _ref) {
     var context = _ref.context,

package/dist/esm/rules/use-tokens-typography/transformers/style-object.js

@@ -5,10 +5,21 @@ function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t =
 
 import { isNodeOfType } from 'eslint-codemod-utils';
 import { getSourceCode } from '@atlaskit/eslint-utils/context-compat';
-import { Object as ASTObject, ObjectEntry, Root } from '../../../ast-nodes';
-import { getValueForPropertyNode, normaliseValue } from '../../ensure-design-token-usage/utils';
-import { isDecendantOfGlobalToken, isDecendantOfStyleBlock, isDecendantOfType } from '../../utils/is-node';
-import { convertPropertyNodeToStringableNode, defaultFontWeight, findFontWeightTokenForValue, findTypographyTokenForValues, fontWeightMap, getLiteralProperty, getTokenProperty, insertTokensImport, isValidPropertyNode, isValidTypographyToken, notUndefined } from '../utils';
+import { Object as ASTObject } from '../../../ast-nodes/object';
+import { ObjectEntry } from '../../../ast-nodes/object-entry';
+import { Root } from '../../../ast-nodes/root';
+import { normaliseValue } from '../../ensure-design-token-usage/normalise-value';
+import { getValueForPropertyNode } from '../../ensure-design-token-usage/utils';
+import { isDecendantOfGlobalToken } from '../../utils/is-decendant-of-global-token';
+import { isDecendantOfType } from '../../utils/is-decendant-of-type';
+import { isDecendantOfStyleBlock } from '../../utils/is-node';
+import { convertPropertyNodeToStringableNode } from '../convert-property-node-to-stringable-node';
+import { getLiteralProperty } from '../get-literal-property';
+import { insertTokensImport } from '../insert-tokens-import';
+import { isValidPropertyNode } from '../is-valid-property-node';
+import { isValidTypographyToken } from '../is-valid-typography-token';
+import { notUndefined } from '../not-undefined';
+import { defaultFontWeight, findFontWeightTokenForValue, findTypographyTokenForValues, fontWeightMap, getTokenProperty } from '../utils';
 export var StyleObject = {
   lint: function lint(node, _ref) {
     var context = _ref.context,

package/dist/esm/rules/use-tokens-typography/transformers/untokenized-properties.js

@@ -3,7 +3,8 @@
 import { isNodeOfType } from 'eslint-codemod-utils';
 import { getSourceCode } from '@atlaskit/eslint-utils/context-compat';
 import { getNodeSource } from '../../utils/get-node-source';
-import { isDecendantOfStyleBlock, isDecendantOfType } from '../../utils/is-node';
+import { isDecendantOfType } from '../../utils/is-decendant-of-type';
+import { isDecendantOfStyleBlock } from '../../utils/is-node';
 export var UntokenizedProperties = {
   lint: function lint(node, _ref) {
     var context = _ref.context,

package/dist/esm/rules/use-tokens-typography/typography-properties.js

@@ -0,0 +1 @@
+export var typographyProperties = ['fontSize', 'fontWeight', 'fontFamily', 'lineHeight'];

package/dist/esm/rules/use-tokens-typography/utils.js

@@ -1,23 +1,6 @@
-import { callExpression, identifier, isNodeOfType, literal, memberExpression, property } from 'eslint-codemod-utils';
+import { callExpression, identifier, literal, memberExpression, property } from 'eslint-codemod-utils';
 import { typographyPalette } from '@atlaskit/tokens/palettes-raw';
 import { typography as typographyTokens } from '@atlaskit/tokens/tokens-raw';
-import { Root } from '../../ast-nodes';
-export var typographyProperties = ['fontSize', 'fontWeight', 'fontFamily', 'lineHeight'];
-export var isTypographyProperty = function isTypographyProperty(propertyName) {
-  return typographyProperties.includes(propertyName);
-};
-export var isFontSize = function isFontSize(node) {
-  return isNodeOfType(node, 'CallExpression') && isNodeOfType(node.callee, 'Identifier') && (node.callee.name === 'fontSize' || node.callee.name === 'getFontSize');
-};
-export var isFontSizeSmall = function isFontSizeSmall(node) {
-  return isNodeOfType(node, 'CallExpression') && isNodeOfType(node.callee, 'Identifier') && node.callee.name === 'fontSizeSmall';
-};
-export var isFontFamily = function isFontFamily(node) {
-  return isNodeOfType(node, 'CallExpression') && isNodeOfType(node.callee, 'Identifier') && (node.callee.name === 'fontFamily' || node.callee.name === 'getFontFamily');
-};
-export var isCodeFontFamily = function isCodeFontFamily(node) {
-  return isNodeOfType(node, 'CallExpression') && isNodeOfType(node.callee, 'Identifier') && (node.callee.name === 'codeFontFamily' || node.callee.name === 'getCodeFontFamily');
-};
 export var typographyValueToToken = typographyTokens
 // we're filtering here to remove the `font` tokens.
 .filter(function (t) {
@@ -53,15 +36,6 @@ export var typographyValueToToken = typographyTokens
     values: individualValues
   };
 });
-export function isValidTypographyToken(tokenName) {
-  return typographyTokens.filter(function (t) {
-    return t.attributes.group === 'typography';
-  }).filter(function (t) {
-    return t.cleanName.includes('font.heading') || t.cleanName.includes('font.body') || t.cleanName.includes('font.code');
-  }).find(function (t) {
-    return t.cleanName === tokenName;
-  });
-}
 export function findTypographyTokenForValues(fontSize, lineHeight) {
   // Match 11px to 12px as this is what happened when transitioning from legacy to refreshed typography
   if (fontSize === '11px') {
@@ -108,26 +82,6 @@ export var fontWeightMap = {
   bold: '700'
 };
 export var defaultFontWeight = fontWeightMap.regular;
-export function findFontFamilyTokenForValue(value) {
-  if (/charlie[\s-]?display/i.test(value)) {
-    return 'font.family.brand.heading';
-  } else if (/charlie[\s-]?text/i.test(value)) {
-    return 'font.family.brand.body';
-  } else if (/sans[\s-]?serif/i.test(value)) {
-    return 'font.family.body';
-  } else if (/monospace/i.test(value)) {
-    return 'font.family.code';
-  }
-}
-export function notUndefined(value) {
-  return value !== undefined;
-}
-export function isValidPropertyNode(node) {
-  if (!isNodeOfType(node.key, 'Identifier') && !isNodeOfType(node.key, 'Literal')) {
-    return false;
-  }
-  return true;
-}
 function getTokenNode(tokenName, fallbackValue) {
   var isFallbackMember = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
   var callExpressionArgs = [literal({
@@ -162,21 +116,4 @@ export function getTokenProperty(propertyName, tokenName, tokenFallback) {
     value: getTokenNode(tokenName, tokenFallback, isFallbackMember)
   });
 }
-export function getLiteralProperty(propertyName, propertyValue) {
-  return property({
-    key: identifier(propertyName),
-    value: literal(propertyValue)
-  });
-}
-export function convertPropertyNodeToStringableNode(node) {
-  return property({
-    key: node.key,
-    value: node.value
-  });
-}
-export function insertTokensImport(root, fixer) {
-  return Root.insertImport(root, {
-    module: '@atlaskit/tokens',
-    specifiers: ['token']
-  }, fixer);
-}
+export { isTypographyProperty } from './is-typography-property';

package/dist/esm/rules/use-visually-hidden/fix-jsx.js

@@ -1,7 +1,7 @@
 import { closestOfType } from 'eslint-codemod-utils';
-import { getImportedNodeBySource } from '../utils/get-import-node-by-source';
+import { getImportedNodeBySource } from '../utils/get-imported-node-by-source';
 import { IMPORT_NAME, VISUALLY_HIDDEN_IMPORT, VISUALLY_HIDDEN_SOURCE } from './constants';
-import { getFirstImport } from './utils';
+import { getFirstImport } from './get-first-import';
 var fixJsx = function fixJsx(source, node) {
   return function (fixer) {
     var fixes = [];

package/dist/esm/rules/use-visually-hidden/fix-vanilla.js

@@ -1,6 +1,6 @@
-import { getImportedNodeBySource } from '../utils/get-import-node-by-source';
+import { getImportedNodeBySource } from '../utils/get-imported-node-by-source';
 import { IMPORT_NAME, VISUALLY_HIDDEN_IMPORT, VISUALLY_HIDDEN_SOURCE } from './constants';
-import { getFirstImport } from './utils';
+import { getFirstImport } from './get-first-import';
 var fixVanilla = function fixVanilla(source, node) {
   return function (fixer) {
     var fixes = [];

package/dist/esm/rules/use-visually-hidden/get-first-import.js

@@ -0,0 +1,8 @@
+/**
+ * Returns the first import in the esprima AST.
+ */
+export var getFirstImport = function getFirstImport(source) {
+  return source.ast.body.find(function (node) {
+    return node.type === 'ImportDeclaration';
+  });
+};

package/dist/esm/rules/use-visually-hidden/index.js

@@ -2,10 +2,12 @@ import _slicedToArray from "@babel/runtime/helpers/slicedToArray";
 import { closestOfType, hasImportDeclaration, isNodeOfType } from 'eslint-codemod-utils';
 import { getDeclaredVariables, getSourceCode } from '@atlaskit/eslint-utils/context-compat';
 import { createLintRule } from '../utils/create-rule';
-import { isCssInJsObjectNode, isCssInJsTemplateNode } from '../utils/is-node';
+import { isCssInJsTemplateNode } from '../utils/is-css-in-js-template-node';
+import { isCssInJsObjectNode } from '../utils/is-node';
 import fixJsx from './fix-jsx';
 import fixVanilla from './fix-vanilla';
-import { countMatchingKeyValues, getObjectLikeness, makeTemplateLiteralIntoEntries } from './utils';
+import { makeTemplateLiteralIntoEntries } from './make-template-literal-into-entries';
+import { countMatchingKeyValues, getObjectLikeness } from './utils';
 var THEME_IMPORT_NAMES = ['visuallyHidden', 'assistive'];
 var rule = createLintRule({
   meta: {

package/dist/esm/rules/use-visually-hidden/make-template-literal-into-entries.js

@@ -0,0 +1,12 @@
+/**
+ * Takes a template literal and returns [key, value] array of the css properties
+ */
+export var makeTemplateLiteralIntoEntries = function makeTemplateLiteralIntoEntries(templateString) {
+  return templateString.replace(/\n/g, '').split(/;|{|}/).filter(function (el) {
+    return !el.match(/\@/);
+  }).map(function (el) {
+    return el.trim().split(':').map(function (e) {
+      return e.trim();
+    });
+  });
+};

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

@@ -9,28 +9,6 @@ var referenceObject = {
   overflow: 'hidden',
   whiteSpace: 'nowrap'
 };
-/**
- * Returns the first import in the esprima AST.
- */
-export var getFirstImport = function getFirstImport(source) {
-  return source.ast.body.find(function (node) {
-    return node.type === 'ImportDeclaration';
-  });
-};
-
-/**
- * Takes a template literal and returns [key, value] array of the css properties
- */
-export var makeTemplateLiteralIntoEntries = function makeTemplateLiteralIntoEntries(templateString) {
-  return templateString.replace(/\n/g, '').split(/;|{|}/).filter(function (el) {
-    return !el.match(/\@/);
-  }).map(function (el) {
-    return el.trim().split(':').map(function (e) {
-      return e.trim();
-    });
-  });
-};
-
 /**
  * Given a node, translate the node into css key-value pairs and
  * compare the output to the reference styles required to make a

package/dist/esm/rules/utils/find-prop.js

@@ -0,0 +1,6 @@
+export function findProp(jsx, propName) {
+  var labelProp = jsx.openingElement.attributes.find(function (attr) {
+    return attr.type === 'JSXAttribute' && attr.name.name === propName;
+  });
+  return labelProp;
+}

package/dist/esm/rules/utils/get-imported-node-by-source.js

@@ -0,0 +1,12 @@
+/**
+ * @param {SourceCode} source The eslint source
+ * @param {string} path The path specified to find
+ * @returns {ImportDeclaration}
+ */
+export var getImportedNodeBySource = function getImportedNodeBySource(source, path) {
+  return source.ast.body.filter(function (node) {
+    return node.type === 'ImportDeclaration';
+  }).find(function (node) {
+    return node.source.value === path;
+  });
+};

package/dist/esm/rules/utils/{get-import-node-by-source.js → get-module-of-identifier.js}

@@ -1,19 +1,6 @@
 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; }
-/**
- * @param {SourceCode} source The eslint source
- * @param {string} path The path specified to find
- * @returns {ImportDeclaration}
- */
-export var getImportedNodeBySource = function getImportedNodeBySource(source, path) {
-  return source.ast.body.filter(function (node) {
-    return node.type === 'ImportDeclaration';
-  }).find(function (node) {
-    return node.source.value === path;
-  });
-};
-
 /**
  * Returns the module name of an identifier, if one exists.
  *

package/dist/esm/rules/utils/is-child-of-type.js

@@ -0,0 +1,4 @@
+import { isNodeOfType } from 'eslint-codemod-utils';
+export var isChildOfType = function isChildOfType(node, type) {
+  return isNodeOfType(node.parent, type);
+};

package/dist/esm/rules/utils/is-color.js

@@ -1,4 +1,3 @@
-import { CURRENT_SURFACE_CSS_VAR } from '@atlaskit/tokens';
 var namedColors = new Set(['black', 'silver', 'gray', 'white', 'maroon', 'red', 'purple', 'fuchsia', 'green', 'lime', 'olive', 'yellow', 'navy', 'blue', 'teal', 'aqua', 'orange', 'aliceblue', 'antiquewhite', 'aquamarine', 'azure', 'beige', 'bisque', 'blanchedalmond', 'blueviolet', 'brown', 'burlywood', 'cadetblue', 'chartreuse', 'chocolate', 'coral', 'cornflowerblue', 'cornsilk', 'crimson', 'cyan', 'darkblue', 'darkcyan', 'darkgoldenrod', 'darkgray', 'darkgreen', 'darkgrey', 'darkkhaki', 'darkmagenta', 'darkolivegreen', 'darkorange', 'darkorchid', 'darkred', 'darksalmon', 'darkseagreen', 'darkslateblue', 'darkslategray', 'darkslategrey', 'darkturquoise', 'darkviolet', 'deeppink', 'deepskyblue', 'dimgray', 'dimgrey', 'dodgerblue', 'firebrick', 'floralwhite', 'forestgreen', 'gainsboro', 'ghostwhite', 'gold', 'goldenrod', 'greenyellow', 'grey', 'honeydew', 'hotpink', 'indianred', 'indigo', 'ivory', 'khaki', 'lavender', 'lavenderblush', 'lawngreen', 'lemonchiffon', 'lightblue', 'lightcoral', 'lightcyan', 'lightgoldenrodyellow', 'lightgray', 'lightgreen', 'lightgrey', 'lightpink', 'lightsalmon', 'lightseagreen', 'lightskyblue', 'lightslategray', 'lightslategrey', 'lightsteelblue', 'lightyellow', 'limegreen', 'linen', 'magenta', 'mediumaquamarine', 'mediumblue', 'mediumorchid', 'mediumpurple', 'mediumseagreen', 'mediumslateblue', 'mediumspringgreen', 'mediumturquoise', 'mediumvioletred', 'midnightblue', 'mintcream', 'mistyrose', 'moccasin', 'navajowhite', 'oldlace', 'olivedrab', 'orangered', 'orchid', 'palegoldenrod', 'palegreen', 'paleturquoise', 'palevioletred', 'papayawhip', 'peachpuff', 'peru', 'pink', 'plum', 'powderblue', 'rosybrown', 'royalblue', 'saddlebrown', 'salmon', 'sandybrown', 'seagreen', 'seashell', 'sienna', 'skyblue', 'slateblue', 'slategray', 'slategrey', 'snow', 'springgreen', 'steelblue', 'tan', 'thistle', 'tomato', 'turquoise', 'violet', 'wheat', 'whitesmoke', 'yellowgreen', 'rebeccapurple']);
 var legacyColors = new Set(['R50', 'R75', 'R100', 'R200', 'R300', 'R400', 'R500', 'Y50', 'Y75', 'Y100', 'Y200', 'Y300', 'Y400', 'Y500', 'G50', 'G75', 'G100', 'G200', 'G300', 'G400', 'G500', 'B50', 'B75', 'B100', 'B200', 'B300', 'B400', 'B500', 'P50', 'P75', 'P100', 'P200', 'P300', 'P400', 'P500', 'T50', 'T75', 'T100', 'T200', 'T300', 'T400', 'T500', 'N0', 'N10', 'N20', 'N30', 'N40', 'N50', 'N60', 'N70', 'N80', 'N90', 'N100', 'N200', 'N300', 'N400', 'N500', 'N600', 'N700', 'N800', 'N900', 'N10A', 'N20A', 'N30A', 'N40A', 'N50A', 'N60A', 'N70A', 'N80A', 'N90A', 'N100A', 'N200A', 'N300A', 'N400A', 'N500A', 'N600A', 'N700A', 'N800A', 'DN900', 'DN800', 'DN700', 'DN600', 'DN500', 'DN400', 'DN300', 'DN200', 'DN100', 'DN90', 'DN80', 'DN70', 'DN60', 'DN50', 'DN40', 'DN30', 'DN20', 'DN10', 'DN0', 'DN800A', 'DN700A', 'DN600A', 'DN500A', 'DN400A', 'DN300A', 'DN200A', 'DN100A', 'DN90A', 'DN80A', 'DN70A', 'DN60A', 'DN50A', 'DN40A', 'DN30A', 'DN20A', 'DN10A',
 // Legacy Trello colors:
@@ -48,7 +47,4 @@ var kebabize = function kebabize(str) {
 };
 export var isColorCssPropertyName = function isColorCssPropertyName(value) {
   return validColorPropertyNames.has(kebabize(value));
-};
-export var isCurrentSurfaceCustomPropertyName = function isCurrentSurfaceCustomPropertyName(value) {
-  return value === 'CURRENT_SURFACE_CSS_VAR' || value === CURRENT_SURFACE_CSS_VAR;
 };

package/dist/esm/rules/utils/is-css-in-js-template-node.js

@@ -0,0 +1,3 @@
+export var isCssInJsTemplateNode = function isCssInJsTemplateNode(node) {
+  return (node === null || node === void 0 ? void 0 : node.type) === 'TaggedTemplateExpression' && node.tag.type === 'MemberExpression' && node.tag.object.type === 'Identifier' && node.tag.object.name === 'styled';
+};

package/dist/esm/rules/utils/is-current-surface-custom-property-name.js

@@ -0,0 +1,4 @@
+import { CURRENT_SURFACE_CSS_VAR } from '@atlaskit/tokens';
+export var isCurrentSurfaceCustomPropertyName = function isCurrentSurfaceCustomPropertyName(value) {
+  return value === 'CURRENT_SURFACE_CSS_VAR' || value === CURRENT_SURFACE_CSS_VAR;
+};

package/dist/esm/rules/utils/is-decendant-of-global-token.js

@@ -0,0 +1,11 @@
+import { isNodeOfType } from 'eslint-codemod-utils';
+var _isDecendantOfGlobalToken = function isDecendantOfGlobalToken(node) {
+  if (isNodeOfType(node, 'CallExpression') && isNodeOfType(node.callee, 'Identifier') && (node.callee.name === 'token' || node.callee.name === 'getTokenValue')) {
+    return true;
+  }
+  if (node.parent) {
+    return _isDecendantOfGlobalToken(node.parent);
+  }
+  return false;
+};
+export { _isDecendantOfGlobalToken as isDecendantOfGlobalToken };