@atlaskit/codemod-cli 0.33.2 → 0.34.1

package/CHANGELOG.md

@@ -1,5 +1,22 @@
 # @atlaskit/codemod-cli
 
+## 0.34.1
+
+### Patch Changes
+
+- [`f111803c4e253`](https://bitbucket.org/atlassian/atlassian-frontend-monorepo/commits/f111803c4e253) -
+  Updating typography fallbacks to refreshed typography values as the deprecated legacy typography
+  theme has been removed.
+- Updated dependencies
+
+## 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

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.1", _PACKAGE_VERSION_ = _process$env$_PACKAGE === void 0 ? '0.0.0-dev' : _process$env$_PACKAGE;
+          _process$env$_PACKAGE = "0.34.0", _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,6 +16,7 @@ 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");
@@ -24,7 +25,7 @@ require("./migrate-deprecated-icon/migrate-deprecated-icon");
  * in the final bundle.
  */
 
-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', '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/remove-token-fallbacks/utils/all-tokens.js

@@ -20,7 +20,7 @@ function buildCombinedMap() {
 }
 
 // Filter the typography tokens based on predefined groups and exclusions
-var typographyAdg3ThemeFiltered = _tokensRaw.typographyAdg3.filter(function (token) {
+var typographyThemeFiltered = _tokensRaw.typography.filter(function (token) {
   return typographyGroups.includes(token.attributes.group);
 }).filter(function (token) {
   return token.cleanName !== 'font.body.UNSAFE_small';
@@ -38,7 +38,7 @@ function getTokenMap() {
   var themeIndex = useLegacyTheme ? 1 : 0;
   if (!tokenMapCache[themeIndex]) {
     var selectedTheme = useLegacyTheme ? _tokensRaw.legacyLightTokens : _tokensRaw.light;
-    tokenMapCache[themeIndex] = buildCombinedMap(selectedTheme, _tokensRaw.spacing, _tokensRaw.shape, typographyAdg3ThemeFiltered);
+    tokenMapCache[themeIndex] = buildCombinedMap(selectedTheme, _tokensRaw.spacing, _tokensRaw.shape, typographyThemeFiltered);
   }
   return tokenMapCache[themeIndex];
 }

package/dist/es2019/presets/index.js

@@ -14,8 +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';
 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', 'badge-appearance-semantic-migration', 'tag-to-newTag-migration'].map(preset => path.join(__dirname, preset, `${preset}.@(ts|js|tsx)`));
+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;

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

@@ -0,0 +1,207 @@
+/* eslint-disable @repo/internal/fs/filename-pattern-match */
+
+const LOZENGE_ENTRY_POINT = '@atlaskit/lozenge';
+const TAG_ENTRY_POINT = '@atlaskit/tag';
+const FG_ENTRY_POINT = '@atlassian/jira-feature-gating';
+const FEATURE_GATE_NAME = 'platform-dst-lozenge-tag-badge-visual-uplifts';
+const 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)
+ */
+export default function transformer(file, api) {
+  const j = api.jscodeshift;
+  let 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
+  const hasLozengeImport = source.find(j.ImportDeclaration).some(importPath => {
+    return importPath.value.source.value === LOZENGE_ENTRY_POINT;
+  });
+  if (!hasLozengeImport) {
+    return file.source;
+  }
+
+  // Get all Lozenge component names (handles renamed imports)
+  const lozengeNames = new Set();
+  source.find(j.ImportDeclaration).forEach(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 ? void 0 : _importPath$value$spe.forEach(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
+  const lozengeElements = [];
+  source.find(j.JSXElement).forEach(path => {
+    var _openingElement$name;
+    const 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;
+      const element = {
+        path,
+        shouldMigrate: false
+      };
+
+      // Check for appearance and isBold props
+      (_openingElement$attri = openingElement.attributes) === null || _openingElement$attri === void 0 ? void 0 : _openingElement$attri.forEach(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') {
+              const 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') {
+              const 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
+  const hasTagImport = source.find(j.ImportDeclaration).some(importPath => importPath.value.source.value === TAG_ENTRY_POINT);
+
+  // Check if fg is already imported from @atlassian/jira-feature-gating
+  const hasFgImport = source.find(j.ImportDeclaration).some(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(spec => {
+        return spec.type === 'ImportSpecifier' && spec.imported.name === 'fg';
+      });
+    }
+    return false;
+  });
+
+  // Add imports after Lozenge import to avoid blank lines
+  const lozengeImport = source.find(j.ImportDeclaration).filter(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(element => {
+    var _openingElement$attri2;
+    const {
+      path
+    } = element;
+    const openingElement = path.value.openingElement;
+
+    // Extract text content or JSX expression from children
+    const children = path.value.children;
+    let 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') {
+        const 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
+        const textContent = children.filter(child => child.type === 'JSXText').map(child => child.value.trim()).filter(text => text.length > 0).join(' ');
+        if (textContent) {
+          textAttribute = j.jsxAttribute(j.jsxIdentifier('text'), j.stringLiteral(textContent));
+        }
+      }
+    }
+
+    // Create the Tag element
+    const 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 ? void 0 : _openingElement$attri2.forEach(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);
+        }
+      }
+    });
+    const tagElement = j.jsxElement(j.jsxOpeningElement(j.jsxIdentifier('Tag'), tagAttributes, true), null, []);
+
+    // Keep the original Lozenge element (just the element, without wrapping)
+    const 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)
+    const 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)
+    const parent = path.parent;
+    const 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/es2019/presets/lozenge-discovery-to-tag-with-fg/lozenge-discovery-to-tag-with-fg.js

@@ -0,0 +1,18 @@
+import lozengeDiscoveryToTagWithFgTransformer from './codemods/lozenge-discovery-to-tag-with-fg';
+export default async function transformer(file, api) {
+  const transformers = [lozengeDiscoveryToTagWithFgTransformer];
+  let src = file.source;
+  transformers.forEach(transformer => {
+    if (typeof src === 'undefined') {
+      return;
+    }
+    const nextSrc = transformer({
+      ...file,
+      source: src
+    }, api);
+    if (nextSrc) {
+      src = nextSrc;
+    }
+  });
+  return src;
+}

package/dist/es2019/presets/remove-token-fallbacks/utils/all-tokens.js

@@ -1,4 +1,4 @@
-import { legacyLightTokens as legacyLightTheme, light as lightTheme, shape as shapeTheme, spacing as spacingTheme, typographyAdg3 as typographyAdg3Theme } from '@atlaskit/tokens/tokens-raw';
+import { legacyLightTokens as legacyLightTheme, light as lightTheme, shape as shapeTheme, spacing as spacingTheme, typography as typographyTheme } from '@atlaskit/tokens/tokens-raw';
 const typographyGroups = ['typography', 'fontWeight', 'fontFamily'];
 function buildCombinedMap(...arrays) {
   const combinedMap = {};
@@ -11,7 +11,7 @@ function buildCombinedMap(...arrays) {
 }
 
 // Filter the typography tokens based on predefined groups and exclusions
-const typographyAdg3ThemeFiltered = typographyAdg3Theme.filter(token => typographyGroups.includes(token.attributes.group)).filter(token => token.cleanName !== 'font.body.UNSAFE_small');
+const typographyThemeFiltered = typographyTheme.filter(token => typographyGroups.includes(token.attributes.group)).filter(token => token.cleanName !== 'font.body.UNSAFE_small');
 
 // Cache array: [0] for light theme, [1] for legacy light theme
 const tokenMapCache = [null, null];
@@ -24,7 +24,7 @@ export function getTokenMap(useLegacyTheme = false) {
   const themeIndex = useLegacyTheme ? 1 : 0;
   if (!tokenMapCache[themeIndex]) {
     const selectedTheme = useLegacyTheme ? legacyLightTheme : lightTheme;
-    tokenMapCache[themeIndex] = buildCombinedMap(selectedTheme, spacingTheme, shapeTheme, typographyAdg3ThemeFiltered);
+    tokenMapCache[themeIndex] = buildCombinedMap(selectedTheme, spacingTheme, shapeTheme, typographyThemeFiltered);
   }
   return tokenMapCache[themeIndex];
 }

package/dist/esm/main.js

@@ -355,7 +355,7 @@ function _main() {
         case 4:
           _yield$parseArgs = _context6.sent;
           packages = _yield$parseArgs.packages;
-          _process$env$_PACKAGE = "0.33.1", _PACKAGE_VERSION_ = _process$env$_PACKAGE === void 0 ? '0.0.0-dev' : _process$env$_PACKAGE;
+          _process$env$_PACKAGE = "0.34.0", _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) {

package/dist/esm/presets/index.js

@@ -14,10 +14,11 @@ 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';
 import './migrate-deprecated-icon/migrate-deprecated-icon';
-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', '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.join(__dirname, preset, "".concat(preset, ".@(ts|js|tsx)"));
 });
 export default presets;

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

@@ -0,0 +1,213 @@
+/* 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)
+ */
+export default 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/esm/presets/lozenge-discovery-to-tag-with-fg/lozenge-discovery-to-tag-with-fg.js

@@ -0,0 +1,37 @@
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
+import _asyncToGenerator from "@babel/runtime/helpers/asyncToGenerator";
+import _regeneratorRuntime from "@babel/runtime/regenerator";
+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) { _defineProperty(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; }
+import lozengeDiscoveryToTagWithFgTransformer from './codemods/lozenge-discovery-to-tag-with-fg';
+export default function transformer(_x, _x2) {
+  return _transformer.apply(this, arguments);
+}
+function _transformer() {
+  _transformer = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee(file, api) {
+    var transformers, src;
+    return _regeneratorRuntime.wrap(function _callee$(_context) {
+      while (1) switch (_context.prev = _context.next) {
+        case 0:
+          transformers = [lozengeDiscoveryToTagWithFgTransformer];
+          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/esm/presets/remove-token-fallbacks/utils/all-tokens.js

@@ -1,4 +1,4 @@
-import { legacyLightTokens as legacyLightTheme, light as lightTheme, shape as shapeTheme, spacing as spacingTheme, typographyAdg3 as typographyAdg3Theme } from '@atlaskit/tokens/tokens-raw';
+import { legacyLightTokens as legacyLightTheme, light as lightTheme, shape as shapeTheme, spacing as spacingTheme, typography as typographyTheme } from '@atlaskit/tokens/tokens-raw';
 var typographyGroups = ['typography', 'fontWeight', 'fontFamily'];
 function buildCombinedMap() {
   var combinedMap = {};
@@ -14,7 +14,7 @@ function buildCombinedMap() {
 }
 
 // Filter the typography tokens based on predefined groups and exclusions
-var typographyAdg3ThemeFiltered = typographyAdg3Theme.filter(function (token) {
+var typographyThemeFiltered = typographyTheme.filter(function (token) {
   return typographyGroups.includes(token.attributes.group);
 }).filter(function (token) {
   return token.cleanName !== 'font.body.UNSAFE_small';
@@ -32,7 +32,7 @@ export function getTokenMap() {
   var themeIndex = useLegacyTheme ? 1 : 0;
   if (!tokenMapCache[themeIndex]) {
     var selectedTheme = useLegacyTheme ? legacyLightTheme : lightTheme;
-    tokenMapCache[themeIndex] = buildCombinedMap(selectedTheme, spacingTheme, shapeTheme, typographyAdg3ThemeFiltered);
+    tokenMapCache[themeIndex] = buildCombinedMap(selectedTheme, spacingTheme, shapeTheme, typographyThemeFiltered);
   }
   return tokenMapCache[themeIndex];
 }

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

@@ -12,6 +12,7 @@ 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';
 import './migrate-deprecated-icon/migrate-deprecated-icon';

package/dist/types/presets/lozenge-discovery-to-tag-with-fg/codemods/lozenge-discovery-to-tag-with-fg.d.ts

@@ -0,0 +1,12 @@
+import { type API, type FileInfo } from 'jscodeshift';
+/**
+ * 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)
+ */
+export default function transformer(file: FileInfo, api: API): any;

package/dist/types/presets/lozenge-discovery-to-tag-with-fg/lozenge-discovery-to-tag-with-fg.d.ts

@@ -0,0 +1,2 @@
+import type { API, FileInfo } from 'jscodeshift';
+export default function transformer(file: FileInfo, api: API): Promise<string>;

package/dist/types-ts4.5/presets/index.d.ts

@@ -12,6 +12,7 @@ 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';
 import './migrate-deprecated-icon/migrate-deprecated-icon';

package/dist/types-ts4.5/presets/lozenge-discovery-to-tag-with-fg/codemods/lozenge-discovery-to-tag-with-fg.d.ts

@@ -0,0 +1,12 @@
+import { type API, type FileInfo } from 'jscodeshift';
+/**
+ * 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)
+ */
+export default function transformer(file: FileInfo, api: API): any;

package/dist/types-ts4.5/presets/lozenge-discovery-to-tag-with-fg/lozenge-discovery-to-tag-with-fg.d.ts

@@ -0,0 +1,2 @@
+import type { API, FileInfo } from 'jscodeshift';
+export default function transformer(file: FileInfo, api: API): Promise<string>;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@atlaskit/codemod-cli",
-	"version": "0.33.2",
+	"version": "0.34.1",
 	"description": "A cli for distributing codemods for atlassian-frontend components and services",
 	"publishConfig": {
 		"registry": "https://registry.npmjs.org/"
@@ -29,9 +29,9 @@
 	"bin": "./bin/codemod-cli.js",
 	"dependencies": {
 		"@atlaskit/codemod-utils": "^4.2.0",
-		"@atlaskit/icon": "^29.3.0",
-		"@atlaskit/icon-lab": "^5.13.0",
-		"@atlaskit/tokens": "^9.1.0",
+		"@atlaskit/icon": "^29.4.0",
+		"@atlaskit/icon-lab": "^5.14.0",
+		"@atlaskit/tokens": "^10.0.0",
 		"@babel/runtime": "^7.0.0",
 		"@codeshift/utils": "^0.2.4",
 		"@hypermod/utils": "^0.4.2",