@atlaskit/codemod-cli 0.24.1 → 0.24.3

package/dist/es2019/presets/migrate-to-new-buttons/codemods/next-migrate-to-new-button-variants.js

@@ -1,6 +1,8 @@
 import { addCommentBefore } from '@atlaskit/codemod-utils';
 import { getDefaultImportSpecifierName } from '@hypermod/utils';
-import { PRINT_SETTINGS, NEW_BUTTON_VARIANTS, entryPointsMapping, NEW_BUTTON_ENTRY_POINT, linkButtonMissingHrefComment, buttonPropsNoLongerSupportedComment, unsupportedProps } from '../utils/constants';
+import { PRINT_SETTINGS, OLD_BUTTON_VARIANTS, NEW_BUTTON_VARIANTS, entryPointsMapping, OLD_BUTTON_ENTRY_POINT, NEW_BUTTON_ENTRY_POINT, linkButtonMissingHrefComment, buttonPropsNoLongerSupportedComment, unsupportedProps, loadingButtonComment } from '../utils/constants';
+import getDefaultImports from '../utils/get-default-imports';
+import getSpecifierNames from '../utils/get-specifier-names';
 import { generateNewElement, handleIconAttributes } from '../utils/generate-new-button-element';
 import { ifHasUnsupportedProps } from '../utils/has-unsupported-props';
 import { checkIfVariantAlreadyImported } from '../utils/if-variant-already-imported';
