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

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

@@ -0,0 +1,117 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+var _typeof = require("@babel/runtime/helpers/typeof");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.CompiledStyled = void 0;
+var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
+var _eslintCodemodUtils = require("eslint-codemod-utils");
+var ast = _interopRequireWildcard(require("../../../../ast-nodes"));
+var _utils = require("../../utils");
+var _convertJsxCallSite = require("./convert-jsx-call-site");
+var _convertStyledComponentCallToJsx = require("./convert-styled-component-call-to-jsx");
+var _findValidJsxUsageToTransform = require("./find-valid-jsx-usage-to-transform");
+var _findValidStyledComponentCall = require("./find-valid-styled-component-call");
+var _upsertImportDeclaration = require("./upsert-import-declaration");
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || _typeof(obj) !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+/* eslint-disable @repo/internal/react/require-jsdoc */
+
+var CompiledStyled = exports.CompiledStyled = {
+  lint: function lint(node, _ref) {
+    var context = _ref.context,
+      config = _ref.config;
+    if (!(0, _eslintCodemodUtils.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 (!(0, _eslintCodemodUtils.isNodeOfType)(node, 'CallExpression')) {
+      return {
+        success: false
+      };
+    }
+    var styledComponentVariableRef = (0, _findValidStyledComponentCall.findValidStyledComponentCall)(node);
+    if (!styledComponentVariableRef || !(0, _eslintCodemodUtils.isNodeOfType)(styledComponentVariableRef.id, 'Identifier') || !(0, _utils.isValidCssPropertiesToTransform)(node, config)) {
+      return {
+        success: false
+      };
+    }
+    var styledComponentJsxRef = (0, _findValidJsxUsageToTransform.findValidJsxUsageToTransform)(styledComponentVariableRef.id.name, context.getScope());
+    if (!styledComponentJsxRef) {
+      return {
+        success: false
+      };
+    }
+    if (!(0, _eslintCodemodUtils.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 = (0, _eslintCodemodUtils.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 = (0, _upsertImportDeclaration.upsertImportDeclaration)({
+        module: '@atlaskit/primitives',
+        specifiers: ['Box', 'xcss']
+      }, context, fixer);
+      var stylesFixes = (0, _convertStyledComponentCallToJsx.convertStyledComponentToXcss)(refs.styles, calculatedStylesVariableName, fixer);
+      var jsxFixes = (0, _convertJsxCallSite.convertJsxCallSite)(refs.jsxElement, calculatedStylesVariableName, fixer);
+      return [importFixes].concat((0, _toConsumableArray2.default)(stylesFixes), (0, _toConsumableArray2.default)(jsxFixes)).filter(function (fix) {
+        return Boolean(fix);
+      }); // Some of the transformers can return arrays with undefined, so filter them out
+    };
+  }
+};

package/dist/cjs/rules/use-primitives/transformers/compiled-styled/supported.js

@@ -0,0 +1,10 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.elements = exports.attributes = void 0;
+var elements = exports.elements = ['div'];
+var attributes = exports.attributes = ['css'
+// 'data-testid'
+];

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

@@ -0,0 +1,37 @@
+"use strict";
+
+var _typeof = require("@babel/runtime/helpers/typeof");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.upsertImportDeclaration = void 0;
+var ast = _interopRequireWildcard(require("../../../../ast-nodes"));
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || _typeof(obj) !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+/**
+ * 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.
+ */
+var upsertImportDeclaration = exports.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/cjs/rules/use-primitives/transformers/emotion-css/contains-only-supported-attrs.js

@@ -0,0 +1,27 @@
+"use strict";
+
+var _typeof = require("@babel/runtime/helpers/typeof");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.containsOnlySupportedAttrs = void 0;
+var _eslintCodemodUtils = require("eslint-codemod-utils");
+var ast = _interopRequireWildcard(require("../../../../ast-nodes"));
+var supported = _interopRequireWildcard(require("./supported"));
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || _typeof(obj) !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+/**
+ * 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`.
+ */
+var containsOnlySupportedAttrs = exports.containsOnlySupportedAttrs = function containsOnlySupportedAttrs(node) {
+  var attrs = ast.JSXElement.getAttributes(node);
+  return attrs.every(function (attr) {
+    if (!(0, _eslintCodemodUtils.isNodeOfType)(attr, 'JSXAttribute')) {
+      return false;
+    }
+    var name = ast.JSXAttribute.getName(attr);
+    return supported.attributes.includes(name);
+  });
+};

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

@@ -0,0 +1,125 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+var _typeof = require("@babel/runtime/helpers/typeof");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.EmotionCSS = void 0;
+var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
+var _eslintCodemodUtils = require("eslint-codemod-utils");
+var ast = _interopRequireWildcard(require("../../../../ast-nodes"));
+var _utils = require("../../utils");
+var _cssToXcss = require("../css-to-xcss");
+var _containsOnlySupportedAttrs = require("./contains-only-supported-attrs");
+var supported = _interopRequireWildcard(require("./supported"));
+var _upsertImportDeclaration = require("./upsert-import-declaration");
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || _typeof(obj) !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+/* eslint-disable @repo/internal/react/require-jsdoc */
+
+var EmotionCSS = exports.EmotionCSS = {
+  lint: function lint(node, _ref) {
+    var context = _ref.context,
+      config = _ref.config;
+    if (!(0, _eslintCodemodUtils.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 (!(0, _eslintCodemodUtils.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 (!(0, _containsOnlySupportedAttrs.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 ((0, _utils.getVariableUsagesCount)(cssAttrValue.value, context) !== 1) {
+      return false;
+    }
+
+    // Find where `myStyles` is defined. We're looking for `const myStyles = css({...})`
+    var cssVariableDefinition = (0, _eslintCodemodUtils.getIdentifierInParentScope)(context.getScope(), cssAttrValue.value);
+    var cssVariableValue = (0, _utils.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 (!(0, _utils.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 = (0, _upsertImportDeclaration.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 = (0, _cssToXcss.cssToXcssTransformer)(node, context, fixer);
+      return [importFix, attributeFix].concat((0, _toConsumableArray2.default)(elementNameFixes), (0, _toConsumableArray2.default)(cssToXcssTransform)).filter(function (fix) {
+        return Boolean(fix);
+      }); // Some of the transformers can return arrays with undefined, so filter them out
+    };
+  }
+};

package/dist/cjs/rules/use-primitives/transformers/emotion-css/supported.js

@@ -0,0 +1,10 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.elements = exports.attributes = void 0;
+var elements = exports.elements = ['div'];
+var attributes = exports.attributes = ['css'
+// 'data-testid'
+];

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

@@ -0,0 +1,37 @@
+"use strict";
+
+var _typeof = require("@babel/runtime/helpers/typeof");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.upsertImportDeclaration = void 0;
+var ast = _interopRequireWildcard(require("../../../../ast-nodes"));
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || _typeof(obj) !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+/**
+ * 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.
+ */
+var upsertImportDeclaration = exports.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/cjs/rules/use-primitives/transformers/index.js

@@ -3,28 +3,28 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-Object.defineProperty(exports, "cssToXcssTransformer", {
+Object.defineProperty(exports, "CompiledStyled", {
   enumerable: true,
   get: function get() {
-    return _cssToXcss.cssToXcssTransformer;
+    return _compiledStyled.CompiledStyled;
   }
 });
-Object.defineProperty(exports, "jsxElementToBoxTransformer", {
+Object.defineProperty(exports, "EmotionCSS", {
   enumerable: true,
   get: function get() {
-    return _jsxElementToBox.jsxElementToBoxTransformer;
+    return _emotionCss.EmotionCSS;
   }
 });
-Object.defineProperty(exports, "spaceTokenMap", {
+Object.defineProperty(exports, "cssToXcssTransformer", {
   enumerable: true,
   get: function get() {
-    return _cssToXcss.spaceTokenMap;
+    return _cssToXcss.cssToXcssTransformer;
   }
 });
-Object.defineProperty(exports, "styledComponentToPrimitive", {
+Object.defineProperty(exports, "spaceTokenMap", {
   enumerable: true,
   get: function get() {
-    return _styledComponentToPrimitive.styledComponentToPrimitive;
+    return _cssToXcss.spaceTokenMap;
   }
 });
 Object.defineProperty(exports, "supportedStylesMap", {
@@ -34,5 +34,5 @@ Object.defineProperty(exports, "supportedStylesMap", {
   }
 });
 var _cssToXcss = require("./css-to-xcss");
-var _jsxElementToBox = require("./jsx-element-to-box");
-var _styledComponentToPrimitive = require("./styled-component-to-primitive");
+var _compiledStyled = require("./compiled-styled");
+var _emotionCss = require("./emotion-css");

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

@@ -3,30 +3,12 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-Object.defineProperty(exports, "containsOnlySupportedAttrs", {
-  enumerable: true,
-  get: function get() {
-    return _containsOnlySupportedAttrs.containsOnlySupportedAttrs;
-  }
-});
 Object.defineProperty(exports, "convertASTObjectExpressionToJSObject", {
   enumerable: true,
   get: function get() {
     return _convertAstObjectExpressionToJsObject.convertASTObjectExpressionToJSObject;
   }
 });
-Object.defineProperty(exports, "findValidJsxUsageToTransform", {
-  enumerable: true,
-  get: function get() {
-    return _findValidJsxUsageToTransform.findValidJsxUsageToTransform;
-  }
-});
-Object.defineProperty(exports, "findValidStyledComponentCall", {
-  enumerable: true,
-  get: function get() {
-    return _findValidStyledComponentCall.findValidStyledComponentCall;
-  }
-});
 Object.defineProperty(exports, "getAttributeValueIdentifier", {
   enumerable: true,
   get: function get() {
@@ -69,34 +51,13 @@ Object.defineProperty(exports, "isValidCssPropertiesToTransform", {
     return _isValidCssPropertiesToTransform.isValidCssPropertiesToTransform;
   }
 });
-Object.defineProperty(exports, "isValidTagName", {
-  enumerable: true,
-  get: function get() {
-    return _isValidTagName.isValidTagName;
-  }
-});
 Object.defineProperty(exports, "updateJSXAttributeByName", {
   enumerable: true,
   get: function get() {
     return _updateJsxAttributeByName.updateJSXAttributeByName;
   }
 });
-Object.defineProperty(exports, "updateJSXElementName", {
-  enumerable: true,
-  get: function get() {
-    return _updateJsxElementName.updateJSXElementName;
-  }
-});
-Object.defineProperty(exports, "upsertImportDeclaration", {
-  enumerable: true,
-  get: function get() {
-    return _upsertImportDeclaration.upsertImportDeclaration;
-  }
-});
-var _containsOnlySupportedAttrs = require("./contains-only-supported-attrs");
 var _convertAstObjectExpressionToJsObject = require("./convert-ast-object-expression-to-js-object");
-var _findValidJsxUsageToTransform = require("./find-valid-jsx-usage-to-transform");
-var _findValidStyledComponentCall = require("./find-valid-styled-component-call");
 var _getAttributeValueIdentifier = require("./get-attribute-value-identifier");
 var _getFunctionArgumentAtPos = require("./get-function-argument-at-pos");
 var _getJsxAttributeByName = require("./get-jsx-attribute-by-name");
@@ -104,7 +65,4 @@ var _getVariableDefinitionValue = require("./get-variable-definition-value");
 var _getVariableUsageCount = require("./get-variable-usage-count");
 var _isFunctionNamed = require("./is-function-named");
 var _isValidCssPropertiesToTransform = require("./is-valid-css-properties-to-transform");
-var _isValidTagName = require("./is-valid-tag-name");
-var _updateJsxAttributeByName = require("./update-jsx-attribute-by-name");
-var _updateJsxElementName = require("./update-jsx-element-name");
-var _upsertImportDeclaration = require("./upsert-import-declaration");
+var _updateJsxAttributeByName = require("./update-jsx-attribute-by-name");

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

@@ -12,6 +12,9 @@ var _cssToXcss = require("../transformers/css-to-xcss");
 var _convertAstObjectExpressionToJsObject = require("./convert-ast-object-expression-to-js-object");
 var _excluded = ["unsupported"];
 var isValidCssPropertiesToTransform = exports.isValidCssPropertiesToTransform = function isValidCssPropertiesToTransform(node, config) {
+  if (!node) {
+    return false;
+  }
   var cssObjectExpression = node.arguments[0];
   // Bail on empty object calls
   if (!cssObjectExpression || !(0, _eslintCodemodUtils.isNodeOfType)(cssObjectExpression, 'ObjectExpression')) {

package/dist/es2019/ast-nodes/function-call.js

@@ -0,0 +1,42 @@
+/* eslint-disable @repo/internal/react/require-jsdoc */
+
+import { isNodeOfType } from 'eslint-codemod-utils';
+export const FunctionCall = {
+  getName(node) {
+    if (!isNodeOfType(node, 'CallExpression')) {
+      return undefined;
+    }
+    if (!isNodeOfType(node.callee, 'Identifier')) {
+      return undefined;
+    }
+    return node.callee.name;
+  },
+  updateName(node, newName, fixer) {
+    return fixer.replaceText(node.callee, newName);
+  },
+  /**
+   * 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, pos) {
+    const argument = node.arguments[pos];
+    if (isNodeOfType(argument, 'Literal') && argument.value) {
+      var _argument$value;
+      return {
+        type: 'Literal',
+        value: (_argument$value = argument.value) === null || _argument$value === void 0 ? void 0 : _argument$value.toString()
+      };
+    }
+    if (isNodeOfType(argument, 'ObjectExpression')) {
+      argument;
+      return {
+        type: 'ObjectExpression',
+        value: argument
+      };
+    }
+  }
+};

package/dist/es2019/ast-nodes/import.js

@@ -0,0 +1,42 @@
+/* eslint-disable @repo/internal/react/require-jsdoc */
+
+import { insertImportSpecifier, isNodeOfType } from 'eslint-codemod-utils';
+export 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, specifiers, fixer) {
+    /**
+     * `insertImportSpecifier()` has the unfortunate implementation detail of naively adding duplicate specifiers.
+     * e.g. calling
+     *  `insertImportSpecifier(importDecl, 'xcss')`
+     * on
+     * `import { Inline, xcss } from '@atlaskit/primitives'`
+     * will result in:
+     * `import { Inline, xcss, xcss } from '@atlaskit/primitives'`.
+     * So, we need to filter out specifiers that are already imported.
+     */
+    const uniqueSpecifiers = specifiers.filter(specifier => {
+      return !this.containsNamedSpecifier(node, specifier);
+    });
+    if (uniqueSpecifiers.length === 0) {
+      return;
+    }
+    return fixer.replaceText(node, `${insertImportSpecifier(node, uniqueSpecifiers.join(', '))};\n`);
+  },
+  containsNamedSpecifier(node, name) {
+    return node.specifiers.some(specifier => {
+      if (!isNodeOfType(specifier, 'ImportSpecifier')) {
+        return false;
+      }
+      return specifier.imported.name === name;
+    });
+  }
+};

package/dist/es2019/ast-nodes/index.js

@@ -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/es2019/ast-nodes/jsx-attribute.js

@@ -0,0 +1,59 @@
+import { isNodeOfType, literal } from 'eslint-codemod-utils';
+const HelperJSXAttribute = {
+  getName(node) {
+    if (!isNodeOfType(node, 'JSXAttribute')) {
+      throw new Error('Not a JSXAttribute');
+    }
+    if (!isNodeOfType(node.name, 'JSXIdentifier')) {
+      throw new Error('name is not a JSXIdentifier');
+    }
+    return node.name.name;
+  },
+  updateName(node, name, fixer) {
+    if (!isNodeOfType(node, 'JSXAttribute')) {
+      throw new Error('Not a JSXAttribute');
+    }
+    if (!isNodeOfType(node.name, 'JSXIdentifier')) {
+      throw new Error('name is not a JSXIdentifier');
+    }
+    return fixer.replaceText(node.name, literal(name).toString());
+  },
+  /**
+   * 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) {
+    if (!isNodeOfType(node, 'JSXAttribute')) {
+      return;
+    }
+    if (!node.value) {
+      return;
+    }
+
+    // handle `css={myStyles}`
+    if (isNodeOfType(node.value, 'JSXExpressionContainer') && isNodeOfType(node.value.expression, 'Identifier')) {
+      return {
+        type: 'ExpressionStatement',
+        value: node.value.expression.name
+      };
+    }
+
+    // handle `css='myStyles'`
+    if (isNodeOfType(node.value, 'Literal') && node.value.value) {
+      var _node$value$value;
+      return {
+        type: 'Literal',
+        value: (_node$value$value = node.value.value) === null || _node$value$value === void 0 ? void 0 : _node$value$value.toString()
+      };
+    }
+  }
+};
+export { HelperJSXAttribute as JSXAttribute };