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

package/dist/es2019/rules/use-primitives/transformers/emotion-css/index.js

@@ -2,11 +2,17 @@
 
 import { getIdentifierInParentScope, isNodeOfType } from 'eslint-codemod-utils';
 import { getScope, getSourceCode } from '@atlaskit/eslint-utils/context-compat';
-import * as ast from '../../../../ast-nodes';
-import { getVariableDefinitionValue, getVariableUsagesCount, isValidCssPropertiesToTransform } from '../../utils';
+import { FunctionCall } from '../../../../ast-nodes/function-call';
+import { JSXAttribute as JSXAttributeHelper } from '../../../../ast-nodes/jsx-attribute';
+import { JSXElement as JSXElementHelper } from '../../../../ast-nodes/jsx-element';
+import { Root } from '../../../../ast-nodes/root';
+import { getVariableDefinitionValue } from '../../utils/get-variable-definition-value';
+import { getVariableUsagesCount } from '../../utils/get-variable-usage-count';
+import { isValidCssPropertiesToTransform } from '../../utils/is-valid-css-properties-to-transform';
 import { validateStyles } from '../../utils/validate-styles';
 import { cssToXcssTransformer } from '../css-to-xcss';
-import * as supported from './supported';
+import { attributes } from './attributes';
+import { elements } from './elements';
 export const EmotionCSS = {
   lint(node, {
     context,
@@ -44,29 +50,29 @@ export const EmotionCSS = {
     if (!isNodeOfType(node, 'JSXElement')) {
       return false;
     }
-    const elementName = ast.JSXElement.getName(node);
+    const elementName = JSXElementHelper.getName(node);
     if (!elementName) {
       return false;
     }
 
     // Currently we only support `div`. This may change in future.
-    if (!supported.elements.includes(elementName)) {
+    if (!elements.includes(elementName)) {
       return false;
     }
 
     // Ignore elements that contain dangerous attributes like `id`.
-    if (!ast.JSXElement.hasAllowedAttrsOnly(node, supported.attributes)) {
+    if (!JSXElementHelper.hasAllowedAttrsOnly(node, attributes)) {
       return false;
     }
 
     // Currently we don't transform anything to `Box` unless it defines styles
-    const cssAttr = ast.JSXElement.getAttributeByName(node, 'css');
+    const cssAttr = JSXElementHelper.getAttributeByName(node, 'css');
     if (!cssAttr) {
       return false;
     }
 
     // Get `myStyles` in `css={myStyles}` as a string so we can search for the `const myStyles` VariableDefinition
-    const cssAttrValue = ast.JSXAttribute.getValue(cssAttr);
+    const cssAttrValue = JSXAttributeHelper.getValue(cssAttr);
     if ((cssAttrValue === null || cssAttrValue === void 0 ? void 0 : cssAttrValue.type) !== 'ExpressionStatement') {
       return false;
     }
@@ -82,13 +88,13 @@ export const EmotionCSS = {
     const cssVariableDefinition = getIdentifierInParentScope(getScope(context, node), cssAttrValue.value);
     const cssVariableValue = getVariableDefinitionValue(cssVariableDefinition);
     // Check if `cssVariableValue` is a function called `css()`
-    if (ast.FunctionCall.getName(cssVariableValue === null || cssVariableValue === void 0 ? void 0 : cssVariableValue.node.init) !== 'css') {
+    if (FunctionCall.getName(cssVariableValue === null || cssVariableValue === void 0 ? void 0 : cssVariableValue.node.init) !== 'css') {
       return false;
     }
     if (!(config.patterns.includes('string-style-property-fix') ? validateStyles(cssVariableValue === null || cssVariableValue === void 0 ? void 0 : cssVariableValue.node.init, config) : isValidCssPropertiesToTransform(cssVariableValue === null || cssVariableValue === void 0 ? void 0 : cssVariableValue.node.init, config))) {
       return false;
     }
-    const importDeclaration = ast.Root.findImportsByModule(getSourceCode(context).ast.body, '@atlaskit/primitives');
+    const 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) {
@@ -100,13 +106,13 @@ export const EmotionCSS = {
     context
   }) {
     return fixer => {
-      const importFix = ast.Root.upsertNamedImportDeclaration({
+      const importFix = Root.upsertNamedImportDeclaration({
         module: '@atlaskit/primitives',
         specifiers: ['Box', 'xcss']
       }, context, fixer);
-      const cssAttr = ast.JSXElement.getAttributeByName(node, 'css'); // Can strongly assert the type here, because we validated it exists in `check()`.
-      const attributeFix = ast.JSXAttribute.updateName(cssAttr, 'xcss', fixer);
-      const elementNameFixes = ast.JSXElement.updateName(node, 'Box', fixer);
+      const cssAttr = JSXElementHelper.getAttributeByName(node, 'css'); // Can strongly assert the type here, because we validated it exists in `check()`.
+      const attributeFix = JSXAttributeHelper.updateName(cssAttr, 'xcss', fixer);
+      const elementNameFixes = JSXElementHelper.updateName(node, 'Box', fixer);
       const cssToXcssTransform = cssToXcssTransformer(node, context, fixer);
       return [importFix, attributeFix, ...elementNameFixes, ...cssToXcssTransform].filter(fix => Boolean(fix)); // Some of the transformers can return arrays with undefined, so filter them out
     };

package/dist/es2019/rules/use-primitives/transformers/space-token-map.js

@@ -0,0 +1,2 @@
+import { allSpaceMap } from '../../../common/token-maps.partial';
+export const spaceTokenMap = allSpaceMap;

package/dist/es2019/rules/use-primitives/transformers/space-token-positive-map.js

@@ -0,0 +1,2 @@
+import { positiveSpaceMap } from '../../../common/token-maps.partial';
+export const spaceTokenPositiveMap = positiveSpaceMap;

package/dist/es2019/rules/use-primitives/transformers/supported-dimension-attributes-map.js

@@ -0,0 +1,9 @@
+import { dimensionsMap } from './dimensions-map';
+export const supportedDimensionAttributesMap = {
+  width: dimensionsMap,
+  height: dimensionsMap,
+  minWidth: dimensionsMap,
+  minHeight: dimensionsMap,
+  maxWidth: dimensionsMap,
+  maxHeight: dimensionsMap
+};

package/dist/es2019/rules/use-primitives/utils/convert-ast-object-expression-to-js-object.js

@@ -1,5 +1,5 @@
 import { isNodeOfType } from 'eslint-codemod-utils';
-export const SPREAD_SYNTAX = Symbol('SPREAD_SYNTAX');
+import { SPREAD_SYNTAX } from './spread-syntax';
 /**
  * Note: Not recursive. Only handles top level key/value pairs
  */

package/dist/es2019/rules/use-primitives/utils/is-valid-css-properties-to-transform.js

@@ -1,6 +1,7 @@
 import { isNodeOfType } from 'eslint-codemod-utils';
-import * as ast from '../../../ast-nodes';
-import { supportedDimensionAttributesMap, supportedStylesMap } from '../transformers/css-to-xcss';
+import { Object as ObjectHelper } from '../../../ast-nodes/object';
+import { supportedStylesMap } from '../transformers/css-to-xcss';
+import { supportedDimensionAttributesMap } from '../transformers/supported-dimension-attributes-map';
 import { convertASTObjectExpressionToJSObject } from './convert-ast-object-expression-to-js-object';
 export const isValidCssPropertiesToTransform = (node, config) => {
   if (!node) {
@@ -11,12 +12,12 @@ export const isValidCssPropertiesToTransform = (node, config) => {
   if (!cssObjectExpression || !isNodeOfType(cssObjectExpression, 'ObjectExpression')) {
     return false;
   }
-  if (!ast.Object.isFlat(cssObjectExpression)) {
+  if (!ObjectHelper.isFlat(cssObjectExpression)) {
     return false;
   }
 
   // `use-primitives` should not report on empty style objects. See: https://product-fabric.atlassian.net/browse/DSP-16520
-  if (ast.Object.getEntries(cssObjectExpression).length === 0) {
+  if (ObjectHelper.getEntries(cssObjectExpression).length === 0) {
     return false;
   }
   const {

package/dist/es2019/rules/use-primitives/utils/spread-syntax.js

@@ -0,0 +1 @@
+export const SPREAD_SYNTAX = Symbol('SPREAD_SYNTAX');

package/dist/es2019/rules/use-primitives/utils/validate-styles.js

@@ -1,7 +1,10 @@
 import { isNodeOfType } from 'eslint-codemod-utils';
-import * as ast from '../../../ast-nodes';
-import { spaceTokenMap, supportedStylesMap } from '../transformers';
-import { supportedDimensionAttributesMap } from '../transformers/css-to-xcss';
+import { FunctionCall } from '../../../ast-nodes/function-call';
+import { Object as ObjectHelper } from '../../../ast-nodes/object';
+import { ObjectEntry } from '../../../ast-nodes/object-entry';
+import { supportedStylesMap } from '../transformers/css-to-xcss';
+import { spaceTokenMap } from '../transformers/space-token-map';
+import { supportedDimensionAttributesMap } from '../transformers/supported-dimension-attributes-map';
 export const validateStyles = (node, config) => {
   if (!node) {
     return false;
@@ -11,10 +14,10 @@ export const validateStyles = (node, config) => {
   if (!isNodeOfType(cssObjectExpression, 'ObjectExpression')) {
     return false;
   }
-  if (!ast.Object.isFlat(cssObjectExpression)) {
+  if (!ObjectHelper.isFlat(cssObjectExpression)) {
     return false;
   }
-  const entries = ast.Object.getEntries(cssObjectExpression);
+  const entries = ObjectHelper.getEntries(cssObjectExpression);
   if (entries.length === 0) {
     return false;
   }
@@ -35,7 +38,7 @@ export const validateStyles = (node, config) => {
     if (!isNodeOfType(key, 'Identifier')) {
       return false;
     }
-    const property = ast.ObjectEntry.getPropertyName(entry);
+    const property = ObjectEntry.getPropertyName(entry);
     if (!property) {
       return false;
     }
@@ -89,10 +92,10 @@ const isTokenCall = node => {
   }
 
   // Is the function called 'token'?
-  if (ast.FunctionCall.getName(node) !== 'token') {
+  if (FunctionCall.getName(node) !== 'token') {
     return false;
   }
-  const token = ast.FunctionCall.getArgumentAtPos(node, 0);
+  const token = FunctionCall.getArgumentAtPos(node, 0);
   if (!token || token.type !== 'Literal') {
     return false;
   }
@@ -104,7 +107,7 @@ const isTokenCall = node => {
 
   // Not all `token()` calls have a fall back. This is fine, but if there is a fallback, make sure it's the same as the fallback xcss will use
   if (node.arguments.length === 2) {
-    const fallback = ast.FunctionCall.getArgumentAtPos(node, 1);
+    const fallback = FunctionCall.getArgumentAtPos(node, 1);
 
     // `getArgumentAtPos` is only able to understand `Literal` and `ObjectExpression` statements
     // If there are 2 args, but `fallback` is undefined, then the fallback is something wild, like `token('space.100, `${gridSize * rem(3)`})`

package/dist/es2019/rules/use-primitives-text/index.js

@@ -1,7 +1,10 @@
 import { createLintRule } from '../utils/create-rule';
 import { errorBoundary } from '../utils/error-boundary';
 import { getConfig, PATTERNS } from './config';
-import { EmphasisElements, ParagraphElements, SpanElements, StrongElements } from './transformers';
+import { EmphasisElements } from './transformers/emphasis-elements';
+import { ParagraphElements } from './transformers/paragraph-elements';
+import { SpanElements } from './transformers/span-elements';
+import { StrongElements } from './transformers/strong-elements';
 const textDocsUrl = 'https://atlassian.design/components/primitives/text';
 const rule = createLintRule({
   meta: {

package/dist/es2019/rules/use-primitives-text/transformers/add-color-inherit-attribute-fix.js

@@ -0,0 +1,8 @@
+import { JSXElement as JSXElementHelper } from '../../../ast-nodes/jsx-element';
+// Add color="inherit" prop depending on config
+export function addColorInheritAttributeFix(node, config, fixer) {
+  if (!config.inheritColor) {
+    return;
+  }
+  return JSXElementHelper.addAttribute(node, 'color', 'inherit', fixer);
+}

package/dist/es2019/rules/use-primitives-text/transformers/allowed-attrs.js

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

package/dist/es2019/rules/use-primitives-text/transformers/common.js

@@ -1,40 +1 @@
-import { isNodeOfType } from 'eslint-codemod-utils';
-import * as ast from '../../../ast-nodes';
-// Rename data-testid prop to testId if present
-export function updateTestIdAttributeFix(node, fixer) {
-  const testIdAttr = ast.JSXElement.getAttributeByName(node, 'data-testid');
-  if (testIdAttr) {
-    return ast.JSXAttribute.updateName(testIdAttr, 'testId', fixer);
-  }
-}
-
-// Add color="inherit" prop depending on config
-export function addColorInheritAttributeFix(node, config, fixer) {
-  if (!config.inheritColor) {
-    return;
-  }
-  return ast.JSXElement.addAttribute(node, 'color', 'inherit', fixer);
-}
-export const allowedAttrs = ['id', 'data-testid', 'key'];
-
-// Only allow elements with strings as children
-// The use of `<FormattedMessage ... />` component and `{formatMessage(...)}` are allowed as these are used for i18n
-export function hasTextChildrenOnly(node) {
-  var _node$children;
-  return (_node$children = node.children) === null || _node$children === void 0 ? void 0 : _node$children.every(child => {
-    if (isNodeOfType(child, 'JSXText')) {
-      return true;
-    }
-
-    // JSX child element <span><FormattedMessage /></span>
-    if (isNodeOfType(child, 'JSXElement') && ast.JSXElement.getName(child) === 'FormattedMessage') {
-      return true;
-    }
-
-    // JSX expression <span>{formatMessage(...)}</span>
-    if (isNodeOfType(child, 'JSXExpressionContainer') && isNodeOfType(child.expression, 'CallExpression')) {
-      return ast.FunctionCall.getName(child.expression) === 'formatMessage';
-    }
-    return false;
-  });
-}
+export {};

package/dist/es2019/rules/use-primitives-text/transformers/emphasis-elements.js

@@ -2,8 +2,11 @@
 
 import { isNodeOfType } from 'eslint-codemod-utils';
 import { getSourceCode } from '@atlaskit/eslint-utils/context-compat';
-import * as ast from '../../../ast-nodes';
-import { addColorInheritAttributeFix, allowedAttrs, updateTestIdAttributeFix } from './common';
+import { JSXElement as JSXElementHelper } from '../../../ast-nodes/jsx-element';
+import { Root } from '../../../ast-nodes/root';
+import { addColorInheritAttributeFix } from './add-color-inherit-attribute-fix';
+import { allowedAttrs } from './allowed-attrs';
+import { updateTestIdAttributeFix } from './update-test-id-attribute-fix';
 export const EmphasisElements = {
   lint(node, {
     context,
@@ -54,7 +57,7 @@ export const EmphasisElements = {
         success: false
       };
     }
-    const elementName = ast.JSXElement.getName(node);
+    const elementName = JSXElementHelper.getName(node);
     if (elementName !== 'em') {
       return {
         success: false
@@ -67,7 +70,7 @@ export const EmphasisElements = {
     }
 
     // Element has no unallowed props
-    if (!ast.JSXElement.hasAllowedAttrsOnly(node, allowedAttrs)) {
+    if (!JSXElementHelper.hasAllowedAttrsOnly(node, allowedAttrs)) {
       return {
         success: true,
         autoFixable: false
@@ -75,7 +78,7 @@ export const EmphasisElements = {
     }
 
     // If there is more than one `@atlaskit/primitives` import, then it becomes difficult to determine which import to transform
-    const importDeclaration = ast.Root.findImportsByModule(getSourceCode(context).ast.body, '@atlaskit/primitives');
+    const importDeclaration = Root.findImportsByModule(getSourceCode(context).ast.body, '@atlaskit/primitives');
     if (importDeclaration.length > 1) {
       return {
         success: true,
@@ -92,12 +95,12 @@ export const EmphasisElements = {
     config
   }) {
     return fixer => {
-      const importFix = ast.Root.upsertNamedImportDeclaration({
+      const importFix = Root.upsertNamedImportDeclaration({
         module: '@atlaskit/primitives',
         specifiers: ['Text']
       }, context, fixer);
-      const elementNameFixes = ast.JSXElement.updateName(node, 'Text', fixer);
-      const asAttributeFix = ast.JSXElement.addAttribute(node, 'as', 'em', fixer);
+      const elementNameFixes = JSXElementHelper.updateName(node, 'Text', fixer);
+      const asAttributeFix = JSXElementHelper.addAttribute(node, 'as', 'em', fixer);
       const colorAttributeFix = addColorInheritAttributeFix(node, config, fixer);
       const testAttributeFix = updateTestIdAttributeFix(node, fixer);
       return [importFix, ...elementNameFixes, asAttributeFix, colorAttributeFix, testAttributeFix].filter(fix => Boolean(fix)); // Some of the transformers can return arrays with undefined, so filter them out

package/dist/es2019/rules/use-primitives-text/transformers/has-text-children-only.js

@@ -0,0 +1,24 @@
+import { isNodeOfType } from 'eslint-codemod-utils';
+import { FunctionCall } from '../../../ast-nodes/function-call';
+import { JSXElement as JSXElementHelper } from '../../../ast-nodes/jsx-element';
+
+// The use of `<FormattedMessage ... />` component and `{formatMessage(...)}` are allowed as these are used for i18n
+export function hasTextChildrenOnly(node) {
+  var _node$children;
+  return (_node$children = node.children) === null || _node$children === void 0 ? void 0 : _node$children.every(child => {
+    if (isNodeOfType(child, 'JSXText')) {
+      return true;
+    }
+
+    // JSX child element <span><FormattedMessage /></span>
+    if (isNodeOfType(child, 'JSXElement') && JSXElementHelper.getName(child) === 'FormattedMessage') {
+      return true;
+    }
+
+    // JSX expression <span>{formatMessage(...)}</span>
+    if (isNodeOfType(child, 'JSXExpressionContainer') && isNodeOfType(child.expression, 'CallExpression')) {
+      return FunctionCall.getName(child.expression) === 'formatMessage';
+    }
+    return false;
+  });
+}

package/dist/es2019/rules/use-primitives-text/transformers/paragraph-elements.js

@@ -2,8 +2,11 @@
 
 import { isNodeOfType } from 'eslint-codemod-utils';
 import { getSourceCode } from '@atlaskit/eslint-utils/context-compat';
-import * as ast from '../../../ast-nodes';
-import { addColorInheritAttributeFix, allowedAttrs, updateTestIdAttributeFix } from './common';
+import { JSXElement as JSXElementHelper } from '../../../ast-nodes/jsx-element';
+import { Root } from '../../../ast-nodes/root';
+import { addColorInheritAttributeFix } from './add-color-inherit-attribute-fix';
+import { allowedAttrs } from './allowed-attrs';
+import { updateTestIdAttributeFix } from './update-test-id-attribute-fix';
 export const ParagraphElements = {
   lint(node, {
     context,
@@ -90,7 +93,7 @@ export const ParagraphElements = {
         }
       };
     }
-    const elementName = ast.JSXElement.getName(node);
+    const elementName = JSXElementHelper.getName(node);
     if (elementName !== 'p') {
       return {
         success: false,
@@ -118,7 +121,7 @@ export const ParagraphElements = {
         }
       };
     }
-    const siblings = ast.JSXElement.getChildren(node.parent);
+    const siblings = JSXElementHelper.getChildren(node.parent);
     if (siblings.length > 1) {
       var _siblings$0$range, _node$range, _siblings$0$range2, _node$range2;
       // Only report for the first p element by comparing node location
@@ -136,10 +139,10 @@ export const ParagraphElements = {
         if (!isNodeOfType(child, 'JSXElement')) {
           return false;
         }
-        if (ast.JSXElement.getName(child) !== 'p') {
+        if (JSXElementHelper.getName(child) !== 'p') {
           return false;
         }
-        return ast.JSXElement.hasAllowedAttrsOnly(child, allowedAttrs);
+        return JSXElementHelper.hasAllowedAttrsOnly(child, allowedAttrs);
       });
       if (!siblingsMatch) {
         return {
@@ -150,7 +153,7 @@ export const ParagraphElements = {
           }
         };
       }
-    } else if (!ast.JSXElement.hasAllowedAttrsOnly(node, allowedAttrs)) {
+    } else if (!JSXElementHelper.hasAllowedAttrsOnly(node, allowedAttrs)) {
       return {
         success: true,
         autoFixable: false,
@@ -159,7 +162,7 @@ export const ParagraphElements = {
         }
       };
     }
-    const importDeclaration = ast.Root.findImportsByModule(getSourceCode(context).ast.body, '@atlaskit/primitives');
+    const 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) {
@@ -184,12 +187,12 @@ export const ParagraphElements = {
     config
   }) {
     return fixer => {
-      const importFix = ast.Root.upsertNamedImportDeclaration({
+      const importFix = Root.upsertNamedImportDeclaration({
         module: '@atlaskit/primitives',
         specifiers: ['Text']
       }, context, fixer);
-      const elementNameFixes = ast.JSXElement.updateName(node, 'Text', fixer);
-      const asAttributeFix = ast.JSXElement.addAttribute(node, 'as', 'p', fixer);
+      const elementNameFixes = JSXElementHelper.updateName(node, 'Text', fixer);
+      const asAttributeFix = JSXElementHelper.addAttribute(node, 'as', 'p', fixer);
       const colorAttributeFix = addColorInheritAttributeFix(node, config, fixer);
       const testAttributeFix = updateTestIdAttributeFix(node, fixer);
       return [importFix, ...elementNameFixes, asAttributeFix, colorAttributeFix, testAttributeFix].filter(fix => Boolean(fix)); // Some of the transformers can return arrays with undefined, so filter them out
@@ -204,7 +207,7 @@ export const ParagraphElements = {
       if (!isNodeOfType(node.parent, 'JSXElement') || !node.parent.closingElement) {
         return [];
       }
-      const importFix = ast.Root.upsertNamedImportDeclaration({
+      const importFix = Root.upsertNamedImportDeclaration({
         module: '@atlaskit/primitives',
         specifiers: ['Text', 'Stack']
       }, context, fixer);
@@ -212,8 +215,8 @@ export const ParagraphElements = {
       // Update all siblings elements and their attributes
       const siblingFixes = refs.siblings.map(sibling => {
         if (isNodeOfType(sibling, 'JSXElement')) {
-          const elementNameFixes = ast.JSXElement.updateName(sibling, 'Text', fixer);
-          const asAttributeFix = ast.JSXElement.addAttribute(sibling, 'as', 'p', fixer);
+          const elementNameFixes = JSXElementHelper.updateName(sibling, 'Text', fixer);
+          const asAttributeFix = JSXElementHelper.addAttribute(sibling, 'as', 'p', fixer);
           const colorAttributeFix = addColorInheritAttributeFix(sibling, config, fixer);
           const testAttributeFix = updateTestIdAttributeFix(sibling, fixer);
           return [...elementNameFixes, asAttributeFix, colorAttributeFix, testAttributeFix];

package/dist/es2019/rules/use-primitives-text/transformers/span-elements.js

@@ -2,8 +2,12 @@
 
 import { isNodeOfType } from 'eslint-codemod-utils';
 import { getSourceCode } from '@atlaskit/eslint-utils/context-compat';
-import * as ast from '../../../ast-nodes';
-import { addColorInheritAttributeFix, allowedAttrs, hasTextChildrenOnly, updateTestIdAttributeFix } from './common';
+import { JSXElement as JSXElementHelper } from '../../../ast-nodes/jsx-element';
+import { Root } from '../../../ast-nodes/root';
+import { addColorInheritAttributeFix } from './add-color-inherit-attribute-fix';
+import { allowedAttrs } from './allowed-attrs';
+import { hasTextChildrenOnly } from './has-text-children-only';
+import { updateTestIdAttributeFix } from './update-test-id-attribute-fix';
 export const SpanElements = {
   lint(node, {
     context,
@@ -54,7 +58,7 @@ export const SpanElements = {
         success: false
       };
     }
-    const elementName = ast.JSXElement.getName(node);
+    const elementName = JSXElementHelper.getName(node);
     if (elementName !== 'span') {
       return {
         success: false
@@ -74,7 +78,7 @@ export const SpanElements = {
     }
 
     // Element has no unallowed props
-    if (!ast.JSXElement.hasAllowedAttrsOnly(node, allowedAttrs)) {
+    if (!JSXElementHelper.hasAllowedAttrsOnly(node, allowedAttrs)) {
       return {
         success: true,
         autoFixable: false
@@ -82,7 +86,7 @@ export const SpanElements = {
     }
 
     // If there is more than one `@atlaskit/primitives` import, then it becomes difficult to determine which import to transform
-    const importDeclaration = ast.Root.findImportsByModule(getSourceCode(context).ast.body, '@atlaskit/primitives');
+    const importDeclaration = Root.findImportsByModule(getSourceCode(context).ast.body, '@atlaskit/primitives');
     if (importDeclaration.length > 1) {
       return {
         success: true,
@@ -99,11 +103,11 @@ export const SpanElements = {
     config
   }) {
     return fixer => {
-      const importFix = ast.Root.upsertNamedImportDeclaration({
+      const importFix = Root.upsertNamedImportDeclaration({
         module: '@atlaskit/primitives',
         specifiers: ['Text']
       }, context, fixer);
-      const elementNameFixes = ast.JSXElement.updateName(node, 'Text', fixer);
+      const elementNameFixes = JSXElementHelper.updateName(node, 'Text', fixer);
       const colorAttributeFix = addColorInheritAttributeFix(node, config, fixer);
       const testAttributeFix = updateTestIdAttributeFix(node, fixer);
       return [importFix, ...elementNameFixes, colorAttributeFix, testAttributeFix].filter(fix => Boolean(fix)); // Some of the transformers can return arrays with undefined, so filter them out

package/dist/es2019/rules/use-primitives-text/transformers/strong-elements.js

@@ -2,8 +2,11 @@
 
 import { isNodeOfType } from 'eslint-codemod-utils';
 import { getSourceCode } from '@atlaskit/eslint-utils/context-compat';
-import * as ast from '../../../ast-nodes';
-import { addColorInheritAttributeFix, allowedAttrs, updateTestIdAttributeFix } from './common';
+import { JSXElement as JSXElementHelper } from '../../../ast-nodes/jsx-element';
+import { Root } from '../../../ast-nodes/root';
+import { addColorInheritAttributeFix } from './add-color-inherit-attribute-fix';
+import { allowedAttrs } from './allowed-attrs';
+import { updateTestIdAttributeFix } from './update-test-id-attribute-fix';
 export const StrongElements = {
   lint(node, {
     context,
@@ -54,7 +57,7 @@ export const StrongElements = {
         success: false
       };
     }
-    const elementName = ast.JSXElement.getName(node);
+    const elementName = JSXElementHelper.getName(node);
     if (elementName !== 'strong') {
       return {
         success: false
@@ -67,7 +70,7 @@ export const StrongElements = {
     }
 
     // Element has no unallowed props
-    if (!ast.JSXElement.hasAllowedAttrsOnly(node, allowedAttrs)) {
+    if (!JSXElementHelper.hasAllowedAttrsOnly(node, allowedAttrs)) {
       return {
         success: true,
         autoFixable: false
@@ -75,7 +78,7 @@ export const StrongElements = {
     }
 
     // If there is more than one `@atlaskit/primitives` import, then it becomes difficult to determine which import to transform
-    const importDeclaration = ast.Root.findImportsByModule(getSourceCode(context).ast.body, '@atlaskit/primitives');
+    const importDeclaration = Root.findImportsByModule(getSourceCode(context).ast.body, '@atlaskit/primitives');
     if (importDeclaration.length > 1) {
       return {
         success: true,
@@ -92,12 +95,12 @@ export const StrongElements = {
     config
   }) {
     return fixer => {
-      const importFix = ast.Root.upsertNamedImportDeclaration({
+      const importFix = Root.upsertNamedImportDeclaration({
         module: '@atlaskit/primitives',
         specifiers: ['Text']
       }, context, fixer);
-      const elementNameFixes = ast.JSXElement.updateName(node, 'Text', fixer);
-      const asAttributeFix = ast.JSXElement.addAttribute(node, 'as', 'strong', fixer);
+      const elementNameFixes = JSXElementHelper.updateName(node, 'Text', fixer);
+      const asAttributeFix = JSXElementHelper.addAttribute(node, 'as', 'strong', fixer);
       const colorAttributeFix = addColorInheritAttributeFix(node, config, fixer);
       const testAttributeFix = updateTestIdAttributeFix(node, fixer);
       return [importFix, ...elementNameFixes, asAttributeFix, colorAttributeFix, testAttributeFix].filter(fix => Boolean(fix)); // Some of the transformers can return arrays with undefined, so filter them out

package/dist/es2019/rules/use-primitives-text/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) {
+  const testIdAttr = JSXElementHelper.getAttributeByName(node, 'data-testid');
+  if (testIdAttr) {
+    return JSXAttribute.updateName(testIdAttr, 'testId', fixer);
+  }
+}

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

@@ -1,5 +1,5 @@
 import { createLintRule } from '../utils/create-rule';
-import { ImportDeclaration } from './linters';
+import { ImportDeclaration } from './linters/import-declaration';
 const rule = createLintRule({
   meta: {
     name: 'use-spotlight-package',

package/dist/es2019/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';
 const messageId = 'noRawShapeValues';
@@ -49,7 +50,7 @@ export const StyleProperty = {
     }
     const {
       value: property
-    } = ast.ObjectEntry.getProperty(node);
+    } = ObjectEntry.getProperty(node);
 
     // Bail if the property is not `borderRadius`, `borderWidth`, etc
     if (!property || !styleMap[property]) {
@@ -58,7 +59,7 @@ export const StyleProperty = {
         ref: undefined
       };
     }
-    const value = ast.ObjectEntry.getValue(node);
+    const 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)) {
@@ -108,7 +109,7 @@ export const StyleProperty = {
    */
   _fix(ref, context) {
     return fixer => {
-      const importFix = ast.Root.upsertNamedImportDeclaration({
+      const importFix = Root.upsertNamedImportDeclaration({
         module: '@atlaskit/tokens',
         specifiers: ['token']
       }, context, fixer);

package/dist/es2019/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';
 const rule = createLintRule({
   meta: {
     name: 'use-tokens-space',