@@ -12,22 +14,38 @@ const transformer = (file, api) => {
   const j = api.jscodeshift;
   const fileSource = j(file.source);
   addCommentForCustomThemeButtons(fileSource, j);
-  const buttonImports = fileSource.find(j.ImportDeclaration).filter(path => path.node.source.value === entryPointsMapping.Button || path.node.source.value === entryPointsMapping.LoadingButton || path.node.source.value === NEW_BUTTON_ENTRY_POINT);
-  if (!buttonImports.length) {
-    return fileSource.toSource();
-  }
-  const defaultButtonImport = buttonImports.find(j.Specifier).filter(path => path.node.type === 'ImportDefaultSpecifier');
-  if (defaultButtonImport.length === 0) {
+
+  // Find old buttons
+  const oldButtonImports = fileSource.find(j.ImportDeclaration).filter(path => path.node.source.value === entryPointsMapping.Button || path.node.source.value === entryPointsMapping.LoadingButton || path.node.source.value === OLD_BUTTON_ENTRY_POINT);
+  if (!oldButtonImports.length) {
     return fileSource.toSource();
   }
-  const specifierIdentifier = defaultButtonImport.get(0).node.local.name;
-  let hasLinkIconButton = checkIfVariantAlreadyImported(NEW_BUTTON_VARIANTS.linkIcon, fileSource, j);
-  let hasLinkButton = checkIfVariantAlreadyImported(NEW_BUTTON_VARIANTS.link, fileSource, j);
-  let hasIconButton = checkIfVariantAlreadyImported(NEW_BUTTON_VARIANTS.icon, fileSource, j);
-  const allButtons = fileSource.find(j.JSXElement).filter(path => path.value.openingElement.name.type === 'JSXIdentifier' && path.value.openingElement.name.name === specifierIdentifier);
-  const buttonsWithoutUnsupportedProps = allButtons.filter(path => !ifHasUnsupportedProps(path.value.openingElement.attributes));
-  const loadingButtonImportName = getDefaultImportSpecifierName(j, fileSource, entryPointsMapping.LoadingButton);
-  buttonsWithoutUnsupportedProps.forEach(element => {
+  const oldDefaultDefaultImports = getDefaultImports(oldButtonImports, j);
+  const oldDefaultImportSpecifiers = getSpecifierNames(oldDefaultDefaultImports);
+
+  // Find new buttons
+  const newButtonImports = fileSource.find(j.ImportDeclaration).filter(path => path.node.source.value === NEW_BUTTON_ENTRY_POINT);
+  const newDefaultDefaultImports = getDefaultImports(newButtonImports, j);
+  const newDefaultImportSpecifiers = getSpecifierNames(newDefaultDefaultImports);
+  const loadingButtonDirectImportName = getDefaultImportSpecifierName(j, fileSource, entryPointsMapping.LoadingButton);
+
+  /**
+   * Which variants should be in this file?
+   *
+   * Any variants enabled here will be added to the final import statement.
+   * Initial values check if the variant is already imported in the file.
+   */
+  let hasVariant = {
+    defaultButton: checkIfVariantAlreadyImported(NEW_BUTTON_VARIANTS.default, NEW_BUTTON_ENTRY_POINT, fileSource, j, true),
+    linkButton: checkIfVariantAlreadyImported(NEW_BUTTON_VARIANTS.link, NEW_BUTTON_ENTRY_POINT, fileSource, j),
+    iconButton: checkIfVariantAlreadyImported(NEW_BUTTON_VARIANTS.icon, NEW_BUTTON_ENTRY_POINT, fileSource, j),
+    linkIconButton: checkIfVariantAlreadyImported(NEW_BUTTON_VARIANTS.linkIcon, NEW_BUTTON_ENTRY_POINT, fileSource, j)
+  };
+  const oldButtonElements = fileSource.find(j.JSXElement).filter(path => {
+    return path.value.openingElement.name.type === 'JSXIdentifier' && ((oldDefaultImportSpecifiers === null || oldDefaultImportSpecifiers === void 0 ? void 0 : oldDefaultImportSpecifiers.includes(path.value.openingElement.name.name)) || Object.values(OLD_BUTTON_VARIANTS).includes(path.value.openingElement.name.name));
+  });
+  const oldButtonsWithoutUnsupportedProps = oldButtonElements.filter(path => !ifHasUnsupportedProps(path.value.openingElement.attributes));
+  oldButtonsWithoutUnsupportedProps.forEach(element => {
     var _element$value$childr;
     const {
       attributes
@@ -43,9 +61,14 @@ const transformer = (file, api) => {
     const isLinkIconButton = hasHref && hasIcon && hasNoChildren && !isFitContainerIconButton;
     const isLinkButton = hasHref && !isLinkIconButton;
     let isIconButton = !hasHref && hasIcon && hasNoChildren && !isFitContainerIconButton;
-    const isDefaultButtonWithAnIcon = !isLinkIconButton && !isIconButton && !isFitContainerIconButton && hasIcon;
-    const isLoadingButton = element.value.openingElement.name.type === 'JSXIdentifier' && element.value.openingElement.name.name === loadingButtonImportName;
-    if (isDefaultButtonWithAnIcon) {
+    const isDefaultButton = !isLinkButton && !isLinkIconButton && !isIconButton && !isFitContainerIconButton;
+    const isDefaultVariantWithAnIcon = !isLinkIconButton && !isIconButton && !isFitContainerIconButton && hasIcon;
+    const isLoadingButton = element.value.openingElement.name.type === 'JSXIdentifier' && element.value.openingElement.name.name === loadingButtonDirectImportName;
+    const linkAppearanceAttribute = attributes.find(node => {
+      var _node$value, _node$name, _node$value2, _node$value3;
+      return node.type === 'JSXAttribute' && ((_node$value = node.value) === null || _node$value === void 0 ? void 0 : _node$value.type) === 'StringLiteral' && (node === null || node === void 0 ? void 0 : (_node$name = node.name) === null || _node$name === void 0 ? void 0 : _node$name.name) === 'appearance' && ((node === null || node === void 0 ? void 0 : (_node$value2 = node.value) === null || _node$value2 === void 0 ? void 0 : _node$value2.value) === 'link' || (node === null || node === void 0 ? void 0 : (_node$value3 = node.value) === null || _node$value3 === void 0 ? void 0 : _node$value3.value) === 'subtle-link');
+    });
+    if (isDefaultVariantWithAnIcon) {
       handleIconAttributes(element.value, j);
     }
     if (isFitContainerIconButton) {
@@ -54,61 +77,74 @@ const transformer = (file, api) => {
         isIconButton = true;
       }
     }
-    if (isLinkIconButton) {
-      hasLinkIconButton = true;
+    if (isLinkIconButton && !isLoadingButton) {
+      hasVariant.linkIconButton = true;
       j(element).replaceWith(generateNewElement(NEW_BUTTON_VARIANTS.linkIcon, element.value, j));
     }
-    if (isIconButton) {
-      hasIconButton = true;
+    if (isIconButton && !isLoadingButton) {
+      hasVariant.iconButton = true;
       j(element).replaceWith(generateNewElement(NEW_BUTTON_VARIANTS.icon, element.value, j));
     }
-    if (isLinkButton) {
-      hasLinkButton = true;
+    if (isLinkButton && !isLoadingButton) {
+      hasVariant.linkButton = true;
       j(element).replaceWith(generateNewElement(NEW_BUTTON_VARIANTS.link, element.value, j));
     }
-    if (isLoadingButton) {
-      j(element).replaceWith(generateNewElement(NEW_BUTTON_VARIANTS.default, element.value, j));
+    if (isDefaultButton && !isLoadingButton) {
+      hasVariant.defaultButton = true;
+      j(element).replaceWith(generateNewElement(newDefaultImportSpecifiers !== null && newDefaultImportSpecifiers !== void 0 && newDefaultImportSpecifiers.length ?
+      // If new button already has a default import, use that incase it's aliased
+      newDefaultImportSpecifiers[0] : NEW_BUTTON_VARIANTS.default, element.value, j));
     }
-    const linkAppearanceAttribute = attributes.find(node => {
-      var _node$value, _node$name, _node$value2, _node$value3;
-      return node.type === 'JSXAttribute' && ((_node$value = node.value) === null || _node$value === void 0 ? void 0 : _node$value.type) === 'StringLiteral' && (node === null || node === void 0 ? void 0 : (_node$name = node.name) === null || _node$name === void 0 ? void 0 : _node$name.name) === 'appearance' && ((node === null || node === void 0 ? void 0 : (_node$value2 = node.value) === null || _node$value2 === void 0 ? void 0 : _node$value2.value) === 'link' || (node === null || node === void 0 ? void 0 : (_node$value3 = node.value) === null || _node$value3 === void 0 ? void 0 : _node$value3.value) === 'subtle-link');
-    });
-    if (!hasHref && linkAppearanceAttribute) {
+    if (isLoadingButton) {
+      const newElement = generateNewElement(NEW_BUTTON_VARIANTS[isIconButton || isLinkIconButton ? 'icon' : 'default'], element.value, j);
+      if (isIconButton || isLinkIconButton) {
+        hasVariant.iconButton = true;
+      } else {
+        hasVariant.defaultButton = true;
+      }
+      j(element).replaceWith(newElement);
+      if (hasHref || linkAppearanceAttribute) {
+        addCommentBefore(j, j(newElement), loadingButtonComment({
+          hasHref,
+          hasLinkAppearance: Boolean(linkAppearanceAttribute)
+        }), 'block');
+      }
+    } else if (!hasHref && linkAppearanceAttribute) {
       addCommentBefore(j, j(linkAppearanceAttribute), linkButtonMissingHrefComment, 'line');
     }
   });
 
   // modify import declarations
   let specifiers = [];
-  [hasLinkButton ? 'link' : null, hasIconButton ? 'icon' : null, hasLinkIconButton ? 'linkIcon' : null].forEach(variant => {
+  [hasVariant.linkButton ? 'link' : null, hasVariant.iconButton ? 'icon' : null, hasVariant.linkIconButton ? 'linkIcon' : null].forEach(variant => {
     if (variant) {
       specifiers.push(j.importSpecifier(j.identifier(NEW_BUTTON_VARIANTS[variant])));
     }
   });
-  const oldButtonImport = fileSource.find(j.ImportDeclaration).filter(path => path.node.source.value === NEW_BUTTON_ENTRY_POINT || path.node.source.value === entryPointsMapping.Button || path.node.source.value === entryPointsMapping.LoadingButton);
-  const remainingDefaultButtons = fileSource.find(j.JSXElement).filter(path => path.value.openingElement.name.type === 'JSXIdentifier' && path.value.openingElement.name.name === specifierIdentifier && !ifHasUnsupportedProps(path.value.openingElement.attributes)).length > 0 || fileSource.find(j.CallExpression).filter(path => path.node.arguments.map(argument => argument.type === 'Identifier' && (argument === null || argument === void 0 ? void 0 : argument.name)).includes(specifierIdentifier)).length > 0;
+  const remainingDefaultButtons = fileSource.find(j.JSXElement).filter(path => path.value.openingElement.name.type === 'JSXIdentifier' && Boolean(oldDefaultImportSpecifiers === null || oldDefaultImportSpecifiers === void 0 ? void 0 : oldDefaultImportSpecifiers.includes(path.value.openingElement.name.name)) && !ifHasUnsupportedProps(path.value.openingElement.attributes)).length > 0 || fileSource.find(j.CallExpression).filter(path => path.node.arguments.map(argument => argument.type === 'Identifier' && (argument === null || argument === void 0 ? void 0 : argument.name)).some(name => name && (oldDefaultImportSpecifiers === null || oldDefaultImportSpecifiers === void 0 ? void 0 : oldDefaultImportSpecifiers.includes(name)))).length > 0;
 
   // Loading buttons map back to default imports
-  if (specifierIdentifier === loadingButtonImportName) {
+  if (loadingButtonDirectImportName && oldDefaultImportSpecifiers !== null && oldDefaultImportSpecifiers !== void 0 && oldDefaultImportSpecifiers.includes(loadingButtonDirectImportName)) {
     fileSource
     // rename LoadingButton to Button in all call expressions i.e. render(LoadingButton), find(LoadingButton)
     .find(j.CallExpression).find(j.Identifier).forEach(path => {
-      if (path.node.name === loadingButtonImportName) {
+      if (path.node.name === loadingButtonDirectImportName) {
         path.node.name = NEW_BUTTON_VARIANTS.default;
       }
     });
-    specifiers.push(j.importDefaultSpecifier(j.identifier(NEW_BUTTON_VARIANTS.default)));
   }
-  if (!specifiers.find(specifier => specifier.type === 'ImportDefaultSpecifier') && remainingDefaultButtons) {
+
+  // Only add the Button import if we found a default button, not icon only
+  if (hasVariant.defaultButton || !specifiers.find(specifier => specifier.type === 'ImportDefaultSpecifier') && remainingDefaultButtons) {
     specifiers.push(j.importDefaultSpecifier(j.identifier(NEW_BUTTON_VARIANTS.default)));
   }
 
   // update import path for types imports
-  specifiers = importTypesFromNewEntryPoint(buttonImports, specifiers, j, fileSource);
-  const buttonsWithUnsupportedProps = allButtons.filter(path => ifHasUnsupportedProps(path.value.openingElement.attributes));
-  if (buttonsWithUnsupportedProps.length) {
+  specifiers = importTypesFromNewEntryPoint(oldButtonImports, specifiers, j, fileSource);
+  const oldButtonsWithUnsupportedProps = oldButtonElements.filter(path => ifHasUnsupportedProps(path.value.openingElement.attributes));
+  if (oldButtonsWithUnsupportedProps.length) {
     // add comment to all buttons with unsupported props: "component", "style", "css"
-    buttonsWithUnsupportedProps.forEach(element => {
+    oldButtonsWithUnsupportedProps.forEach(element => {
       var _element$value$openin;
       const attribute = (_element$value$openin = element.value.openingElement.attributes) === null || _element$value$openin === void 0 ? void 0 : _element$value$openin.find(node => node.type === 'JSXAttribute' && typeof node.name.name === 'string' && unsupportedProps.includes(node.name.name));
       if (attribute) {
@@ -118,16 +154,53 @@ const transformer = (file, api) => {
 
     // rename all buttons with unsupported props to LegacyButton if default new button is imported
     if (specifiers.find(specifier => specifier.type === 'ImportDefaultSpecifier')) {
-      renameDefaultButtonToLegacyButtonImport(oldButtonImport, buttonsWithUnsupportedProps, j);
+      renameDefaultButtonToLegacyButtonImport(oldButtonImports, oldButtonsWithUnsupportedProps, j);
     }
   }
   if (specifiers.length) {
-    const newButtonImport = j.importDeclaration(specifiers, j.stringLiteral(NEW_BUTTON_ENTRY_POINT));
-    oldButtonImport.forEach(path => {
+    const existingNewButtonImports = fileSource.find(j.ImportDeclaration).filter(path => path.node.source.value === NEW_BUTTON_ENTRY_POINT);
+    let newButtonImport = j.importDeclaration(specifiers, j.stringLiteral(NEW_BUTTON_ENTRY_POINT));
+    oldButtonImports.forEach(path => {
       var _path$node;
       newButtonImport.comments = path !== null && path !== void 0 && (_path$node = path.node) !== null && _path$node !== void 0 && _path$node.comments ? path.node.comments : undefined;
     });
-    oldButtonImport.replaceWith(newButtonImport);
+    if (existingNewButtonImports.length) {
+      existingNewButtonImports.forEach(path => {
+        // Merge specifiers from existing new button import with added specifiers
+        const mergedSpecifiers = [...specifiers.filter(specifier => {
+          var _path$node$specifiers;
+          if (specifier.type !== 'ImportDefaultSpecifier') {
+            return true;
+          }
+
+          // Ensure we don't add a duplicate default specifier if one is already imported
+          return !((_path$node$specifiers = path.node.specifiers) !== null && _path$node$specifiers !== void 0 && _path$node$specifiers.find(s => s.type === 'ImportDefaultSpecifier'));
+        }), ...(path.node.specifiers ? path.node.specifiers : [])]
+        // Filter duplicates
+        .filter(specifier => {
+          if (specifier.type === 'ImportDefaultSpecifier') {
+            return true;
+          }
+          const isAlreadyImported = specifiers.find(s => {
+            var _specifier$local;
+            return s.type === 'ImportSpecifier' && s.imported.name === ((_specifier$local = specifier.local) === null || _specifier$local === void 0 ? void 0 : _specifier$local.name);
+          });
+          return !isAlreadyImported;
+        });
+        newButtonImport = j.importDeclaration(mergedSpecifiers, j.stringLiteral(NEW_BUTTON_ENTRY_POINT));
+      });
+      oldButtonImports.remove();
+      existingNewButtonImports.replaceWith(newButtonImport);
+    } else {
+      oldButtonImports.replaceWith((_, index) => {
+        // Only replace the first import
+        if (index === 0) {
+          return newButtonImport;
+        }
+        // Remove the rest
+        return null;
+      });
+    }
   }
 
   // remove empty import declarations

package/dist/es2019/presets/migrate-to-new-buttons/codemods/next-split-imports.js

@@ -1,4 +1,6 @@
 import { PRINT_SETTINGS, entryPointsMapping, BUTTON_TYPES, NEW_BUTTON_ENTRY_POINT } from '../utils/constants';
+import renameElements from '../utils/rename-elements';
+import { getDefaultImportSpecifierName } from '@hypermod/utils';
 const transformer = (file, api) => {
   const j = api.jscodeshift;
   const fileSource = j(file.source);
@@ -14,17 +16,25 @@ const transformer = (file, api) => {
       specifiers,
       source
     } = node.node;
+
+    // Return early if the import is not a named import
     if ([...Object.values(entryPointsMapping), NEW_BUTTON_ENTRY_POINT, '@atlaskit/button/types'].includes(source.value)) {
       return fileSource.toSource(PRINT_SETTINGS);
     }
     const defaultSpecifier = specifiers === null || specifiers === void 0 ? void 0 : specifiers.find(specifier => specifier.type === 'ImportDefaultSpecifier');
     if (defaultSpecifier && defaultSpecifier.local) {
-      const defaultButtonImport = j.importDeclaration([j.importDefaultSpecifier(j.identifier(defaultSpecifier.local.name))], j.stringLiteral(entryPointsMapping.Button));
-      j(node).insertAfter(defaultButtonImport);
+      const existingSpecifier = getDefaultImportSpecifierName(j, fileSource, entryPointsMapping.Button);
+      if (existingSpecifier) {
+        var _defaultSpecifier$loc;
+        renameElements((_defaultSpecifier$loc = defaultSpecifier.local) === null || _defaultSpecifier$loc === void 0 ? void 0 : _defaultSpecifier$loc.name, existingSpecifier, fileSource, j);
+      } else {
+        const newImport = j.importDeclaration([j.importDefaultSpecifier(j.identifier(defaultSpecifier.local.name))], j.stringLiteral(entryPointsMapping.Button));
+        j(node).insertAfter(newImport);
+      }
     }
-    const valueSpecifiers = specifiers === null || specifiers === void 0 ? void 0 : specifiers.filter(specifier => specifier.type === 'ImportSpecifier');
-    const newTypeSpecifier = valueSpecifiers === null || valueSpecifiers === void 0 ? void 0 : valueSpecifiers.filter(specifier => specifier.type === 'ImportSpecifier' && (specifier.imported.name === 'Appearance' || specifier.imported.name === 'Spacing'));
-    const otherTypeSpecifiers = valueSpecifiers === null || valueSpecifiers === void 0 ? void 0 : valueSpecifiers.filter(specifier => BUTTON_TYPES.includes(specifier.imported.name));
+    const namedSpecifiers = specifiers === null || specifiers === void 0 ? void 0 : specifiers.filter(specifier => specifier.type === 'ImportSpecifier');
+    const newTypeSpecifier = namedSpecifiers === null || namedSpecifiers === void 0 ? void 0 : namedSpecifiers.filter(specifier => specifier.type === 'ImportSpecifier' && (specifier.imported.name === 'Appearance' || specifier.imported.name === 'Spacing'));
+    const otherTypeSpecifiers = namedSpecifiers === null || namedSpecifiers === void 0 ? void 0 : namedSpecifiers.filter(specifier => BUTTON_TYPES.includes(specifier.imported.name));
     if (newTypeSpecifier !== null && newTypeSpecifier !== void 0 && newTypeSpecifier.length) {
       const typeImport = j.importDeclaration(newTypeSpecifier, j.stringLiteral('@atlaskit/button/types'));
       j(node).insertAfter(typeImport);
@@ -33,11 +43,17 @@ const transformer = (file, api) => {
       const typeImport = j.importDeclaration(otherTypeSpecifiers, j.stringLiteral('@atlaskit/button'));
       j(node).insertAfter(typeImport);
     }
-    if (valueSpecifiers !== null && valueSpecifiers !== void 0 && valueSpecifiers.length) {
-      valueSpecifiers.forEach(specifier => {
+    if (namedSpecifiers !== null && namedSpecifiers !== void 0 && namedSpecifiers.length) {
+      namedSpecifiers.forEach(specifier => {
         if (specifier.local && specifier.type === 'ImportSpecifier' && specifier.local.name && entryPointsMapping[specifier.imported.name]) {
-          const newImport = j.importDeclaration([j.importDefaultSpecifier(j.identifier(specifier.local.name))], j.stringLiteral(entryPointsMapping[specifier.imported.name]));
-          j(node).insertAfter(newImport);
+          const existingSpecifier = getDefaultImportSpecifierName(j, fileSource, entryPointsMapping[specifier.imported.name]);
+          if (existingSpecifier) {
+            var _specifier$local;
+            renameElements((_specifier$local = specifier.local) === null || _specifier$local === void 0 ? void 0 : _specifier$local.name, existingSpecifier, fileSource, j);
+          } else {
+            const newImport = j.importDeclaration([j.importDefaultSpecifier(j.identifier(specifier.local.name))], j.stringLiteral(entryPointsMapping[specifier.imported.name]));
+            j(node).insertAfter(newImport);
+          }
         }
       });
     }

package/dist/es2019/presets/migrate-to-new-buttons/utils/constants.js

@@ -1,13 +1,21 @@
 export const PRINT_SETTINGS = {
   quote: 'single'
 };
+
+/** NEW button **/
+export const NEW_BUTTON_ENTRY_POINT = '@atlaskit/button/new';
 export const NEW_BUTTON_VARIANTS = {
   default: 'Button',
   link: 'LinkButton',
   icon: 'IconButton',
   linkIcon: 'LinkIconButton'
 };
-export const NEW_BUTTON_ENTRY_POINT = '@atlaskit/button/new';
+
+/** OLD button **/
+export const OLD_BUTTON_ENTRY_POINT = '@atlaskit/button';
+export const OLD_BUTTON_VARIANTS = {
+  loading: 'LoadingButton'
+};
 export const entryPointsMapping = {
   Button: '@atlaskit/button/standard-button',
   LoadingButton: '@atlaskit/button/loading-button',
@@ -25,4 +33,10 @@ export const linkButtonMissingHrefComment = `"link" and "subtle-link" appearance
 export const buttonPropsNoLongerSupportedComment = `Buttons with "component", "css" or "style" prop can't be automatically migrated with codemods. Please migrate it manually.`;
 export const migrateFitContainerButtonToDefaultButtonComment = `Migrated to a default button with text which is from the icon label.`;
 export const migrateFitContainerButtonToIconButtonComment = `"shouldFitContainer" is not available in icon buttons, please consider using a default button with text.`;
-export const customThemeButtonComment = `CustomThemeButton will be deprecated. Please consider migrating to Pressable or Anchor Primitives with custom styles.`;
+export const customThemeButtonComment = `CustomThemeButton will be deprecated. Please consider migrating to Pressable or Anchor Primitives with custom styles.`;
+export const loadingButtonComment = ({
+  hasLinkAppearance,
+  hasHref
+}) => {
+  return `This should be migrated to a new Button with a \`isLoading\` prop. ${hasLinkAppearance ? `"link" and "subtle-link" appearances are not available for new loading buttons."` : ''}${hasHref ? `The \`href\` attribute it not compatible with new loading buttons, because links should not need loading states.` : ''} Please reconsider the design or change the appearance of the button.`;
+};

package/dist/es2019/presets/migrate-to-new-buttons/utils/generate-new-button-element.js

@@ -48,7 +48,8 @@ export const handleIconAttributes = (element, j, iconRenamed = false) => {
     // takes precedence over icon label.
 
     const buttonAlreadyHasLabelProp = buttonAttributes === null || buttonAttributes === void 0 ? void 0 : buttonAttributes.find(buttonAttribute => buttonAttribute.type === 'JSXAttribute' && buttonAttribute.name.name === 'label');
-    if (!buttonAlreadyHasLabelProp) {
+    const buttonAlreadyHasAriaLabelProp = buttonAttributes === null || buttonAttributes === void 0 ? void 0 : buttonAttributes.find(buttonAttribute => buttonAttribute.type === 'JSXAttribute' && buttonAttribute.name.name === 'aria-label');
+    if (!buttonAlreadyHasLabelProp && !buttonAlreadyHasAriaLabelProp) {
       const labelAttribute = iconAttributes.find(attribute => attribute.type === 'JSXAttribute' && attribute.name.name === 'label');
       if (labelAttribute && labelAttribute.type === 'JSXAttribute' && iconRenamed) {
         buttonAttributes === null || buttonAttributes === void 0 ? void 0 : buttonAttributes.unshift(labelAttribute);
@@ -108,12 +109,18 @@ export const generateNewElement = (variant, element, j) => {
     if (ariaLabelAttr.length) {
       const hasNoLabelProp = !(attributes !== null && attributes !== void 0 && attributes.find(attribute => attribute.type === 'JSXAttribute' && attribute.name.name === 'label'));
       if (hasNoLabelProp && attributes) {
-        attributes.push(j.jsxAttribute(j.jsxIdentifier('label'), ariaLabelAttr.get().node.value));
+        attributes.unshift(j.jsxAttribute.from({
+          name: j.jsxIdentifier('label'),
+          value: j.literal(ariaLabelAttr.get().value.value.value)
+        }));
       }
       ariaLabelAttr.remove();
     }
   }
-  return j.jsxElement(
-  // self closing if it's an icon button or icon link button
-  j.jsxOpeningElement(j.jsxIdentifier(variant), attributes, isIconOrLinkIcon), isIconOrLinkIcon ? null : j.jsxClosingElement(j.jsxIdentifier(variant)), element.children);
+  return j.jsxElement.from({
+    openingElement: j.jsxOpeningElement(j.jsxIdentifier(variant), attributes, isIconOrLinkIcon),
+    // self closing if it's an icon button or icon link button
+    closingElement: isIconOrLinkIcon ? null : j.jsxClosingElement(j.jsxIdentifier(variant)),
+    children: element.children
+  });
 };

package/dist/es2019/presets/migrate-to-new-buttons/utils/get-default-imports.js

@@ -0,0 +1,6 @@
+/**
+ * Returns default import specifiers from the given import declarations.
+ */
+export default function getDefaultImports(importDeclarations, j) {
+  return importDeclarations.find(j.Specifier).filter(path => path.node.type === 'ImportDefaultSpecifier');
+}

package/dist/es2019/presets/migrate-to-new-buttons/utils/get-specifier-names.js

@@ -0,0 +1,6 @@
+/**
+ * Returns a list of specifier names from the given specifiers.
+ */
+export default function getSpecifierNames(specifiers) {
+  return specifiers.length ? specifiers.paths().map(path => path.get().value.local.name) : undefined;
+}

package/dist/es2019/presets/migrate-to-new-buttons/utils/if-variant-already-imported.js

@@ -1,4 +1,10 @@
-import { NEW_BUTTON_ENTRY_POINT } from './constants';
-export const checkIfVariantAlreadyImported = (variant, fileSource, j) => {
-  return fileSource.find(j.ImportDeclaration).filter(path => path.node.source.value === NEW_BUTTON_ENTRY_POINT).find(j.ImportSpecifier).filter(path => path.node.imported.name === variant).length > 0;
+export const findVariantAlreadyImported = (variant, entryPoint, fileSource, j, isDefaultSpecifier = false) => {
+  const imports = fileSource.find(j.ImportDeclaration).filter(path => path.node.source.value === entryPoint);
+  if (isDefaultSpecifier) {
+    return imports.find(j.ImportDefaultSpecifier);
+  }
+  return imports.find(j.ImportSpecifier).filter(path => path.node.imported.name === variant);
+};
+export const checkIfVariantAlreadyImported = (variant, entryPoint, fileSource, j, isDefaultSpecifier = false) => {
+  return findVariantAlreadyImported(variant, entryPoint, fileSource, j, isDefaultSpecifier).length > 0;
 };

package/dist/es2019/presets/migrate-to-new-buttons/utils/rename-elements.js

@@ -0,0 +1,12 @@
+export default function renameElements(elementName, newElementName, fileSource, j) {
+  const oldElements = fileSource.find(j.JSXElement).filter(path => {
+    return path.value.openingElement.name.type === 'JSXIdentifier' && path.value.openingElement.name.name === elementName;
+  });
+
+  // Rename elements to match existing import name
+  oldElements.forEach(element => {
+    var _element$value$childr, _element$value$childr2;
+    const newElement = j.jsxElement(j.jsxOpeningElement(j.jsxIdentifier(newElementName), element.value.openingElement.attributes, ((_element$value$childr = element.value.children) === null || _element$value$childr === void 0 ? void 0 : _element$value$childr.length) === 0), ((_element$value$childr2 = element.value.children) === null || _element$value$childr2 === void 0 ? void 0 : _element$value$childr2.length) === 0 ? null : j.jsxClosingElement(j.jsxIdentifier(newElementName)), element.value.children);
+    j(element).replaceWith(newElement);
+  });
+}

package/dist/esm/main.js

@@ -298,7 +298,7 @@ function _main() {
         case 4:
           _yield$parseArgs = _context5.sent;
           packages = _yield$parseArgs.packages;
-          _process$env$_PACKAGE = "0.24.1", _PACKAGE_VERSION_ = _process$env$_PACKAGE === void 0 ? '0.0.0-dev' : _process$env$_PACKAGE;
+          _process$env$_PACKAGE = "0.24.3", _PACKAGE_VERSION_ = _process$env$_PACKAGE === void 0 ? '0.0.0-dev' : _process$env$_PACKAGE;
           logger.log(chalk.bgBlue(chalk.black("\uD83D\uDCDA Atlassian-Frontend codemod library @ ".concat(_PACKAGE_VERSION_, " \uD83D\uDCDA"))));
           if (packages && packages.length > 0) {
             logger.log(chalk.gray("Searching for codemods for newer versions of the following packages: ".concat(packages.map(function (pkg) {