@atlaskit/codemod-cli 0.33.1 → 0.34.0

package/CHANGELOG.md

@@ -1,5 +1,21 @@
 # @atlaskit/codemod-cli
 
+## 0.34.0
+
+### Minor Changes
+
+- [`7e8bbc2620251`](https://bitbucket.org/atlassian/atlassian-frontend-monorepo/commits/7e8bbc2620251) -
+  Added a codemod lozenge-discovery-to-tag-with-fg to migrate Lozenge components with
+  appearance='new' or 'discovery' to Tag behind feature gate.
+
+## 0.33.2
+
+### Patch Changes
+
+- [`036c3ee917e3c`](https://bitbucket.org/atlassian/atlassian-frontend-monorepo/commits/036c3ee917e3c) -
+  Icon migration entry point update
+- Updated dependencies
+
 ## 0.33.1
 
 ### Patch Changes

package/dist/cjs/main.js

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

package/dist/cjs/presets/index.js

@@ -16,14 +16,16 @@ require("./remove-dark-theme-vr-options/remove-dark-theme-vr-options");
 require("./remove-token-fallbacks/remove-token-fallbacks");
 require("./lozenge-appearance-semantic-migration/lozenge-appearance-semantic-migration");
 require("./lozenge-to-tag-migration/lozenge-to-tag-migration");
+require("./lozenge-discovery-to-tag-with-fg/lozenge-discovery-to-tag-with-fg");
 require("./badge-appearance-semantic-migration/badge-appearance-semantic-migration");
 require("./tag-to-newTag-migration/tag-to-newTag-migration");
+require("./migrate-deprecated-icon/migrate-deprecated-icon");
 /**
  * Manually import presets to make sure typescript includes them
  * in the final bundle.
  */
 
-var presets = ['styled-to-emotion', 'theme-remove-deprecated-mixins', 'migrate-to-link', 'migrate-to-new-buttons', 'migrate-icon-object-to-object', 'upgrade-pragmatic-drag-and-drop-to-stable', 'remove-dark-theme-vr-options', 'remove-token-fallbacks', 'lozenge-appearance-semantic-migration', 'lozenge-to-tag-migration', 'badge-appearance-semantic-migration', 'tag-to-newTag-migration'].map(function (preset) {
+var presets = ['styled-to-emotion', 'theme-remove-deprecated-mixins', 'migrate-deprecated-icon', 'migrate-to-link', 'migrate-to-new-buttons', 'migrate-icon-object-to-object', 'upgrade-pragmatic-drag-and-drop-to-stable', 'remove-dark-theme-vr-options', 'remove-token-fallbacks', 'lozenge-appearance-semantic-migration', 'lozenge-to-tag-migration', 'lozenge-discovery-to-tag-with-fg', 'badge-appearance-semantic-migration', 'tag-to-newTag-migration'].map(function (preset) {
   return _path.default.join(__dirname, preset, "".concat(preset, ".@(ts|js|tsx)"));
 });
 var _default = exports.default = presets;

package/dist/cjs/presets/lozenge-discovery-to-tag-with-fg/codemods/lozenge-discovery-to-tag-with-fg.js

@@ -0,0 +1,219 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = transformer;
+/* eslint-disable @repo/internal/fs/filename-pattern-match */
+
+var LOZENGE_ENTRY_POINT = '@atlaskit/lozenge';
+var TAG_ENTRY_POINT = '@atlaskit/tag';
+var FG_ENTRY_POINT = '@atlassian/jira-feature-gating';
+var FEATURE_GATE_NAME = 'platform-dst-lozenge-tag-badge-visual-uplifts';
+var PRINT_SETTINGS = {
+  quote: 'single'
+};
+/**
+ * Codemod to migrate Lozenge components with appearance='new' or 'discovery' to Tag behind feature gate.
+ *
+ * This codemod:
+ * 1. Finds Lozenges with appearance="new" or appearance="discovery"
+ * 2. Also includes discovery Lozenges with isBold={true} or isBold
+ * 3. Wraps them in a feature gate: fg('platform-dst-lozenge-tag-badge-visual-uplifts')
+ * 4. Converts to Tag with color="purple" when feature gate is off
+ * 5. Adds necessary imports (Tag, fg)
+ */
+function transformer(file, api) {
+  var j = api.jscodeshift;
+  var source;
+
+  // Try to parse the file
+  try {
+    source = j(file.source);
+  } catch (error) {
+    // eslint-disable-next-line no-console
+    console.error(error);
+    return file.source;
+  }
+
+  // Check if Lozenge is imported from @atlaskit/lozenge
+  var hasLozengeImport = source.find(j.ImportDeclaration).some(function (importPath) {
+    return importPath.value.source.value === LOZENGE_ENTRY_POINT;
+  });
+  if (!hasLozengeImport) {
+    return file.source;
+  }
+
+  // Get all Lozenge component names (handles renamed imports)
+  var lozengeNames = new Set();
+  source.find(j.ImportDeclaration).forEach(function (importPath) {
+    if (importPath.value.source.value === LOZENGE_ENTRY_POINT) {
+      var _importPath$value$spe;
+      (_importPath$value$spe = importPath.value.specifiers) === null || _importPath$value$spe === void 0 || _importPath$value$spe.forEach(function (specifier) {
+        if (specifier.type === 'ImportDefaultSpecifier') {
+          lozengeNames.add(specifier.local.name);
+        } else if (specifier.type === 'ImportSpecifier' && specifier.imported.name === 'default') {
+          lozengeNames.add(specifier.local.name);
+        }
+      });
+    }
+  });
+
+  // Find all Lozenge elements that should be migrated
+  var lozengeElements = [];
+  source.find(j.JSXElement).forEach(function (path) {
+    var _openingElement$name;
+    var openingElement = path.value.openingElement;
+    if (((_openingElement$name = openingElement.name) === null || _openingElement$name === void 0 ? void 0 : _openingElement$name.type) === 'JSXIdentifier' && lozengeNames.has(openingElement.name.name)) {
+      var _openingElement$attri;
+      var element = {
+        path: path,
+        shouldMigrate: false
+      };
+
+      // Check for appearance and isBold props
+      (_openingElement$attri = openingElement.attributes) === null || _openingElement$attri === void 0 || _openingElement$attri.forEach(function (attr) {
+        var _attr$name;
+        if (attr.type === 'JSXAttribute' && ((_attr$name = attr.name) === null || _attr$name === void 0 ? void 0 : _attr$name.type) === 'JSXIdentifier') {
+          if (attr.name.name === 'appearance') {
+            var _attr$value, _attr$value2;
+            if (((_attr$value = attr.value) === null || _attr$value === void 0 ? void 0 : _attr$value.type) === 'StringLiteral') {
+              element.appearanceValue = attr.value.value;
+            } else if (((_attr$value2 = attr.value) === null || _attr$value2 === void 0 ? void 0 : _attr$value2.type) === 'JSXExpressionContainer') {
+              var expression = attr.value.expression;
+              if (expression.type === 'StringLiteral') {
+                element.appearanceValue = expression.value;
+              }
+            }
+          } else if (attr.name.name === 'isBold') {
+            var _attr$value3;
+            if (attr.value === null) {
+              element.isBoldValue = true;
+            } else if (((_attr$value3 = attr.value) === null || _attr$value3 === void 0 ? void 0 : _attr$value3.type) === 'JSXExpressionContainer') {
+              var _expression = attr.value.expression;
+              if (_expression.type === 'BooleanLiteral') {
+                element.isBoldValue = _expression.value;
+              } else if (_expression.type === 'Literal' && typeof _expression.value === 'boolean') {
+                element.isBoldValue = _expression.value;
+              }
+            }
+          }
+        }
+      });
+
+      // Determine if this Lozenge should be migrated
+      // Migrate if: appearance="new" OR appearance="discovery" OR (appearance="discovery" AND isBold={true})
+      if (element.appearanceValue === 'new' || element.appearanceValue === 'discovery' || element.appearanceValue === 'discovery' && element.isBoldValue === true) {
+        element.shouldMigrate = true;
+      }
+      if (element.shouldMigrate) {
+        lozengeElements.push(element);
+      }
+    }
+  });
+
+  // If no elements to migrate, return early
+  if (lozengeElements.length === 0) {
+    return file.source;
+  }
+
+  // Check if Tag import exists
+  var hasTagImport = source.find(j.ImportDeclaration).some(function (importPath) {
+    return importPath.value.source.value === TAG_ENTRY_POINT;
+  });
+
+  // Check if fg is already imported from @atlassian/jira-feature-gating
+  var hasFgImport = source.find(j.ImportDeclaration).some(function (importPath) {
+    if (importPath.value.source.value === FG_ENTRY_POINT) {
+      var _importPath$value$spe2;
+      // Check if 'fg' is in the specifiers
+      return (_importPath$value$spe2 = importPath.value.specifiers) === null || _importPath$value$spe2 === void 0 ? void 0 : _importPath$value$spe2.some(function (spec) {
+        return spec.type === 'ImportSpecifier' && spec.imported.name === 'fg';
+      });
+    }
+    return false;
+  });
+
+  // Add imports after Lozenge import to avoid blank lines
+  var lozengeImport = source.find(j.ImportDeclaration).filter(function (path) {
+    return path.value.source.value === LOZENGE_ENTRY_POINT;
+  }).at(0);
+  if (lozengeImport.length > 0) {
+    // Add imports in reverse order so they appear in the right order
+    if (!hasFgImport) {
+      lozengeImport.insertAfter(j.importDeclaration([j.importSpecifier(j.identifier('fg'))], j.stringLiteral(FG_ENTRY_POINT)));
+    }
+    if (!hasTagImport) {
+      lozengeImport.insertAfter(j.importDeclaration([j.importDefaultSpecifier(j.identifier('Tag'))], j.stringLiteral(TAG_ENTRY_POINT)));
+    }
+  }
+
+  // Transform each element
+  lozengeElements.forEach(function (element) {
+    var _openingElement$attri2;
+    var path = element.path;
+    var openingElement = path.value.openingElement;
+
+    // Extract text content or JSX expression from children
+    var children = path.value.children;
+    var textAttribute = null;
+    if (children && children.length > 0) {
+      // Check if there's a single JSX expression child (e.g., {formatMessage(...)})
+      if (children.length === 1 && children[0].type === 'JSXExpressionContainer') {
+        var expression = children[0].expression;
+        // Use the expression as the text value
+        textAttribute = j.jsxAttribute(j.jsxIdentifier('text'), j.jsxExpressionContainer(expression));
+      } else {
+        // Extract plain text content from JSXText nodes
+        var textContent = children.filter(function (child) {
+          return child.type === 'JSXText';
+        }).map(function (child) {
+          return child.value.trim();
+        }).filter(function (text) {
+          return text.length > 0;
+        }).join(' ');
+        if (textContent) {
+          textAttribute = j.jsxAttribute(j.jsxIdentifier('text'), j.stringLiteral(textContent));
+        }
+      }
+    }
+
+    // Create the Tag element
+    var tagAttributes = [j.jsxAttribute(j.jsxIdentifier('color'), j.stringLiteral('purple'))];
+    if (textAttribute) {
+      tagAttributes.unshift(textAttribute);
+    }
+
+    // Copy other props from Lozenge to Tag (except appearance and isBold)
+    (_openingElement$attri2 = openingElement.attributes) === null || _openingElement$attri2 === void 0 || _openingElement$attri2.forEach(function (attr) {
+      var _attr$name2;
+      if (attr.type === 'JSXAttribute' && ((_attr$name2 = attr.name) === null || _attr$name2 === void 0 ? void 0 : _attr$name2.type) === 'JSXIdentifier') {
+        if (attr.name.name !== 'appearance' && attr.name.name !== 'isBold') {
+          tagAttributes.push(attr);
+        }
+      }
+    });
+    var tagElement = j.jsxElement(j.jsxOpeningElement(j.jsxIdentifier('Tag'), tagAttributes, true), null, []);
+
+    // Keep the original Lozenge element (just the element, without wrapping)
+    var lozengeElement = path.value;
+
+    // Create the conditional expression: fg(FEATURE_GATE_NAME) ? <Tag .../> : <Lozenge .../>
+    // When feature gate is ON, show Tag (new behavior)
+    // When feature gate is OFF, show Lozenge (old behavior)
+    var conditionalExpression = j.conditionalExpression(j.callExpression(j.identifier('fg'), [j.stringLiteral(FEATURE_GATE_NAME)]), tagElement, lozengeElement);
+
+    // Check if the parent is a JSXElement (means we're inside JSX, need curly braces)
+    // Otherwise, it's a regular expression (like in a return statement)
+    var parent = path.parent;
+    var needsJSXWrapper = parent && (parent.value.type === 'JSXElement' || parent.value.type === 'JSXExpressionContainer');
+    if (needsJSXWrapper) {
+      // Inside JSX, wrap in expression container
+      j(path).replaceWith(j.jsxExpressionContainer(conditionalExpression));
+    } else {
+      // In regular JS context (like return statement), just use the conditional
+      j(path).replaceWith(conditionalExpression);
+    }
+  });
+  return source.toSource(PRINT_SETTINGS);
+}

package/dist/cjs/presets/lozenge-discovery-to-tag-with-fg/lozenge-discovery-to-tag-with-fg.js

@@ -0,0 +1,44 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = transformer;
+var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
+var _lozengeDiscoveryToTagWithFg = _interopRequireDefault(require("./codemods/lozenge-discovery-to-tag-with-fg"));
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { (0, _defineProperty2.default)(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+function transformer(_x, _x2) {
+  return _transformer.apply(this, arguments);
+}
+function _transformer() {
+  _transformer = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee(file, api) {
+    var transformers, src;
+    return _regenerator.default.wrap(function _callee$(_context) {
+      while (1) switch (_context.prev = _context.next) {
+        case 0:
+          transformers = [_lozengeDiscoveryToTagWithFg.default];
+          src = file.source;
+          transformers.forEach(function (transformer) {
+            if (typeof src === 'undefined') {
+              return;
+            }
+            var nextSrc = transformer(_objectSpread(_objectSpread({}, file), {}, {
+              source: src
+            }), api);
+            if (nextSrc) {
+              src = nextSrc;
+            }
+          });
+          return _context.abrupt("return", src);
+        case 4:
+        case "end":
+          return _context.stop();
+      }
+    }, _callee);
+  }));
+  return _transformer.apply(this, arguments);
+}

package/dist/cjs/presets/migrate-deprecated-icon/codemods/migrate-deprecated-icon.js

@@ -0,0 +1,142 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _deprecatedMap = require("@atlaskit/icon-lab/deprecated-map");
+var _metadata = _interopRequireDefault(require("@atlaskit/icon-lab/metadata"));
+var _deprecatedMap2 = require("@atlaskit/icon/deprecated-map");
+var _metadata2 = require("@atlaskit/icon/metadata");
+/* eslint-disable @repo/internal/fs/filename-pattern-match */
+
+var extractIconName = function extractIconName(importPath) {
+  var match = importPath.match(/\/([^\/]+)$/);
+  return match ? match[1] : '';
+};
+var getIconComponentName = function getIconComponentName(name) {
+  return name.split(/\W/).map(function (part) {
+    return "".concat(part[0].toUpperCase()).concat(part.slice(1));
+  }).join('').concat('Icon');
+};
+
+/**
+ * Creates a new default import declaration for the transformed component
+ */
+var createDefaultImportDeclaration = function createDefaultImportDeclaration(j, componentName, importPath) {
+  var defaultSpecifier = j.importDefaultSpecifier(j.identifier(componentName));
+  return j.importDeclaration([defaultSpecifier], j.stringLiteral(importPath));
+};
+var PRINT_SETTINGS = {
+  quote: 'single',
+  trailingComma: true
+};
+var transformer = function transformer(file, api) {
+  var j = api.jscodeshift;
+  var fileSource = j(file.source);
+  var deprecatedIcons = Object.keys(_deprecatedMap2.deprecatedCore);
+  var deprecatedIconLabIcons = Object.keys(_deprecatedMap.deprecatedCore);
+
+  // Find all deprecated icon imports
+  var deprecatedIconImports = fileSource.find(j.ImportDeclaration).filter(function (path) {
+    var _coreIconMetadata$ico, _coreIconLabMetadata$;
+    var source = path.node.source.value;
+
+    //Extract icon name from import path
+    var iconName = extractIconName(source);
+    var isDeprecated = deprecatedIcons.includes(source) || deprecatedIconLabIcons.includes(source);
+    var hasReplacement = !!((_coreIconMetadata$ico = _metadata2.coreIconMetadata[iconName]) !== null && _coreIconMetadata$ico !== void 0 && _coreIconMetadata$ico.replacement) || !!((_coreIconLabMetadata$ = _metadata.default[iconName]) !== null && _coreIconLabMetadata$ !== void 0 && _coreIconLabMetadata$.replacement);
+    return typeof source === 'string' && isDeprecated && hasReplacement;
+  });
+  if (!deprecatedIconImports.length) {
+    return fileSource.toSource();
+  }
+
+  // Track import name mappings (old name -> new name) and new imports to create
+  var importNameMappings = new Map();
+  var newImportsToCreate = [];
+
+  // Process each icon-object import
+  deprecatedIconImports.forEach(function (importPath) {
+    var _coreIconMetadata$ico2, _coreIconMetadata$ico3, _coreIconLabMetadata$2, _importDeclaration$sp;
+    var importDeclaration = importPath.node;
+    var source = importDeclaration.source.value;
+
+    //Extract icon name from import path
+    var iconName = extractIconName(source);
+    var replacementIconInfo = (_coreIconMetadata$ico2 = (_coreIconMetadata$ico3 = _metadata2.coreIconMetadata[iconName]) === null || _coreIconMetadata$ico3 === void 0 ? void 0 : _coreIconMetadata$ico3.replacement) !== null && _coreIconMetadata$ico2 !== void 0 ? _coreIconMetadata$ico2 : (_coreIconLabMetadata$2 = _metadata.default[iconName]) === null || _coreIconLabMetadata$2 === void 0 ? void 0 : _coreIconLabMetadata$2.replacement;
+    if (!replacementIconInfo) {
+      return; // No replacement found, skip
+    }
+    var replacementIconName = getIconComponentName(replacementIconInfo.name);
+    var replacementIconImport = "".concat(replacementIconInfo.location, "/core/").concat(replacementIconInfo.name);
+
+    // Get the current import name (could be default import or renamed)
+    var defaultSpecifier = (_importDeclaration$sp = importDeclaration.specifiers) === null || _importDeclaration$sp === void 0 ? void 0 : _importDeclaration$sp.find(function (spec) {
+      return spec.type === 'ImportDefaultSpecifier';
+    });
+    if (defaultSpecifier) {
+      var _defaultSpecifier$loc;
+      var currentImportName = (_defaultSpecifier$loc = defaultSpecifier.local) === null || _defaultSpecifier$loc === void 0 ? void 0 : _defaultSpecifier$loc.name;
+      if (currentImportName) {
+        // Map the old import name to the new component name
+        importNameMappings.set(currentImportName, replacementIconName);
+
+        // Track the new import to create
+        newImportsToCreate.push({
+          componentName: replacementIconName,
+          importPath: replacementIconImport,
+          oldImportPath: importPath
+        });
+      }
+    }
+  });
+
+  // Update JSX elements to use new component names
+  importNameMappings.forEach(function (newName, oldName) {
+    fileSource.find(j.JSXElement).filter(function (path) {
+      var openingElement = path.value.openingElement;
+      return openingElement.name.type === 'JSXIdentifier' && openingElement.name.name === oldName;
+    }).forEach(function (elementPath) {
+      var _element$closingEleme;
+      var element = elementPath.value;
+
+      // Update opening tag
+      if (element.openingElement.name.type === 'JSXIdentifier') {
+        element.openingElement.name.name = newName;
+      }
+
+      // Update closing tag if it exists
+      if (((_element$closingEleme = element.closingElement) === null || _element$closingEleme === void 0 ? void 0 : _element$closingEleme.name.type) === 'JSXIdentifier') {
+        element.closingElement.name.name = newName;
+      }
+    });
+  });
+
+  // Update other references (like in render calls, etc.)
+  importNameMappings.forEach(function (newName, oldName) {
+    fileSource.find(j.Identifier).filter(function (path) {
+      return path.node.name === oldName;
+    }).forEach(function (path) {
+      var _parent$value, _parent$value2;
+      // Only update if it's not part of an import declaration or JSX element
+      // (those are handled separately)
+      var parent = path.parent;
+      if ((parent === null || parent === void 0 || (_parent$value = parent.value) === null || _parent$value === void 0 ? void 0 : _parent$value.type) !== 'ImportDefaultSpecifier' && (parent === null || parent === void 0 || (_parent$value2 = parent.value) === null || _parent$value2 === void 0 ? void 0 : _parent$value2.type) !== 'JSXIdentifier') {
+        path.node.name = newName;
+      }
+    });
+  });
+
+  // Create new individual default imports
+  newImportsToCreate.forEach(function (_ref) {
+    var componentName = _ref.componentName,
+      importPath = _ref.importPath,
+      oldImportPath = _ref.oldImportPath;
+    var newImport = createDefaultImportDeclaration(j, componentName, importPath);
+    oldImportPath.replace(newImport);
+  });
+  return fileSource.toSource(PRINT_SETTINGS);
+};
+var _default = exports.default = transformer;

package/dist/cjs/presets/migrate-deprecated-icon/migrate-deprecated-icon.js

@@ -0,0 +1,44 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = transformer;
+var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
+var _migrateDeprecatedIcon = _interopRequireDefault(require("./codemods/migrate-deprecated-icon"));
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { (0, _defineProperty2.default)(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+function transformer(_x, _x2) {
+  return _transformer.apply(this, arguments);
+}
+function _transformer() {
+  _transformer = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee(file, api) {
+    var transformers, src;
+    return _regenerator.default.wrap(function _callee$(_context) {
+      while (1) switch (_context.prev = _context.next) {
+        case 0:
+          transformers = [_migrateDeprecatedIcon.default];
+          src = file.source;
+          transformers.forEach(function (transformer) {
+            if (typeof src === 'undefined') {
+              return;
+            }
+            var nextSrc = transformer(_objectSpread(_objectSpread({}, file), {}, {
+              source: src
+            }), api);
+            if (nextSrc) {
+              src = nextSrc;
+            }
+          });
+          return _context.abrupt("return", src);
+        case 4:
+        case "end":
+          return _context.stop();
+      }
+    }, _callee);
+  }));
+  return _transformer.apply(this, arguments);
+}

package/dist/cjs/presets/migrate-deprecated-icon/utils/mock.js

@@ -0,0 +1,81 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.mockMetadata = exports.mockDeprecatedIcons = void 0;
+var mockMetadata = exports.mockMetadata = {
+  coreIconMetadata: {
+    capture: {
+      keywords: ['capture', 'icon', 'focus', 'focus area', 'capture'],
+      componentName: 'CaptureIcon',
+      package: '@atlaskit/icon/core/capture',
+      oldName: ['jira/capture'],
+      replacement: {
+        name: 'focus-area',
+        location: '@atlaskit/icon'
+      },
+      categorization: 'single-purpose',
+      usage: 'Reserved for representing Focus Areas.',
+      team: 'Design System Team',
+      status: 'deprecated'
+    },
+    'chart-matrix': {
+      keywords: ['chart-matrix', 'chartmatrix', 'icon', 'dot chart', 'graph', 'matrix', ''],
+      componentName: 'ChartMatrixIcon',
+      package: '@atlaskit/icon/core/chart-matrix',
+      replacement: {
+        name: 'chart-bubble',
+        location: '@atlaskit/icon'
+      },
+      categorization: 'multi-purpose',
+      usage: 'Multi purpose - Known uses: Matrix view in in JPD, and other matrix charts.',
+      team: 'Design System Team',
+      status: 'deprecated'
+    },
+    close: {
+      keywords: ['close', 'icon', 'cross', 'x', 'close', 'remove'],
+      componentName: 'CloseIcon',
+      package: '@atlaskit/icon/core/close',
+      oldName: ['cross', 'editor/close'],
+      replacement: {
+        name: 'cross',
+        location: '@atlaskit/icon'
+      },
+      categorization: 'multi-purpose',
+      usage: 'Known uses: closing modals, panels, and transient views; removing tags',
+      team: 'Design System Team',
+      status: 'deprecated'
+    },
+    error: {
+      keywords: ['error', 'warning', 'alert', 'icon', 'filled', 'status', 'danger', 'exclamation', '!', 'error'],
+      componentName: 'ErrorIcon',
+      package: '@atlaskit/icon/core/error',
+      oldName: ['error'],
+      replacement: {
+        name: 'status-error',
+        location: '@atlaskit/icon'
+      },
+      categorization: 'single-purpose',
+      usage: 'Reserved for error statuses and messaging. Filled status icons provide higher visual contrast to draw attention to important information.',
+      team: 'Design System Team',
+      status: 'deprecated'
+    }
+  }
+};
+var mockDeprecatedIcons = exports.mockDeprecatedIcons = {
+  deprecatedCore: {
+    '@atlaskit/icon/core/capture': {
+      message: 'The icon "capture" is deprecated in favour of "focus-area" from "@atlaskit/icon/core"'
+    },
+    '@atlaskit/icon/core/chart-matrix': {
+      message: 'The icon "chart-matrix" is deprecated in favour of "chart-bubble" from "@atlaskit/icon/core"'
+    },
+    '@atlaskit/icon/core/close': {
+      message: 'The icon "close" is deprecated in favour of "cross" from "@atlaskit/icon/core"'
+    },
+    '@atlaskit/icon/core/error': {
+      message: 'The icon "error" is deprecated in favour of "status-error" from "@atlaskit/icon/core"'
+    }
+  }
+};

package/dist/es2019/presets/index.js

@@ -14,7 +14,9 @@ import './remove-dark-theme-vr-options/remove-dark-theme-vr-options';
 import './remove-token-fallbacks/remove-token-fallbacks';
 import './lozenge-appearance-semantic-migration/lozenge-appearance-semantic-migration';
 import './lozenge-to-tag-migration/lozenge-to-tag-migration';
+import './lozenge-discovery-to-tag-with-fg/lozenge-discovery-to-tag-with-fg';
 import './badge-appearance-semantic-migration/badge-appearance-semantic-migration';
 import './tag-to-newTag-migration/tag-to-newTag-migration';
-const presets = ['styled-to-emotion', 'theme-remove-deprecated-mixins', 'migrate-to-link', 'migrate-to-new-buttons', 'migrate-icon-object-to-object', 'upgrade-pragmatic-drag-and-drop-to-stable', 'remove-dark-theme-vr-options', 'remove-token-fallbacks', 'lozenge-appearance-semantic-migration', 'lozenge-to-tag-migration', 'badge-appearance-semantic-migration', 'tag-to-newTag-migration'].map(preset => path.join(__dirname, preset, `${preset}.@(ts|js|tsx)`));
+import './migrate-deprecated-icon/migrate-deprecated-icon';
+const presets = ['styled-to-emotion', 'theme-remove-deprecated-mixins', 'migrate-deprecated-icon', 'migrate-to-link', 'migrate-to-new-buttons', 'migrate-icon-object-to-object', 'upgrade-pragmatic-drag-and-drop-to-stable', 'remove-dark-theme-vr-options', 'remove-token-fallbacks', 'lozenge-appearance-semantic-migration', 'lozenge-to-tag-migration', 'lozenge-discovery-to-tag-with-fg', 'badge-appearance-semantic-migration', 'tag-to-newTag-migration'].map(preset => path.join(__dirname, preset, `${preset}.@(ts|js|tsx)`));
 export default presets;