@atlaskit/eslint-plugin-design-system 8.34.0 → 8.36.1

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

@@ -3,7 +3,7 @@
 import { isNodeOfType } from 'eslint-codemod-utils';
 import * as ast from '../../../ast-nodes';
 import { upsertImportDeclaration } from '../../use-primitives/transformers/emotion-css/upsert-import-declaration';
-import { allowedAttrs, updateTestIdAttributeFix } from './common';
+import { addColorInheritAttributeFix, allowedAttrs, updateTestIdAttributeFix } from './common';
 export const StrongElements = {
   lint(node, {
     context,
@@ -26,7 +26,8 @@ export const StrongElements = {
       suggest: [{
         desc: `Convert to Text`,
         fix: StrongElements._fix(node, {
-          context
+          context,
+          config
         })
       }]
     });
@@ -56,7 +57,8 @@ export const StrongElements = {
     return true;
   },
   _fix(node, {
-    context
+    context,
+    config
   }) {
     return fixer => {
       const importFix = upsertImportDeclaration({
@@ -65,8 +67,9 @@ export const StrongElements = {
       }, context, fixer);
       const elementNameFixes = ast.JSXElement.updateName(node, 'Text', fixer);
       const asAttributeFix = ast.JSXElement.addAttribute(node, 'as', 'strong', fixer);
+      const colorAttributeFix = addColorInheritAttributeFix(node, config, fixer);
       const testAttributeFix = updateTestIdAttributeFix(node, fixer);
-      return [importFix, ...elementNameFixes, asAttributeFix, testAttributeFix].filter(fix => Boolean(fix)); // Some of the transformers can return arrays with undefined, so filter them out
+      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/utils/is-node.js

@@ -1,6 +1,7 @@
 // eslint-disable-next-line import/no-extraneous-dependencies
 
 import { isNodeOfType } from 'eslint-codemod-utils';
+import { Root } from '../../ast-nodes';
 export const isDecendantOfGlobalToken = node => {
   if (isNodeOfType(node, 'CallExpression') && isNodeOfType(node.callee, 'Identifier') && (node.callee.name === 'token' || node.callee.name === 'getTokenValue')) {
     return true;
@@ -47,6 +48,22 @@ export const isDecendantOfSvgElement = node => {
   }
   return false;
 };
+export const isDecendantOfPrimitive = (node, context) => {
+  const primitivesToCheck = ['Box', 'Text'];
+  if (isNodeOfType(node, 'JSXElement')) {
+    // @ts-ignore
+    if (primitivesToCheck.includes(node.openingElement.name.name)) {
+      const importDeclaration = Root.findImportsByModule(context.getSourceCode().ast.body, '@atlaskit/primitives');
+      if (importDeclaration.length) {
+        return true;
+      }
+    }
+  }
+  if (node.parent) {
+    return isDecendantOfPrimitive(node.parent, context);
+  }
+  return false;
+};
 const cssInJsCallees = ['css', 'styled', 'styled2'];
 export const isCssInJsTemplateNode = node => (node === null || node === void 0 ? void 0 : node.type) === 'TaggedTemplateExpression' && node.tag.type === 'MemberExpression' && node.tag.object.type === 'Identifier' && node.tag.object.name === 'styled';
 export const isCssInJsCallNode = node => (node === null || node === void 0 ? void 0 : node.type) === 'CallExpression' && node.callee.type === 'Identifier' && cssInJsCallees.includes(node.callee.name);

package/dist/esm/rules/ensure-design-token-usage/color.js

@@ -4,7 +4,7 @@ import { node as generate, isNodeOfType } from 'eslint-codemod-utils';
 import { getIsException } from '../utils/get-is-exception';
 import { includesHardCodedColor, isHardCodedColor, isLegacyColor, isLegacyNamedColor } from '../utils/is-color';
 import { isLegacyElevation } from '../utils/is-elevation';
-import { isChildOfType, isDecendantOfGlobalToken, isDecendantOfStyleBlock, isDecendantOfSvgElement } from '../utils/is-node';
+import { isChildOfType, isDecendantOfGlobalToken, isDecendantOfPrimitive, isDecendantOfStyleBlock, isDecendantOfSvgElement } from '../utils/is-node';
 // TemplateLiteral > Identifier
 export var lintTemplateIdentifierForColor = function lintTemplateIdentifierForColor(node, context, config) {
   if (node.type !== 'Identifier') {
@@ -137,6 +137,11 @@ export var lintJSXLiteralForColor = function lintJSXLiteralForColor(node, contex
   if (isDecendantOfSvgElement(node.parent)) {
     return;
   }
+
+  // Box backgroundColor prop accepts token names directly - don't lint against this
+  if (isDecendantOfPrimitive(node.parent, context)) {
+    return;
+  }
   if (['alt', 'src', 'label', 'key'].includes(node.parent.name.name)) {
     return;
   }

package/dist/esm/rules/use-primitives/transformers/compiled-styled/find-valid-jsx-usage-to-transform.js

@@ -1,10 +1,15 @@
+import _slicedToArray from "@babel/runtime/helpers/slicedToArray";
 import { isNodeOfType } from 'eslint-codemod-utils';
-
+var JSX_IDENTIFIER = 'JSXIdentifier';
 /**
  * Given a component name finds its JSX usages and performs some
  * additional validations to ensure transformation can be done correctly
+ *
+ * anyOrder: if true, the order of the references doesn't matter (JSX or style declaration)
  */
 export var findValidJsxUsageToTransform = function findValidJsxUsageToTransform(componentName, scope) {
+  var _variableDeclaration$;
+  var anyOrder = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
   var variableDeclaration = scope.variables.find(function (v) {
     return v.name === componentName;
   });
@@ -20,7 +25,23 @@ export var findValidJsxUsageToTransform = function findValidJsxUsageToTransform(
   if (variableDeclaration.references.length !== 2) {
     return;
   }
-  var jsxUsage = variableDeclaration.references[1].identifier;
+  var jsxUsage = (_variableDeclaration$ = variableDeclaration.references[1]) === null || _variableDeclaration$ === void 0 ? void 0 : _variableDeclaration$.identifier;
+  if (anyOrder) {
+    var _variableDeclaration$2 = variableDeclaration.references.map(function (ref) {
+        return ref === null || ref === void 0 ? void 0 : ref.identifier;
+      }),
+      _variableDeclaration$3 = _slicedToArray(_variableDeclaration$2, 2),
+      firstIdentifier = _variableDeclaration$3[0],
+      secondIdentifier = _variableDeclaration$3[1];
+    // Check if the first reference is a JSXOpeningElement and the second is not or vice versa
+    if (isNodeOfType(firstIdentifier, JSX_IDENTIFIER) && !isNodeOfType(secondIdentifier, JSX_IDENTIFIER)) {
+      jsxUsage = firstIdentifier;
+    } else if (isNodeOfType(secondIdentifier, JSX_IDENTIFIER) && !isNodeOfType(firstIdentifier, JSX_IDENTIFIER)) {
+      jsxUsage = secondIdentifier;
+    } else {
+      return;
+    }
+  }
   if (!isNodeOfType(jsxUsage, 'JSXIdentifier')) {
     return;
   }

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

@@ -55,7 +55,8 @@ export var CompiledStyled = {
         success: false
       };
     }
-    var styledComponentJsxRef = findValidJsxUsageToTransform(styledComponentVariableRef.id.name, context.getScope());
+    var anyOrder = config.patterns.includes('jsx-order-fix');
+    var styledComponentJsxRef = findValidJsxUsageToTransform(styledComponentVariableRef.id.name, context.getScope(), anyOrder);
     if (!styledComponentJsxRef) {
       return {
         success: false

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

@@ -1,5 +1,6 @@
 var defaults = {
-  patterns: ['paragraph-elements', 'span-elements', 'strong-elements', 'emphasis-elements']
+  patterns: ['paragraph-elements', 'span-elements', 'strong-elements', 'emphasis-elements'],
+  inheritColor: false
 };
 export var getConfig = function getConfig(overrides) {
   // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/assign

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

@@ -1,6 +1,5 @@
 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) {
   var testIdAttr = ast.JSXElement.getAttributeByName(node, 'data-testid');
@@ -8,10 +7,18 @@ export function updateTestIdAttributeFix(node, fixer) {
     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 var 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
+// 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(function (child) {

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

@@ -4,7 +4,7 @@ import _toConsumableArray from "@babel/runtime/helpers/toConsumableArray";
 import { isNodeOfType } from 'eslint-codemod-utils';
 import * as ast from '../../../ast-nodes';
 import { upsertImportDeclaration } from '../../use-primitives/transformers/emotion-css/upsert-import-declaration';
-import { allowedAttrs, updateTestIdAttributeFix } from './common';
+import { addColorInheritAttributeFix, allowedAttrs, updateTestIdAttributeFix } from './common';
 export var EmphasisElements = {
   lint: function lint(node, _ref) {
     var context = _ref.context,
@@ -26,7 +26,8 @@ export var EmphasisElements = {
       suggest: [{
         desc: "Convert to Text",
         fix: EmphasisElements._fix(node, {
-          context: context
+          context: context,
+          config: config
         })
       }]
     });
@@ -55,7 +56,8 @@ export var EmphasisElements = {
     return true;
   },
   _fix: function _fix(node, _ref3) {
-    var context = _ref3.context;
+    var context = _ref3.context,
+      config = _ref3.config;
     return function (fixer) {
       var importFix = upsertImportDeclaration({
         module: '@atlaskit/primitives',
@@ -63,8 +65,9 @@ export var EmphasisElements = {
       }, context, fixer);
       var elementNameFixes = ast.JSXElement.updateName(node, 'Text', fixer);
       var asAttributeFix = ast.JSXElement.addAttribute(node, 'as', 'em', fixer);
+      var colorAttributeFix = addColorInheritAttributeFix(node, config, fixer);
       var testAttributeFix = updateTestIdAttributeFix(node, fixer);
-      return [importFix].concat(_toConsumableArray(elementNameFixes), [asAttributeFix, testAttributeFix]).filter(function (fix) {
+      return [importFix].concat(_toConsumableArray(elementNameFixes), [asAttributeFix, colorAttributeFix, testAttributeFix]).filter(function (fix) {
         return Boolean(fix);
       }); // Some of the transformers can return arrays with undefined, so filter them out
     };

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

@@ -4,7 +4,7 @@ import _toConsumableArray from "@babel/runtime/helpers/toConsumableArray";
 import { isNodeOfType } from 'eslint-codemod-utils';
 import * as ast from '../../../ast-nodes';
 import { upsertImportDeclaration } from '../../use-primitives/transformers/emotion-css/upsert-import-declaration';
-import { allowedAttrs, updateTestIdAttributeFix } from './common';
+import { addColorInheritAttributeFix, allowedAttrs, updateTestIdAttributeFix } from './common';
 export var ParagraphElements = {
   lint: function lint(node, _ref) {
     var context = _ref.context,
@@ -43,6 +43,7 @@ export var ParagraphElements = {
           desc: 'Convert to Text and Stack',
           fix: ParagraphElements._fixMultiple(node, {
             context: context,
+            config: config,
             refs: refs
           })
         }]
@@ -54,7 +55,8 @@ export var ParagraphElements = {
         suggest: [{
           desc: 'Convert to Text',
           fix: ParagraphElements._fixSingle(node, {
-            context: context
+            context: context,
+            config: config
           })
         }]
       });
@@ -120,6 +122,13 @@ export var ParagraphElements = {
           }
         };
       }
+    } else if (!ast.JSXElement.hasAllowedAttrsOnly(node, allowedAttrs)) {
+      return {
+        success: false,
+        refs: {
+          siblings: siblings
+        }
+      };
     }
     var importDeclaration = ast.Root.findImportsByModule(context.getSourceCode().ast.body, '@atlaskit/primitives');
 
@@ -140,21 +149,25 @@ export var ParagraphElements = {
     };
   },
   _fixSingle: function _fixSingle(node, _ref3) {
-    var context = _ref3.context;
+    var context = _ref3.context,
+      config = _ref3.config;
     return function (fixer) {
       var importFix = upsertImportDeclaration({
         module: '@atlaskit/primitives',
         specifiers: ['Text']
       }, context, fixer);
       var elementNameFixes = ast.JSXElement.updateName(node, 'Text', fixer);
+      var asAttributeFix = ast.JSXElement.addAttribute(node, 'as', 'p', fixer);
+      var colorAttributeFix = addColorInheritAttributeFix(node, config, fixer);
       var testAttributeFix = updateTestIdAttributeFix(node, fixer);
-      return [importFix].concat(_toConsumableArray(elementNameFixes), [testAttributeFix]).filter(function (fix) {
+      return [importFix].concat(_toConsumableArray(elementNameFixes), [asAttributeFix, colorAttributeFix, testAttributeFix]).filter(function (fix) {
         return Boolean(fix);
       }); // Some of the transformers can return arrays with undefined, so filter them out
     };
   },
   _fixMultiple: function _fixMultiple(node, _ref4) {
     var context = _ref4.context,
+      config = _ref4.config,
       refs = _ref4.refs;
     return function (fixer) {
       if (!isNodeOfType(node.parent, 'JSXElement') || !node.parent.closingElement) {
@@ -169,8 +182,10 @@ export var ParagraphElements = {
       var siblingFixes = refs.siblings.map(function (sibling) {
         if (isNodeOfType(sibling, 'JSXElement')) {
           var elementNameFixes = ast.JSXElement.updateName(sibling, 'Text', fixer);
+          var asAttributeFix = ast.JSXElement.addAttribute(sibling, 'as', 'p', fixer);
+          var colorAttributeFix = addColorInheritAttributeFix(sibling, config, fixer);
           var testAttributeFix = updateTestIdAttributeFix(sibling, fixer);
-          return [].concat(_toConsumableArray(elementNameFixes), [testAttributeFix]);
+          return [].concat(_toConsumableArray(elementNameFixes), [asAttributeFix, colorAttributeFix, testAttributeFix]);
         }
         return undefined;
       }).flat();

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

@@ -4,7 +4,7 @@ import _toConsumableArray from "@babel/runtime/helpers/toConsumableArray";
 import { isNodeOfType } from 'eslint-codemod-utils';
 import * as ast from '../../../ast-nodes';
 import { upsertImportDeclaration } from '../../use-primitives/transformers/emotion-css/upsert-import-declaration';
-import { allowedAttrs, hasTextChildrenOnly, updateTestIdAttributeFix } from './common';
+import { addColorInheritAttributeFix, allowedAttrs, hasTextChildrenOnly, updateTestIdAttributeFix } from './common';
 export var SpanElements = {
   lint: function lint(node, _ref) {
     var context = _ref.context,
@@ -26,7 +26,8 @@ export var SpanElements = {
       suggest: [{
         desc: "Convert to Text",
         fix: SpanElements._fix(node, {
-          context: context
+          context: context,
+          config: config
         })
       }]
     });
@@ -60,16 +61,17 @@ export var SpanElements = {
     return true;
   },
   _fix: function _fix(node, _ref3) {
-    var context = _ref3.context;
+    var context = _ref3.context,
+      config = _ref3.config;
     return function (fixer) {
       var importFix = upsertImportDeclaration({
         module: '@atlaskit/primitives',
         specifiers: ['Text']
       }, context, fixer);
       var elementNameFixes = ast.JSXElement.updateName(node, 'Text', fixer);
-      var variantAttributeFix = ast.JSXElement.addAttribute(node, 'variant', 'ui', fixer);
+      var colorAttributeFix = addColorInheritAttributeFix(node, config, fixer);
       var testAttributeFix = updateTestIdAttributeFix(node, fixer);
-      return [importFix].concat(_toConsumableArray(elementNameFixes), [variantAttributeFix, testAttributeFix]).filter(function (fix) {
+      return [importFix].concat(_toConsumableArray(elementNameFixes), [colorAttributeFix, testAttributeFix]).filter(function (fix) {
         return Boolean(fix);
       }); // Some of the transformers can return arrays with undefined, so filter them out
     };

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

@@ -4,7 +4,7 @@ import _toConsumableArray from "@babel/runtime/helpers/toConsumableArray";
 import { isNodeOfType } from 'eslint-codemod-utils';
 import * as ast from '../../../ast-nodes';
 import { upsertImportDeclaration } from '../../use-primitives/transformers/emotion-css/upsert-import-declaration';
-import { allowedAttrs, updateTestIdAttributeFix } from './common';
+import { addColorInheritAttributeFix, allowedAttrs, updateTestIdAttributeFix } from './common';
 export var StrongElements = {
   lint: function lint(node, _ref) {
     var context = _ref.context,
@@ -26,7 +26,8 @@ export var StrongElements = {
       suggest: [{
         desc: "Convert to Text",
         fix: StrongElements._fix(node, {
-          context: context
+          context: context,
+          config: config
         })
       }]
     });
@@ -55,7 +56,8 @@ export var StrongElements = {
     return true;
   },
   _fix: function _fix(node, _ref3) {
-    var context = _ref3.context;
+    var context = _ref3.context,
+      config = _ref3.config;
     return function (fixer) {
       var importFix = upsertImportDeclaration({
         module: '@atlaskit/primitives',
@@ -63,8 +65,9 @@ export var StrongElements = {
       }, context, fixer);
       var elementNameFixes = ast.JSXElement.updateName(node, 'Text', fixer);
       var asAttributeFix = ast.JSXElement.addAttribute(node, 'as', 'strong', fixer);
+      var colorAttributeFix = addColorInheritAttributeFix(node, config, fixer);
       var testAttributeFix = updateTestIdAttributeFix(node, fixer);
-      return [importFix].concat(_toConsumableArray(elementNameFixes), [asAttributeFix, testAttributeFix]).filter(function (fix) {
+      return [importFix].concat(_toConsumableArray(elementNameFixes), [asAttributeFix, colorAttributeFix, testAttributeFix]).filter(function (fix) {
         return Boolean(fix);
       }); // Some of the transformers can return arrays with undefined, so filter them out
     };

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

@@ -1,6 +1,7 @@
 // eslint-disable-next-line import/no-extraneous-dependencies
 
 import { isNodeOfType } from 'eslint-codemod-utils';
+import { Root } from '../../ast-nodes';
 export var isDecendantOfGlobalToken = function isDecendantOfGlobalToken(node) {
   if (isNodeOfType(node, 'CallExpression') && isNodeOfType(node.callee, 'Identifier') && (node.callee.name === 'token' || node.callee.name === 'getTokenValue')) {
     return true;
@@ -48,6 +49,22 @@ export var isDecendantOfSvgElement = function isDecendantOfSvgElement(node) {
   }
   return false;
 };
+export var isDecendantOfPrimitive = function isDecendantOfPrimitive(node, context) {
+  var primitivesToCheck = ['Box', 'Text'];
+  if (isNodeOfType(node, 'JSXElement')) {
+    // @ts-ignore
+    if (primitivesToCheck.includes(node.openingElement.name.name)) {
+      var importDeclaration = Root.findImportsByModule(context.getSourceCode().ast.body, '@atlaskit/primitives');
+      if (importDeclaration.length) {
+        return true;
+      }
+    }
+  }
+  if (node.parent) {
+    return isDecendantOfPrimitive(node.parent, context);
+  }
+  return false;
+};
 var cssInJsCallees = ['css', 'styled', 'styled2'];
 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/types/rules/use-primitives/config/index.d.ts

@@ -1,4 +1,4 @@
-type Pattern = 'compiled-css-function' | 'compiled-styled-object' | 'css-template-literal' | 'css-property-with-tokens' | 'css-property-multiple-values' | 'multiple-properties' | 'dimension-properties';
+type Pattern = 'compiled-css-function' | 'compiled-styled-object' | 'css-template-literal' | 'css-property-with-tokens' | 'css-property-multiple-values' | 'multiple-properties' | 'dimension-properties' | 'jsx-order-fix';
 export interface RuleConfig {
     patterns: Pattern[];
 }

package/dist/types/rules/use-primitives/transformers/compiled-styled/find-valid-jsx-usage-to-transform.d.ts

@@ -3,5 +3,7 @@ import { JSXOpeningElement } from 'eslint-codemod-utils';
 /**
  * Given a component name finds its JSX usages and performs some
  * additional validations to ensure transformation can be done correctly
+ *
+ * anyOrder: if true, the order of the references doesn't matter (JSX or style declaration)
  */
-export declare const findValidJsxUsageToTransform: (componentName: string, scope: Scope.Scope) => (JSXOpeningElement & Rule.NodeParentExtension) | undefined;
+export declare const findValidJsxUsageToTransform: (componentName: string, scope: Scope.Scope, anyOrder?: boolean) => (JSXOpeningElement & Rule.NodeParentExtension) | undefined;

package/dist/types/rules/use-primitives/transformers/compiled-styled/index.d.ts

@@ -20,6 +20,6 @@ export declare const CompiledStyled: {
      * All required validation steps have been taken care of before this
      * transformer is called, so it just goes ahead providing all necessary fixes
      */
-    _fix(refs: Refs, context: Rule.RuleContext): (fixer: Rule.RuleFixer) => Rule.Fix[];
+    _fix(refs: Refs, context: Rule.RuleContext): Rule.ReportFixer;
 };
 export {};

package/dist/types/rules/use-primitives/transformers/emotion-css/index.d.ts

@@ -5,12 +5,11 @@ interface MetaData {
     context: Rule.RuleContext;
     config: RuleConfig;
 }
-type FixFunction = (fixer: Rule.RuleFixer) => Rule.Fix[];
 export declare const EmotionCSS: {
     lint(node: Rule.Node, { context, config }: MetaData): void;
     _check(node: Rule.Node, { context, config }: MetaData): boolean;
     _fix(node: JSXElement, { context }: {
         context: Rule.RuleContext;
-    }): FixFunction;
+    }): Rule.ReportFixer;
 };
 export {};

package/dist/types/rules/use-primitives-text/config/index.d.ts

@@ -1,6 +1,7 @@
 type Pattern = 'paragraph-elements' | 'span-elements' | 'strong-elements' | 'emphasis-elements';
 export interface RuleConfig {
     patterns: Pattern[];
+    inheritColor: boolean;
 }
 export declare const getConfig: (overrides: Partial<RuleConfig>) => Required<RuleConfig>;
 export {};

package/dist/types/rules/use-primitives-text/transformers/common.d.ts

@@ -1,5 +1,11 @@
 import type { Rule } from 'eslint';
 import { JSXElement } from 'eslint-codemod-utils';
+import { RuleConfig } from '../config';
+export type MetaData = {
+    context: Rule.RuleContext;
+    config: RuleConfig;
+};
 export declare function updateTestIdAttributeFix(node: JSXElement, fixer: Rule.RuleFixer): Rule.Fix | undefined;
+export declare function addColorInheritAttributeFix(node: JSXElement, config: RuleConfig, fixer: Rule.RuleFixer): Rule.Fix | undefined;
 export declare const allowedAttrs: string[];
 export declare function hasTextChildrenOnly(node: JSXElement): boolean;

package/dist/types/rules/use-primitives-text/transformers/emphasis-elements.d.ts

@@ -1,16 +1,8 @@
 import type { Rule } from 'eslint';
 import { JSXElement } from 'eslint-codemod-utils';
-import { RuleConfig } from '../config';
-interface MetaData {
-    context: Rule.RuleContext;
-    config: RuleConfig;
-}
-type FixFunction = (fixer: Rule.RuleFixer) => Rule.Fix[];
+import { type MetaData } from './common';
 export declare const EmphasisElements: {
     lint(node: Rule.Node, { context, config }: MetaData): void;
     _check(node: JSXElement, { context, config }: MetaData): boolean;
-    _fix(node: JSXElement, { context }: {
-        context: Rule.RuleContext;
-    }): FixFunction;
+    _fix(node: JSXElement, { context, config }: MetaData): Rule.ReportFixer;
 };
-export {};

package/dist/types/rules/use-primitives-text/transformers/paragraph-elements.d.ts

@@ -1,17 +1,12 @@
 import type { Rule } from 'eslint';
 import { JSXElement } from 'eslint-codemod-utils';
-import { RuleConfig } from '../config';
-type MetaData = {
-    context: Rule.RuleContext;
-    config: RuleConfig;
-};
+import { type MetaData } from './common';
 type CheckResult = {
     success: boolean;
     refs: {
         siblings: JSXElement['children'];
     };
 };
-type FixFunction = (fixer: Rule.RuleFixer) => Rule.Fix[];
 export declare const ParagraphElements: {
     lint(node: Rule.Node, { context, config }: MetaData): void;
     _check(node: JSXElement & {
@@ -19,14 +14,11 @@ export declare const ParagraphElements: {
     }, { context, config }: MetaData): CheckResult;
     _fixSingle(node: JSXElement & {
         parent: Rule.Node;
-    }, { context }: {
-        context: Rule.RuleContext;
-    }): FixFunction;
+    }, { context, config }: MetaData): Rule.ReportFixer;
     _fixMultiple(node: JSXElement & {
         parent: Rule.Node;
-    }, { context, refs }: {
-        context: Rule.RuleContext;
+    }, { context, config, refs }: MetaData & {
         refs: CheckResult['refs'];
-    }): FixFunction;
+    }): Rule.ReportFixer;
 };
 export {};

package/dist/types/rules/use-primitives-text/transformers/span-elements.d.ts

@@ -1,16 +1,8 @@
 import type { Rule } from 'eslint';
 import { JSXElement } from 'eslint-codemod-utils';
-import { RuleConfig } from '../config';
-interface MetaData {
-    context: Rule.RuleContext;
-    config: RuleConfig;
-}
-type FixFunction = (fixer: Rule.RuleFixer) => Rule.Fix[];
+import { type MetaData } from './common';
 export declare const SpanElements: {
     lint(node: Rule.Node, { context, config }: MetaData): void;
     _check(node: JSXElement, { context, config }: MetaData): boolean;
-    _fix(node: JSXElement, { context }: {
-        context: Rule.RuleContext;
-    }): FixFunction;
+    _fix(node: JSXElement, { context, config }: MetaData): Rule.ReportFixer;
 };
-export {};

package/dist/types/rules/use-primitives-text/transformers/strong-elements.d.ts

@@ -1,16 +1,8 @@
 import type { Rule } from 'eslint';
 import { JSXElement } from 'eslint-codemod-utils';
-import { RuleConfig } from '../config';
-interface MetaData {
-    context: Rule.RuleContext;
-    config: RuleConfig;
-}
-type FixFunction = (fixer: Rule.RuleFixer) => Rule.Fix[];
+import { type MetaData } from './common';
 export declare const StrongElements: {
     lint(node: Rule.Node, { context, config }: MetaData): void;
     _check(node: JSXElement, { context, config }: MetaData): boolean;
-    _fix(node: JSXElement, { context }: {
-        context: Rule.RuleContext;
-    }): FixFunction;
+    _fix(node: JSXElement, { context, config }: MetaData): Rule.ReportFixer;
 };
-export {};

package/dist/types/rules/use-tokens-typography/utils.d.ts

@@ -126,6 +126,39 @@ export declare const fontFamilyTokens: ({
     name: string;
     path: string[];
     cleanName: string;
+} | {
+    attributes: {
+        group: string;
+        state: string;
+        introduced: string;
+        deprecated: string;
+        description: string;
+        responsiveSmallerVariant?: undefined;
+    };
+    value: string;
+    filePath: string;
+    isSource: boolean;
+    original: {
+        attributes: {
+            group: string;
+            state: string;
+            introduced: string;
+            deprecated: string;
+            description: string;
+            responsiveSmallerVariant?: undefined;
+        };
+        value: {
+            fontWeight: string;
+            fontSize: string;
+            lineHeight: string;
+            fontFamily: string;
+            fontStyle: string;
+            letterSpacing: string;
+        };
+    };
+    name: string;
+    path: string[];
+    cleanName: string;
 } | {
     attributes: {
         group: string;

package/dist/types/rules/utils/is-node.d.ts

@@ -5,6 +5,7 @@ export declare const isDecendantOfType: (node: Rule.Node, type: Rule.Node['type'
 export declare const isPropertyKey: (node: Rule.Node) => boolean;
 export declare const isDecendantOfStyleJsxAttribute: (node: Rule.Node) => boolean;
 export declare const isDecendantOfSvgElement: (node: Rule.Node) => boolean;
+export declare const isDecendantOfPrimitive: (node: Rule.Node, context: Rule.RuleContext) => boolean;
 export declare const isCssInJsTemplateNode: (node?: Expression | null) => node is TaggedTemplateExpression;
 export declare const isCssInJsCallNode: (node?: Expression | null) => node is CallExpression;
 export declare const isCssInJsObjectNode: (node?: Expression | null) => node is CallExpression;

package/dist/types-ts4.5/rules/use-primitives/config/index.d.ts

@@ -1,4 +1,4 @@
-type Pattern = 'compiled-css-function' | 'compiled-styled-object' | 'css-template-literal' | 'css-property-with-tokens' | 'css-property-multiple-values' | 'multiple-properties' | 'dimension-properties';
+type Pattern = 'compiled-css-function' | 'compiled-styled-object' | 'css-template-literal' | 'css-property-with-tokens' | 'css-property-multiple-values' | 'multiple-properties' | 'dimension-properties' | 'jsx-order-fix';
 export interface RuleConfig {
     patterns: Pattern[];
 }

package/dist/types-ts4.5/rules/use-primitives/transformers/compiled-styled/find-valid-jsx-usage-to-transform.d.ts

@@ -3,5 +3,7 @@ import { JSXOpeningElement } from 'eslint-codemod-utils';
 /**
  * Given a component name finds its JSX usages and performs some
  * additional validations to ensure transformation can be done correctly
+ *
+ * anyOrder: if true, the order of the references doesn't matter (JSX or style declaration)
  */
-export declare const findValidJsxUsageToTransform: (componentName: string, scope: Scope.Scope) => (JSXOpeningElement & Rule.NodeParentExtension) | undefined;
+export declare const findValidJsxUsageToTransform: (componentName: string, scope: Scope.Scope, anyOrder?: boolean) => (JSXOpeningElement & Rule.NodeParentExtension) | undefined;