@atlaskit/eslint-plugin-design-system 8.29.1 → 8.31.0

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

@@ -0,0 +1,72 @@
+import _toConsumableArray from "@babel/runtime/helpers/toConsumableArray";
+/* eslint-disable @repo/internal/react/require-jsdoc */
+
+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';
+export var EmphasisElements = {
+  lint: function lint(node, _ref) {
+    var context = _ref.context,
+      config = _ref.config;
+    if (!isNodeOfType(node, 'JSXElement')) {
+      return;
+    }
+
+    // Check whether all criteria needed to make a transformation are met
+    if (!EmphasisElements._check(node, {
+      context: context,
+      config: config
+    })) {
+      return;
+    }
+    context.report({
+      node: node.openingElement,
+      messageId: 'preferPrimitivesText',
+      suggest: [{
+        desc: "Convert to Text",
+        fix: EmphasisElements._fix(node, {
+          context: context
+        })
+      }]
+    });
+  },
+  _check: function _check(node, _ref2) {
+    var context = _ref2.context,
+      config = _ref2.config;
+    if (!config.patterns.includes('emphasis-elements')) {
+      return false;
+    }
+    var elementName = ast.JSXElement.getName(node);
+    if (elementName !== 'em') {
+      return false;
+    }
+
+    // Element has no unallowed props
+    if (!ast.JSXElement.hasAllowedAttrsOnly(node, allowedAttrs)) {
+      return false;
+    }
+
+    // If there is more than one `@atlaskit/primitives` import, then it becomes difficult to determine which import to transform
+    var importDeclaration = ast.Root.findImportsByModule(context.getSourceCode().ast.body, '@atlaskit/primitives');
+    if (importDeclaration.length > 1) {
+      return false;
+    }
+    return true;
+  },
+  _fix: function _fix(node, _ref3) {
+    var context = _ref3.context;
+    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', 'em', fixer);
+      var testAttributeFix = updateTestIdAttributeFix(node, fixer);
+      return [importFix].concat(_toConsumableArray(elementNameFixes), [asAttributeFix, 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/index.js

@@ -0,0 +1,4 @@
+export { EmphasisElements } from './emphasis-elements';
+export { SpanElements } from './span-elements';
+export { StrongElements } from './strong-elements';
+export { ParagraphElements } from './paragraph-elements';

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

@@ -0,0 +1,186 @@
+import _toConsumableArray from "@babel/runtime/helpers/toConsumableArray";
+/* eslint-disable @repo/internal/react/require-jsdoc */
+
+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';
+export var ParagraphElements = {
+  lint: function lint(node, _ref) {
+    var context = _ref.context,
+      config = _ref.config;
+    if (!isNodeOfType(node, 'JSXElement')) {
+      return;
+    }
+
+    // Check whether all criteria needed to make a transformation are met
+    var _ParagraphElements$_c = ParagraphElements._check(node, {
+        context: context,
+        config: config
+      }),
+      success = _ParagraphElements$_c.success,
+      refs = _ParagraphElements$_c.refs;
+    if (!success) {
+      return;
+    }
+    if (refs.siblings.length > 1) {
+      var _refs$siblings$0$loc, _refs$siblings$loc;
+      /**
+       * Highlighting from first opening element to last closing element
+       * to indicate fix will change all p elements and wrap them in a Stack,
+       * falls back to first opening element.
+       */
+      var startLoc = (_refs$siblings$0$loc = refs.siblings[0].loc) === null || _refs$siblings$0$loc === void 0 ? void 0 : _refs$siblings$0$loc.start;
+      var endLoc = (_refs$siblings$loc = refs.siblings[refs.siblings.length - 1].loc) === null || _refs$siblings$loc === void 0 ? void 0 : _refs$siblings$loc.end;
+      context.report({
+        loc: startLoc && endLoc && {
+          start: startLoc,
+          end: endLoc
+        },
+        node: node.openingElement,
+        messageId: 'preferPrimitivesStackedText',
+        suggest: [{
+          desc: 'Convert to Text and Stack',
+          fix: ParagraphElements._fixMultiple(node, {
+            context: context,
+            refs: refs
+          })
+        }]
+      });
+    } else {
+      context.report({
+        node: node,
+        messageId: 'preferPrimitivesText',
+        suggest: [{
+          desc: 'Convert to Text',
+          fix: ParagraphElements._fixSingle(node, {
+            context: context
+          })
+        }]
+      });
+    }
+  },
+  _check: function _check(node, _ref2) {
+    var context = _ref2.context,
+      config = _ref2.config;
+    if (!config.patterns.includes('paragraph-elements')) {
+      return {
+        success: false,
+        refs: {
+          siblings: []
+        }
+      };
+    }
+    var elementName = ast.JSXElement.getName(node);
+    if (elementName !== 'p') {
+      return {
+        success: false,
+        refs: {
+          siblings: []
+        }
+      };
+    }
+
+    // All siblings have to be paragraph elements with no unallowed props
+    if (!isNodeOfType(node.parent, 'JSXElement')) {
+      return {
+        success: false,
+        refs: {
+          siblings: []
+        }
+      };
+    }
+    var siblings = ast.JSXElement.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
+      if (((_siblings$0$range = siblings[0].range) === null || _siblings$0$range === void 0 ? void 0 : _siblings$0$range[0]) !== ((_node$range = node.range) === null || _node$range === void 0 ? void 0 : _node$range[0]) || ((_siblings$0$range2 = siblings[0].range) === null || _siblings$0$range2 === void 0 ? void 0 : _siblings$0$range2[1]) !== ((_node$range2 = node.range) === null || _node$range2 === void 0 ? void 0 : _node$range2[1])) {
+        return {
+          success: false,
+          refs: {
+            siblings: siblings
+          }
+        };
+      }
+      // Only report when every sibling is a p element
+      var siblingsMatch = siblings.every(function (child) {
+        if (!isNodeOfType(child, 'JSXElement')) {
+          return false;
+        }
+        if (ast.JSXElement.getName(child) !== 'p') {
+          return false;
+        }
+        return ast.JSXElement.hasAllowedAttrsOnly(child, allowedAttrs);
+      });
+      if (!siblingsMatch) {
+        return {
+          success: false,
+          refs: {
+            siblings: siblings
+          }
+        };
+      }
+    }
+    var importDeclaration = ast.Root.findImportsByModule(context.getSourceCode().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) {
+      return {
+        success: false,
+        refs: {
+          siblings: siblings
+        }
+      };
+    }
+    return {
+      success: true,
+      refs: {
+        siblings: siblings
+      }
+    };
+  },
+  _fixSingle: function _fixSingle(node, _ref3) {
+    var context = _ref3.context;
+    return function (fixer) {
+      var importFix = upsertImportDeclaration({
+        module: '@atlaskit/primitives',
+        specifiers: ['Text']
+      }, context, fixer);
+      var elementNameFixes = ast.JSXElement.updateName(node, 'Text', fixer);
+      var testAttributeFix = updateTestIdAttributeFix(node, fixer);
+      return [importFix].concat(_toConsumableArray(elementNameFixes), [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,
+      refs = _ref4.refs;
+    return function (fixer) {
+      if (!isNodeOfType(node.parent, 'JSXElement') || !node.parent.closingElement) {
+        return [];
+      }
+      var importFix = upsertImportDeclaration({
+        module: '@atlaskit/primitives',
+        specifiers: ['Text', 'Stack']
+      }, context, fixer);
+
+      // Update all siblings elements and their attributes
+      var siblingFixes = refs.siblings.map(function (sibling) {
+        if (isNodeOfType(sibling, 'JSXElement')) {
+          var elementNameFixes = ast.JSXElement.updateName(sibling, 'Text', fixer);
+          var testAttributeFix = updateTestIdAttributeFix(sibling, fixer);
+          return [].concat(_toConsumableArray(elementNameFixes), [testAttributeFix]);
+        }
+        return undefined;
+      }).flat();
+
+      // Wrap in <Stack /> when more than 1 sibling
+      var wrapperOpenElementFix = fixer.insertTextAfter(node.parent.openingElement, "<Stack space='space.150'>");
+      var wrapperCloseElementFix = fixer.insertTextBefore(node.parent.closingElement, '</Stack>');
+      return [importFix].concat(_toConsumableArray(siblingFixes), [wrapperOpenElementFix, wrapperCloseElementFix]).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/span-elements.js

@@ -0,0 +1,77 @@
+import _toConsumableArray from "@babel/runtime/helpers/toConsumableArray";
+/* eslint-disable @repo/internal/react/require-jsdoc */
+
+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';
+export var SpanElements = {
+  lint: function lint(node, _ref) {
+    var context = _ref.context,
+      config = _ref.config;
+    if (!isNodeOfType(node, 'JSXElement')) {
+      return;
+    }
+
+    // Check whether all criteria needed to make a transformation are met
+    if (!SpanElements._check(node, {
+      context: context,
+      config: config
+    })) {
+      return;
+    }
+    context.report({
+      node: node.openingElement,
+      messageId: 'preferPrimitivesText',
+      suggest: [{
+        desc: "Convert to Text",
+        fix: SpanElements._fix(node, {
+          context: context
+        })
+      }]
+    });
+  },
+  _check: function _check(node, _ref2) {
+    var context = _ref2.context,
+      config = _ref2.config;
+    if (!config.patterns.includes('span-elements')) {
+      return false;
+    }
+    var elementName = ast.JSXElement.getName(node);
+    if (elementName !== 'span') {
+      return false;
+    }
+
+    // Element has no unallowed props
+    if (!ast.JSXElement.hasAllowedAttrsOnly(node, allowedAttrs)) {
+      return false;
+    }
+
+    // Only allow elements with strings as children
+    if (!hasTextChildrenOnly(node)) {
+      return false;
+    }
+    var importDeclaration = ast.Root.findImportsByModule(context.getSourceCode().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) {
+      return false;
+    }
+    return true;
+  },
+  _fix: function _fix(node, _ref3) {
+    var context = _ref3.context;
+    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 testAttributeFix = updateTestIdAttributeFix(node, fixer);
+      return [importFix].concat(_toConsumableArray(elementNameFixes), [variantAttributeFix, 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

@@ -0,0 +1,72 @@
+import _toConsumableArray from "@babel/runtime/helpers/toConsumableArray";
+/* eslint-disable @repo/internal/react/require-jsdoc */
+
+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';
+export var StrongElements = {
+  lint: function lint(node, _ref) {
+    var context = _ref.context,
+      config = _ref.config;
+    if (!isNodeOfType(node, 'JSXElement')) {
+      return;
+    }
+
+    // Check whether all criteria needed to make a transformation are met
+    if (!StrongElements._check(node, {
+      context: context,
+      config: config
+    })) {
+      return;
+    }
+    context.report({
+      node: node.openingElement,
+      messageId: 'preferPrimitivesText',
+      suggest: [{
+        desc: "Convert to Text",
+        fix: StrongElements._fix(node, {
+          context: context
+        })
+      }]
+    });
+  },
+  _check: function _check(node, _ref2) {
+    var context = _ref2.context,
+      config = _ref2.config;
+    if (!config.patterns.includes('strong-elements')) {
+      return false;
+    }
+    var elementName = ast.JSXElement.getName(node);
+    if (elementName !== 'strong') {
+      return false;
+    }
+
+    // Element has no unallowed props
+    if (!ast.JSXElement.hasAllowedAttrsOnly(node, allowedAttrs)) {
+      return false;
+    }
+
+    // If there is more than one `@atlaskit/primitives` import, then it becomes difficult to determine which import to transform
+    var importDeclaration = ast.Root.findImportsByModule(context.getSourceCode().ast.body, '@atlaskit/primitives');
+    if (importDeclaration.length > 1) {
+      return false;
+    }
+    return true;
+  },
+  _fix: function _fix(node, _ref3) {
+    var context = _ref3.context;
+    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', 'strong', fixer);
+      var testAttributeFix = updateTestIdAttributeFix(node, fixer);
+      return [importFix].concat(_toConsumableArray(elementNameFixes), [asAttributeFix, testAttributeFix]).filter(function (fix) {
+        return Boolean(fix);
+      }); // Some of the transformers can return arrays with undefined, so filter them out
+    };
+  }
+};

package/dist/types/ast-nodes/jsx-element.d.ts

@@ -7,8 +7,8 @@ export declare const JSXElementHelper: {
      * `<MyComponents.Component></MyComponents.Component>` - `MyComponents` is a namespace (JSXNamespacedName)
      * `<MyComponents.Component></MyComponents.Component>` - `MyComponents` is an object (JSXMemberExpression)
      *
-     * Getting the name of a JSXMemberExpression is difficult, because object can contain objects, which is recursively defined in the AST.
-     * e.g. getting the name of `<MyComponents.PresentationLayer.LeftSideBar.Header />` would require `getName` to recursively resolve all parts of the name.
+     * getting the name of a JSXMemberExpression is difficult, because object can contain objects, which is recursively defined in the AST.
+     * e.g. Getting the name of `<MyComponents.PresentationLayer.LeftSideBar.Header />` would require `getName` to recursively resolve all parts of the name.
      * `getName` does not currently have this functionality. Add it if you need it.
      */
     getName(node: JSXElement): string;
@@ -17,5 +17,8 @@ export declare const JSXElementHelper: {
     getAttributes(node: JSXElement): (JSXAttribute | JSXSpreadAttribute)[];
     getAttributeByName(node: JSXElement, name: string): JSXAttribute | undefined;
     containsSpreadAttributes(node: JSXElement): boolean;
+    addAttribute(node: JSXElement, name: string, value: string, fixer: Rule.RuleFixer): Rule.Fix;
+    getChildren(node: JSXElement): JSXElement['children'];
+    hasAllowedAttrsOnly(node: JSXElement, allowedProps: string[]): boolean;
 };
 export { JSXElementHelper as JSXElement };

package/dist/types/index.codegen.d.ts

@@ -7,7 +7,6 @@ export declare const configs: {
             '@atlaskit/design-system/ensure-design-token-usage': string;
             '@atlaskit/design-system/ensure-design-token-usage/preview': string;
             '@atlaskit/design-system/icon-label': string;
-            '@atlaskit/design-system/local-cx-xcss': string;
             '@atlaskit/design-system/no-banned-imports': string;
             '@atlaskit/design-system/no-css-tagged-template-expression': string;
             '@atlaskit/design-system/no-deprecated-apis': string;
@@ -31,6 +30,7 @@ export declare const configs: {
             '@atlaskit/design-system/use-heading-level-in-spotlight-card': string;
             '@atlaskit/design-system/use-href-in-link-item': string;
             '@atlaskit/design-system/use-primitives': string;
+            '@atlaskit/design-system/use-primitives-text': string;
             '@atlaskit/design-system/use-visually-hidden': string;
         };
     };
@@ -40,7 +40,6 @@ export declare const configs: {
             '@atlaskit/design-system/consistent-css-prop-usage': string;
             '@atlaskit/design-system/ensure-design-token-usage': string;
             '@atlaskit/design-system/icon-label': string;
-            '@atlaskit/design-system/local-cx-xcss': string;
             '@atlaskit/design-system/no-banned-imports': string;
             '@atlaskit/design-system/no-deprecated-apis': string;
             '@atlaskit/design-system/no-deprecated-design-token-usage': string;

package/dist/types/presets/all.codegen.d.ts

@@ -1,6 +1,6 @@
 /**
  * THIS FILE WAS CREATED VIA CODEGEN DO NOT MODIFY {@see http://go/af-codegen}
- * @codegen <<SignedSource::5647ce9c10ba880cffece66b5924fd6e>>
+ * @codegen <<SignedSource::aa64b4343b8763cfa5aa66230faea408>>
  * @codegenCommand yarn workspace @atlaskit/eslint-plugin-design-system codegen
  */
 declare const _default: {
@@ -10,7 +10,6 @@ declare const _default: {
         '@atlaskit/design-system/ensure-design-token-usage': string;
         '@atlaskit/design-system/ensure-design-token-usage/preview': string;
         '@atlaskit/design-system/icon-label': string;
-        '@atlaskit/design-system/local-cx-xcss': string;
         '@atlaskit/design-system/no-banned-imports': string;
         '@atlaskit/design-system/no-css-tagged-template-expression': string;
         '@atlaskit/design-system/no-deprecated-apis': string;
@@ -34,6 +33,7 @@ declare const _default: {
         '@atlaskit/design-system/use-heading-level-in-spotlight-card': string;
         '@atlaskit/design-system/use-href-in-link-item': string;
         '@atlaskit/design-system/use-primitives': string;
+        '@atlaskit/design-system/use-primitives-text': string;
         '@atlaskit/design-system/use-visually-hidden': string;
     };
 };

package/dist/types/presets/recommended.codegen.d.ts

@@ -1,6 +1,6 @@
 /**
  * THIS FILE WAS CREATED VIA CODEGEN DO NOT MODIFY {@see http://go/af-codegen}
- * @codegen <<SignedSource::577269c832952ce359cde6a50f26f4e0>>
+ * @codegen <<SignedSource::aebc778f0b10032cbb2941b55189d766>>
  * @codegenCommand yarn workspace @atlaskit/eslint-plugin-design-system codegen
  */
 declare const _default: {
@@ -9,7 +9,6 @@ declare const _default: {
         '@atlaskit/design-system/consistent-css-prop-usage': string;
         '@atlaskit/design-system/ensure-design-token-usage': string;
         '@atlaskit/design-system/icon-label': string;
-        '@atlaskit/design-system/local-cx-xcss': string;
         '@atlaskit/design-system/no-banned-imports': string;
         '@atlaskit/design-system/no-deprecated-apis': string;
         '@atlaskit/design-system/no-deprecated-design-token-usage': string;

package/dist/types/rules/index.codegen.d.ts

@@ -3,7 +3,6 @@ declare const _default: {
     'ensure-design-token-usage': import("eslint").Rule.RuleModule;
     'ensure-design-token-usage/preview': import("eslint").Rule.RuleModule;
     'icon-label': import("eslint").Rule.RuleModule;
-    'local-cx-xcss': import("eslint").Rule.RuleModule;
     'no-banned-imports': import("eslint").Rule.RuleModule;
     'no-css-tagged-template-expression': import("eslint").Rule.RuleModule;
     'no-deprecated-apis': import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleModule<string, [{
@@ -31,6 +30,7 @@ declare const _default: {
     'use-heading-level-in-spotlight-card': import("eslint").Rule.RuleModule;
     'use-href-in-link-item': import("eslint").Rule.RuleModule;
     'use-primitives': import("eslint").Rule.RuleModule;
+    'use-primitives-text': import("eslint").Rule.RuleModule;
     'use-visually-hidden': import("eslint").Rule.RuleModule;
 };
 export default _default;

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

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

package/dist/types/rules/{local-cx-xcss → use-primitives-text}/index.d.ts

@@ -1,3 +1,3 @@
 import type { Rule } from 'eslint';
-export declare const rule: Rule.RuleModule;
+declare const rule: Rule.RuleModule;
 export default rule;

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

@@ -0,0 +1,5 @@
+import type { Rule } from 'eslint';
+import { JSXElement } from 'eslint-codemod-utils';
+export declare function updateTestIdAttributeFix(node: JSXElement, 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

@@ -0,0 +1,16 @@
+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[];
+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;
+};
+export {};

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

@@ -0,0 +1,4 @@
+export { EmphasisElements } from './emphasis-elements';
+export { SpanElements } from './span-elements';
+export { StrongElements } from './strong-elements';
+export { ParagraphElements } from './paragraph-elements';

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

@@ -0,0 +1,32 @@
+import type { Rule } from 'eslint';
+import { JSXElement } from 'eslint-codemod-utils';
+import { RuleConfig } from '../config';
+type MetaData = {
+    context: Rule.RuleContext;
+    config: RuleConfig;
+};
+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 & {
+        parent: Rule.Node;
+    }, { context, config }: MetaData): CheckResult;
+    _fixSingle(node: JSXElement & {
+        parent: Rule.Node;
+    }, { context }: {
+        context: Rule.RuleContext;
+    }): FixFunction;
+    _fixMultiple(node: JSXElement & {
+        parent: Rule.Node;
+    }, { context, refs }: {
+        context: Rule.RuleContext;
+        refs: CheckResult['refs'];
+    }): FixFunction;
+};
+export {};

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

@@ -0,0 +1,16 @@
+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[];
+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;
+};
+export {};

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

@@ -0,0 +1,16 @@
+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[];
+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;
+};
+export {};

package/dist/types-ts4.5/ast-nodes/jsx-element.d.ts

@@ -7,8 +7,8 @@ export declare const JSXElementHelper: {
      * `<MyComponents.Component></MyComponents.Component>` - `MyComponents` is a namespace (JSXNamespacedName)
      * `<MyComponents.Component></MyComponents.Component>` - `MyComponents` is an object (JSXMemberExpression)
      *
-     * Getting the name of a JSXMemberExpression is difficult, because object can contain objects, which is recursively defined in the AST.
-     * e.g. getting the name of `<MyComponents.PresentationLayer.LeftSideBar.Header />` would require `getName` to recursively resolve all parts of the name.
+     * getting the name of a JSXMemberExpression is difficult, because object can contain objects, which is recursively defined in the AST.
+     * e.g. Getting the name of `<MyComponents.PresentationLayer.LeftSideBar.Header />` would require `getName` to recursively resolve all parts of the name.
      * `getName` does not currently have this functionality. Add it if you need it.
      */
     getName(node: JSXElement): string;
@@ -17,5 +17,8 @@ export declare const JSXElementHelper: {
     getAttributes(node: JSXElement): (JSXAttribute | JSXSpreadAttribute)[];
     getAttributeByName(node: JSXElement, name: string): JSXAttribute | undefined;
     containsSpreadAttributes(node: JSXElement): boolean;
+    addAttribute(node: JSXElement, name: string, value: string, fixer: Rule.RuleFixer): Rule.Fix;
+    getChildren(node: JSXElement): JSXElement['children'];
+    hasAllowedAttrsOnly(node: JSXElement, allowedProps: string[]): boolean;
 };
 export { JSXElementHelper as JSXElement };