@atlaskit/eslint-plugin-design-system 8.23.1 → 8.23.3

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

@@ -0,0 +1,107 @@
+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 { isValidCssPropertiesToTransform } from '../../utils';
+import { convertJsxCallSite } from './convert-jsx-call-site';
+import { convertStyledComponentToXcss } from './convert-styled-component-call-to-jsx';
+import { findValidJsxUsageToTransform } from './find-valid-jsx-usage-to-transform';
+import { findValidStyledComponentCall } from './find-valid-styled-component-call';
+import { upsertImportDeclaration } from './upsert-import-declaration';
+export var CompiledStyled = {
+  lint: function lint(node, _ref) {
+    var context = _ref.context,
+      config = _ref.config;
+    if (!isNodeOfType(node, 'CallExpression')) {
+      return;
+    }
+
+    // Check whether all criteria needed to make a transformation are met
+    var _CompiledStyled$_chec = CompiledStyled._check(node, {
+        context: context,
+        config: config
+      }),
+      success = _CompiledStyled$_chec.success,
+      refs = _CompiledStyled$_chec.refs;
+    if (!success || !refs) {
+      return;
+    }
+    context.report({
+      node: refs.styles,
+      messageId: 'preferPrimitivesBox',
+      suggest: [{
+        desc: "Convert ".concat(ast.JSXElement.getName(refs.jsxElement), " to Box"),
+        fix: CompiledStyled._fix(refs, context)
+      }]
+    });
+  },
+  _check: function _check(node, _ref2) {
+    var context = _ref2.context,
+      config = _ref2.config;
+    if (!config.patterns.includes('compiled-styled-object')) {
+      return {
+        success: false
+      };
+    }
+    if (!isNodeOfType(node, 'CallExpression')) {
+      return {
+        success: false
+      };
+    }
+    var styledComponentVariableRef = findValidStyledComponentCall(node);
+    if (!styledComponentVariableRef || !isNodeOfType(styledComponentVariableRef.id, 'Identifier') || !isValidCssPropertiesToTransform(node, config)) {
+      return {
+        success: false
+      };
+    }
+    var styledComponentJsxRef = findValidJsxUsageToTransform(styledComponentVariableRef.id.name, context.getScope());
+    if (!styledComponentJsxRef) {
+      return {
+        success: false
+      };
+    }
+    if (!isNodeOfType(styledComponentJsxRef.parent, 'JSXElement')) {
+      return {
+        success: 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 {
+        success: false
+      };
+    }
+    return {
+      success: true,
+      refs: {
+        styles: styledComponentVariableRef,
+        jsxElement: styledComponentJsxRef.parent
+      }
+    };
+  },
+  /**
+   * All required validation steps have been taken care of before this
+   * transformer is called, so it just goes ahead providing all necessary fixes
+   */
+  _fix: function _fix(refs, context) {
+    return function (fixer) {
+      // generates the new variable name: MyComponent -> myComponentStyles
+      var calculatedStylesVariableName = isNodeOfType(refs.styles.id, 'Identifier') && "".concat(refs.styles.id.name.replace(refs.styles.id.name[0], refs.styles.id.name[0].toLowerCase()), "Styles");
+      if (!calculatedStylesVariableName) {
+        return [];
+      }
+      var importFixes = upsertImportDeclaration({
+        module: '@atlaskit/primitives',
+        specifiers: ['Box', 'xcss']
+      }, context, fixer);
+      var stylesFixes = convertStyledComponentToXcss(refs.styles, calculatedStylesVariableName, fixer);
+      var jsxFixes = convertJsxCallSite(refs.jsxElement, calculatedStylesVariableName, fixer);
+      return [importFixes].concat(_toConsumableArray(stylesFixes), _toConsumableArray(jsxFixes)).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/transformers/compiled-styled/supported.js

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

package/dist/esm/rules/use-primitives/transformers/compiled-styled/upsert-import-declaration.js

@@ -0,0 +1,29 @@
+import * as ast from '../../../../ast-nodes';
+
+/**
+ * Currently this is defined here because it's not very general purpose.
+ * If we were to move this to `ast-nodes`, half the implementation would be in `Root`,
+ * and the other half would be in `Import`.
+ *
+ * TODO: Refactor and move to `ast-nodes`
+ *
+ * Note: It does not handle default imports, namespace imports, or aliased imports.
+ */
+export var upsertImportDeclaration = function upsertImportDeclaration(_ref, context, fixer) {
+  var module = _ref.module,
+    specifiers = _ref.specifiers;
+  // Find any imports that match the packageName
+  var root = context.getSourceCode().ast.body;
+  var importDeclarations = ast.Root.findImportsByModule(root, module);
+
+  // The import doesn't exist yet, we can just insert a whole new one
+  if (importDeclarations.length === 0) {
+    return ast.Root.insertImport(root, {
+      module: module,
+      specifiers: specifiers
+    }, fixer);
+  }
+
+  // The import exists so, modify the existing one
+  return ast.Import.insertNamedSpecifiers(importDeclarations[0], specifiers, fixer);
+};

package/dist/esm/rules/use-primitives/transformers/emotion-css/contains-only-supported-attrs.js

@@ -0,0 +1,19 @@
+import { isNodeOfType } from 'eslint-codemod-utils';
+import * as ast from '../../../../ast-nodes';
+import * as supported from './supported';
+
+/**
+ * Check that every attribute in the JSXElement is something we support.
+ * We do this via a whitelist in `this.attributes`. The result is we exclude
+ * dangerous attrs like `id` and `style`.
+ */
+export var containsOnlySupportedAttrs = function containsOnlySupportedAttrs(node) {
+  var attrs = ast.JSXElement.getAttributes(node);
+  return attrs.every(function (attr) {
+    if (!isNodeOfType(attr, 'JSXAttribute')) {
+      return false;
+    }
+    var name = ast.JSXAttribute.getName(attr);
+    return supported.attributes.includes(name);
+  });
+};

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

@@ -0,0 +1,115 @@
+import _toConsumableArray from "@babel/runtime/helpers/toConsumableArray";
+/* eslint-disable @repo/internal/react/require-jsdoc */
+
+import { getIdentifierInParentScope, isNodeOfType } from 'eslint-codemod-utils';
+import * as ast from '../../../../ast-nodes';
+import { getVariableDefinitionValue, getVariableUsagesCount, isValidCssPropertiesToTransform } from '../../utils';
+import { cssToXcssTransformer } from '../css-to-xcss';
+import { containsOnlySupportedAttrs } from './contains-only-supported-attrs';
+import * as supported from './supported';
+import { upsertImportDeclaration } from './upsert-import-declaration';
+export var EmotionCSS = {
+  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 (!EmotionCSS._check(node, {
+      context: context,
+      config: config
+    })) {
+      return;
+    }
+    context.report({
+      node: node.openingElement,
+      messageId: 'preferPrimitivesBox',
+      suggest: [{
+        desc: "Convert to Box",
+        fix: EmotionCSS._fix(node, {
+          context: context
+        })
+      }]
+    });
+  },
+  _check: function _check(node, _ref2) {
+    var _cssVariableValue$nod, _cssVariableValue$nod2;
+    var context = _ref2.context,
+      config = _ref2.config;
+    if (!config.patterns.includes('compiled-css-function')) {
+      return false;
+    }
+    if (!isNodeOfType(node, 'JSXElement')) {
+      return false;
+    }
+    var elementName = ast.JSXElement.getName(node);
+    if (!elementName) {
+      return false;
+    }
+
+    // Currently we only support `div`. This may change in future.
+    if (!supported.elements.includes(elementName)) {
+      return false;
+    }
+
+    // Ignore elements that contain dangerous attributes like `id`.
+    if (!containsOnlySupportedAttrs(node)) {
+      return false;
+    }
+
+    // Currently we don't transform anything to `Box` unless it defines styles
+    var cssAttr = ast.JSXElement.getAttributeByName(node, 'css');
+    if (!cssAttr) {
+      return false;
+    }
+
+    // Get `myStyles` in `css={myStyles}` as a string so we can search for the `const myStyles` VariableDefinition
+    var cssAttrValue = ast.JSXAttribute.getValue(cssAttr);
+    if ((cssAttrValue === null || cssAttrValue === void 0 ? void 0 : cssAttrValue.type) !== 'ExpressionStatement') {
+      return false;
+    }
+
+    // TODO: Everything below this line could be refactored to use `ast-nodes`.
+
+    // Bail if the styles are used on multiple JSXElements
+    if (getVariableUsagesCount(cssAttrValue.value, context) !== 1) {
+      return false;
+    }
+
+    // Find where `myStyles` is defined. We're looking for `const myStyles = css({...})`
+    var cssVariableDefinition = getIdentifierInParentScope(context.getScope(), cssAttrValue.value);
+    var cssVariableValue = getVariableDefinitionValue(cssVariableDefinition);
+    // Check if `cssVariableValue` is a function called `css()`
+    if (ast.FunctionCall.getName(cssVariableValue === null || cssVariableValue === void 0 || (_cssVariableValue$nod = cssVariableValue.node) === null || _cssVariableValue$nod === void 0 ? void 0 : _cssVariableValue$nod.init) !== 'css') {
+      return false;
+    }
+    if (!isValidCssPropertiesToTransform(cssVariableValue === null || cssVariableValue === void 0 || (_cssVariableValue$nod2 = cssVariableValue.node) === null || _cssVariableValue$nod2 === void 0 ? void 0 : _cssVariableValue$nod2.init, config)) {
+      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: ['Box', 'xcss']
+      }, context, fixer);
+      var cssAttr = ast.JSXElement.getAttributeByName(node, 'css'); // Can strongly assert the type here, because we validated it exists in `check()`.
+      var attributeFix = ast.JSXAttribute.updateName(cssAttr, 'xcss', fixer);
+      var elementNameFixes = ast.JSXElement.updateName(node, 'Box', fixer);
+      var cssToXcssTransform = cssToXcssTransformer(node, context, fixer);
+      return [importFix, attributeFix].concat(_toConsumableArray(elementNameFixes), _toConsumableArray(cssToXcssTransform)).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/transformers/emotion-css/supported.js

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

package/dist/esm/rules/use-primitives/transformers/emotion-css/upsert-import-declaration.js

@@ -0,0 +1,29 @@
+import * as ast from '../../../../ast-nodes';
+
+/**
+ * Currently this is defined here because it's not very general purpose.
+ * If we were to move this to `ast-nodes`, half the implementation would be in `Root`,
+ * and the other half would be in `Import`.
+ *
+ * TODO: Refactor and move to `ast-nodes`
+ *
+ * Note: It does not handle default imports, namespace imports, or aliased imports.
+ */
+export var upsertImportDeclaration = function upsertImportDeclaration(_ref, context, fixer) {
+  var module = _ref.module,
+    specifiers = _ref.specifiers;
+  // Find any imports that match the packageName
+  var root = context.getSourceCode().ast.body;
+  var importDeclarations = ast.Root.findImportsByModule(root, module);
+
+  // The import doesn't exist yet, we can just insert a whole new one
+  if (importDeclarations.length === 0) {
+    return ast.Root.insertImport(root, {
+      module: module,
+      specifiers: specifiers
+    }, fixer);
+  }
+
+  // The import exists so, modify the existing one
+  return ast.Import.insertNamedSpecifiers(importDeclarations[0], specifiers, fixer);
+};

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

@@ -1,3 +1,3 @@
 export { cssToXcssTransformer, supportedStylesMap, spaceTokenMap } from './css-to-xcss';
-export { jsxElementToBoxTransformer } from './jsx-element-to-box';
-export { styledComponentToPrimitive } from './styled-component-to-primitive';
+export { CompiledStyled } from './compiled-styled';
+export { EmotionCSS } from './emotion-css';

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

@@ -1,7 +1,4 @@
-export { containsOnlySupportedAttrs } from './contains-only-supported-attrs';
 export { convertASTObjectExpressionToJSObject } from './convert-ast-object-expression-to-js-object';
-export { findValidJsxUsageToTransform } from './find-valid-jsx-usage-to-transform';
-export { findValidStyledComponentCall } from './find-valid-styled-component-call';
 export { getAttributeValueIdentifier } from './get-attribute-value-identifier';
 export { getFunctionArgumentAtPos } from './get-function-argument-at-pos';
 export { getJSXAttributeByName } from './get-jsx-attribute-by-name';
@@ -9,7 +6,4 @@ export { getVariableDefinitionValue } from './get-variable-definition-value';
 export { getVariableUsagesCount } from './get-variable-usage-count';
 export { isFunctionNamed } from './is-function-named';
 export { isValidCssPropertiesToTransform } from './is-valid-css-properties-to-transform';
-export { isValidTagName } from './is-valid-tag-name';
-export { updateJSXAttributeByName } from './update-jsx-attribute-by-name';
-export { updateJSXElementName } from './update-jsx-element-name';
-export { upsertImportDeclaration } from './upsert-import-declaration';
+export { updateJSXAttributeByName } from './update-jsx-attribute-by-name';

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

@@ -5,6 +5,9 @@ import { isNodeOfType } from 'eslint-codemod-utils';
 import { supportedStylesMap } from '../transformers/css-to-xcss';
 import { convertASTObjectExpressionToJSObject } from './convert-ast-object-expression-to-js-object';
 export var isValidCssPropertiesToTransform = function isValidCssPropertiesToTransform(node, config) {
+  if (!node) {
+    return false;
+  }
   var cssObjectExpression = node.arguments[0];
   // Bail on empty object calls
   if (!cssObjectExpression || !isNodeOfType(cssObjectExpression, 'ObjectExpression')) {

package/dist/types/ast-nodes/function-call.d.ts

@@ -0,0 +1,21 @@
+import type { Rule } from 'eslint';
+import { CallExpression, ObjectExpression } from 'eslint-codemod-utils';
+export declare const FunctionCall: {
+    getName(node: CallExpression): string | undefined;
+    updateName(node: CallExpression, newName: string, fixer: Rule.RuleFixer): Rule.Fix;
+    /**
+     * Function arguments can be many things:
+     * `css(myStyles, () => {}, undefined, 'literal', ...rest) // etc`
+     * They all need slightly different treatment.
+     *
+     * Currently 'getArgumentAtPos' only implements strategies for Literals and ObjectExpressions.
+     * If you need to support another type of arg, add it, and update the type.
+     */
+    getArgumentAtPos(node: CallExpression, pos: number): {
+        type: 'Literal';
+        value: string;
+    } | {
+        type: 'ObjectExpression';
+        value: ObjectExpression;
+    } | undefined;
+};

package/dist/types/ast-nodes/import.d.ts

@@ -0,0 +1,16 @@
+import type { Rule } from 'eslint';
+import { type ImportDeclaration } from 'eslint-codemod-utils';
+export declare const Import: {
+    /**
+     * Note: fixes can't overlap, which means this will fail:
+     * ```
+     * const importNode = Root.findImportByModule('@atlaskit/primitives')
+     * Import.insertNamedSpecifier(importNode, 'Box')
+     * Import.insertNamedSpecifier(importNode, 'xcss')
+     * ```
+     *
+     * For this reason `insertNamedSpecifiers` accepts a `specifiers` array, so you can group all inserts together.
+     */
+    insertNamedSpecifiers(node: ImportDeclaration, specifiers: string[], fixer: Rule.RuleFixer): Rule.Fix | undefined;
+    containsNamedSpecifier(node: ImportDeclaration, name: string): boolean;
+};

package/dist/types/ast-nodes/index.d.ts

@@ -0,0 +1,5 @@
+export { FunctionCall } from './function-call';
+export { Import } from './import';
+export { JSXAttribute } from './jsx-attribute';
+export { JSXElement } from './jsx-element';
+export { Root } from './root';

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

@@ -0,0 +1,26 @@
+import type { Rule } from 'eslint';
+import { JSXAttribute } from 'eslint-codemod-utils';
+declare const HelperJSXAttribute: {
+    getName(node: JSXAttribute): string;
+    updateName(node: JSXAttribute, name: string, fixer: Rule.RuleFixer): Rule.Fix;
+    /**
+     * A JSXAttribute value can be many things:
+     * - css='myStyles'
+     * - css={myStyles}
+     * - css={[styles1, styles2]}
+     * - header={<></>}
+     * - css={styleMap.header}
+     * - css={...styles}
+     *
+     * Currently, `getValue` has only implemented strategies for when the value is a string, or an ExpressionStatement
+     * If you need additional functionality add it, and set the correct `type` on the returned object
+     */
+    getValue(node: JSXAttribute): {
+        type: 'ExpressionStatement';
+        value: string;
+    } | {
+        type: 'Literal';
+        value: string;
+    } | undefined;
+};
+export { HelperJSXAttribute as JSXAttribute };

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

@@ -0,0 +1,21 @@
+import type { Rule } from 'eslint';
+import { JSXAttribute, JSXElement, JSXSpreadAttribute } from 'eslint-codemod-utils';
+export declare const JSXElementHelper: {
+    /**
+     * Names of JSXElements can be any of:
+     * `<Component></Component>` - (JSXIdentifier)
+     * `<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.
+     * `getName` does not currently have this functionality. Add it if you need it.
+     */
+    getName(node: JSXElement): string;
+    updateName(node: JSXElement, newName: string, fixer: Rule.RuleFixer): Rule.Fix[];
+    isSelfClosing(node: JSXElement): boolean;
+    getAttributes(node: JSXElement): (JSXAttribute | JSXSpreadAttribute)[];
+    getAttributeByName(node: JSXElement, name: string): JSXAttribute | undefined;
+    containsSpreadAttributes(node: JSXElement): boolean;
+};
+export { JSXElementHelper as JSXElement };

package/dist/types/ast-nodes/root.d.ts

@@ -0,0 +1,19 @@
+/// <reference types="node" />
+import type { Rule } from 'eslint';
+import { Directive, ImportDeclaration, insertImportDeclaration, ModuleDeclaration, Statement } from 'eslint-codemod-utils';
+type ImportData = Parameters<typeof insertImportDeclaration>[1];
+export declare const Root: {
+    /**
+     * Note: This can return multiple ImportDeclarations for cases like:
+     * ```
+     * import { Stack } from '@atlaskit/primitives'
+     * import type { StackProps } from '@atlaskit/primitives'
+     * ```
+     */
+    findImportsByModule(root: (Directive | Statement | ModuleDeclaration)[], name: string): ImportDeclaration[];
+    insertImport(root: (Directive | Statement | ModuleDeclaration)[], data: {
+        module: string;
+        specifiers: ImportData;
+    }, fixer: Rule.RuleFixer): Rule.Fix;
+};
+export {};

package/dist/types/rules/use-primitives/transformers/compiled-styled/convert-jsx-call-site.d.ts

@@ -0,0 +1,17 @@
+import type { Rule } from 'eslint';
+import { JSXElement } from 'eslint-codemod-utils';
+/**
+ * Transforms a JSXElement from:
+ * ```
+ *   <div>
+ *     // ...
+ *   </div>
+ * ```
+ * to
+ * ```
+ *   <Box xcss={myStyles}>
+ *     // ...
+ *   </Box>
+ * ```
+ */
+export declare const convertJsxCallSite: (jsxElement: JSXElement, newStylesVariableName: string, fixer: Rule.RuleFixer) => Rule.Fix[];

package/dist/types/rules/use-primitives/transformers/compiled-styled/convert-styled-component-call-to-jsx.d.ts

@@ -0,0 +1,17 @@
+import type { Rule } from 'eslint';
+import { VariableDeclarator } from 'eslint-codemod-utils';
+/**
+ * Transforms a variable like:
+ * ```
+ * const MyComponent = styled.div({
+ *   padding: '8px',
+ * })
+ * ```
+ * to
+ * ```
+ * const myComponentStyles = xcss({
+ *   padding: 'space.100',
+ * })
+ * ```
+ */
+export declare const convertStyledComponentToXcss: (styles: VariableDeclarator, newStylesVariableName: string, fixer: Rule.RuleFixer) => (Rule.Fix | undefined)[];

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

@@ -0,0 +1,25 @@
+import type { Rule } from 'eslint';
+import { JSXElement, VariableDeclarator } from 'eslint-codemod-utils';
+import { RuleConfig } from '../../config';
+interface MetaData {
+    context: Rule.RuleContext;
+    config: RuleConfig;
+}
+interface Refs {
+    styles: VariableDeclarator;
+    jsxElement: JSXElement;
+}
+type Check = {
+    success: boolean;
+    refs?: Refs;
+};
+export declare const CompiledStyled: {
+    lint(node: Rule.Node, { context, config }: MetaData): void;
+    _check(node: Rule.Node, { context, config }: MetaData): Check;
+    /**
+     * 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[];
+};
+export {};

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

@@ -0,0 +1,2 @@
+export declare const elements: string[];
+export declare const attributes: string[];

package/dist/types/rules/use-primitives/transformers/compiled-styled/upsert-import-declaration.d.ts

@@ -0,0 +1,14 @@
+import type { Rule } from 'eslint';
+/**
+ * Currently this is defined here because it's not very general purpose.
+ * If we were to move this to `ast-nodes`, half the implementation would be in `Root`,
+ * and the other half would be in `Import`.
+ *
+ * TODO: Refactor and move to `ast-nodes`
+ *
+ * Note: It does not handle default imports, namespace imports, or aliased imports.
+ */
+export declare const upsertImportDeclaration: ({ module, specifiers, }: {
+    module: string;
+    specifiers: string[];
+}, context: Rule.RuleContext, fixer: Rule.RuleFixer) => Rule.Fix | undefined;

package/dist/types/rules/use-primitives/transformers/emotion-css/contains-only-supported-attrs.d.ts

@@ -0,0 +1,7 @@
+import { JSXElement } from 'eslint-codemod-utils';
+/**
+ * Check that every attribute in the JSXElement is something we support.
+ * We do this via a whitelist in `this.attributes`. The result is we exclude
+ * dangerous attrs like `id` and `style`.
+ */
+export declare const containsOnlySupportedAttrs: (node: JSXElement) => boolean;

package/dist/types/rules/use-primitives/transformers/emotion-css/index.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 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;
+};
+export {};

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

@@ -0,0 +1,2 @@
+export declare const elements: string[];
+export declare const attributes: string[];

package/dist/types/rules/use-primitives/transformers/emotion-css/upsert-import-declaration.d.ts

@@ -0,0 +1,14 @@
+import type { Rule } from 'eslint';
+/**
+ * Currently this is defined here because it's not very general purpose.
+ * If we were to move this to `ast-nodes`, half the implementation would be in `Root`,
+ * and the other half would be in `Import`.
+ *
+ * TODO: Refactor and move to `ast-nodes`
+ *
+ * Note: It does not handle default imports, namespace imports, or aliased imports.
+ */
+export declare const upsertImportDeclaration: ({ module, specifiers, }: {
+    module: string;
+    specifiers: string[];
+}, context: Rule.RuleContext, fixer: Rule.RuleFixer) => Rule.Fix | undefined;

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

@@ -1,3 +1,3 @@
 export { cssToXcssTransformer, supportedStylesMap, spaceTokenMap, } from './css-to-xcss';
-export { jsxElementToBoxTransformer } from './jsx-element-to-box';
-export { styledComponentToPrimitive } from './styled-component-to-primitive';
+export { CompiledStyled } from './compiled-styled';
+export { EmotionCSS } from './emotion-css';

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

@@ -1,7 +1,4 @@
-export { containsOnlySupportedAttrs } from './contains-only-supported-attrs';
 export { convertASTObjectExpressionToJSObject } from './convert-ast-object-expression-to-js-object';
-export { findValidJsxUsageToTransform } from './find-valid-jsx-usage-to-transform';
-export { findValidStyledComponentCall } from './find-valid-styled-component-call';
 export { getAttributeValueIdentifier } from './get-attribute-value-identifier';
 export { getFunctionArgumentAtPos } from './get-function-argument-at-pos';
 export { getJSXAttributeByName } from './get-jsx-attribute-by-name';
@@ -9,7 +6,4 @@ export { getVariableDefinitionValue } from './get-variable-definition-value';
 export { getVariableUsagesCount } from './get-variable-usage-count';
 export { isFunctionNamed } from './is-function-named';
 export { isValidCssPropertiesToTransform } from './is-valid-css-properties-to-transform';
-export { isValidTagName } from './is-valid-tag-name';
 export { updateJSXAttributeByName } from './update-jsx-attribute-by-name';
-export { updateJSXElementName } from './update-jsx-element-name';
-export { upsertImportDeclaration } from './upsert-import-declaration';

package/dist/types-ts4.5/ast-nodes/function-call.d.ts

@@ -0,0 +1,21 @@
+import type { Rule } from 'eslint';
+import { CallExpression, ObjectExpression } from 'eslint-codemod-utils';
+export declare const FunctionCall: {
+    getName(node: CallExpression): string | undefined;
+    updateName(node: CallExpression, newName: string, fixer: Rule.RuleFixer): Rule.Fix;
+    /**
+     * Function arguments can be many things:
+     * `css(myStyles, () => {}, undefined, 'literal', ...rest) // etc`
+     * They all need slightly different treatment.
+     *
+     * Currently 'getArgumentAtPos' only implements strategies for Literals and ObjectExpressions.
+     * If you need to support another type of arg, add it, and update the type.
+     */
+    getArgumentAtPos(node: CallExpression, pos: number): {
+        type: 'Literal';
+        value: string;
+    } | {
+        type: 'ObjectExpression';
+        value: ObjectExpression;
+    } | undefined;
+};