@atlaskit/codemod-cli 0.30.0 → 0.31.1

package/CHANGELOG.md

@@ -1,5 +1,19 @@
 # @atlaskit/codemod-cli
 
+## 0.31.1
+
+### Patch Changes
+
+- Updated dependencies
+
+## 0.31.0
+
+### Minor Changes
+
+- [`2b2b250287a95`](https://bitbucket.org/atlassian/atlassian-frontend-monorepo/commits/2b2b250287a95) -
+  Add a new codemod `lozenge-to-tag-migration` to automatically migrate `isBold={false}` Lozenge
+  usages to Tag component as part of the Labelling System Phase 1 migration.
+
 ## 0.30.0
 
 ### Minor 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.29.2", _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

@@ -15,12 +15,13 @@ require("./upgrade-pragmatic-drag-and-drop-to-stable/upgrade-pragmatic-drag-and-
 require("./remove-dark-theme-vr-options/remove-dark-theme-vr-options");
 require("./remove-token-fallbacks/remove-token-fallbacks");
 require("./lozenge-appearance-to-color/lozenge-appearance-to-color");
+require("./lozenge-to-tag-migration/lozenge-to-tag-migration");
 /**
  * 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-to-color'].map(function (preset) {
+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-to-color', 'lozenge-to-tag-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-to-tag-migration/codemods/lozenge-to-tag-migration.js

@@ -0,0 +1,253 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _codemodUtils = require("@atlaskit/codemod-utils");
+var transformer = function transformer(file, api) {
+  var j = api.jscodeshift;
+  var source = j(file.source);
+
+  // Check if file has Lozenge imports
+  var lozengeImports = source.find(j.ImportDeclaration).filter(function (path) {
+    return path.node.source.value === '@atlaskit/lozenge';
+  });
+  if (lozengeImports.length === 0) {
+    return file.source;
+  }
+
+  // Get the import name for Lozenge (could be renamed)
+  var lozengeImportName = 'Lozenge';
+  lozengeImports.forEach(function (importPath) {
+    var _importPath$node$spec;
+    (_importPath$node$spec = importPath.node.specifiers) === null || _importPath$node$spec === void 0 || _importPath$node$spec.forEach(function (specifier) {
+      if (j.ImportDefaultSpecifier.check(specifier)) {
+        var _specifier$local;
+        lozengeImportName = ((_specifier$local = specifier.local) === null || _specifier$local === void 0 ? void 0 : _specifier$local.name) || 'Lozenge';
+      } else if (j.ImportSpecifier.check(specifier)) {
+        // Handle { default as Badge } syntax
+        if (j.Identifier.check(specifier.imported) && specifier.imported.name === 'default') {
+          var _specifier$local2;
+          lozengeImportName = ((_specifier$local2 = specifier.local) === null || _specifier$local2 === void 0 ? void 0 : _specifier$local2.name) || 'Lozenge';
+        }
+      }
+    });
+  });
+
+  // Appearance to color mapping
+  var appearanceToColorMap = {
+    success: 'lime',
+    default: 'standard',
+    removed: 'red',
+    inprogress: 'blue',
+    new: 'purple',
+    moved: 'orange'
+  };
+  var hasTransformed = false;
+
+  // Find and transform Lozenge elements
+  source.find(j.JSXElement).forEach(function (elementPath) {
+    var _element$openingEleme, _element$openingEleme2;
+    var element = elementPath.node;
+    if (!j.JSXIdentifier.check(element.openingElement.name)) {
+      return;
+    }
+    if (element.openingElement.name.name !== lozengeImportName) {
+      return;
+    }
+
+    // Check isBold attribute
+    var isBoldAttr = (_element$openingEleme = element.openingElement.attributes) === null || _element$openingEleme === void 0 ? void 0 : _element$openingEleme.find(function (attr) {
+      return j.JSXAttribute.check(attr) && j.JSXIdentifier.check(attr.name) && attr.name.name === 'isBold';
+    });
+
+    // Don't transform if isBold is true or boolean prop without value
+    if (isBoldAttr) {
+      if (j.JSXExpressionContainer.check(isBoldAttr.value)) {
+        var expression = isBoldAttr.value.expression;
+
+        // If it's a boolean literal true, don't transform
+        if (j.BooleanLiteral.check(expression) && expression.value === true) {
+          return;
+        }
+
+        // If it's a boolean literal false, we can transform
+        if (j.BooleanLiteral.check(expression) && expression.value === false) {
+          // Continue with transformation
+        } else {
+          // If it's not a boolean literal (dynamic value), add warning and don't transform
+          (0, _codemodUtils.addCommentBefore)(j, j(elementPath), "FIXME: This Lozenge component uses a dynamic `isBold` prop. Please manually review if this should be migrated to Tag component.\nIf isBold is typically false, consider migrating to <Tag /> from '@atlaskit/tag'.");
+          return;
+        }
+      } else if (!isBoldAttr.value) {
+        // isBold prop without value (boolean shorthand) means true, don't transform
+        return;
+      }
+    }
+
+    // Create new Tag element
+    var newAttributes = [];
+    var otherAttributes = [];
+    var colorAttribute = null;
+    var textContent = '';
+    var hasComplexChildren = false;
+    var hasStyleProp = false;
+    var hasMaxWidthProp = false;
+    var hasUnknownAppearance = false;
+    var dynamicAppearance = false;
+    var unknownAppearanceValue = '';
+
+    // Process children to extract text
+    if (element.children && element.children.length > 0) {
+      if (element.children.length === 1) {
+        var child = element.children[0];
+        if (j.JSXText.check(child)) {
+          var text = child.value.trim();
+          if (text) {
+            textContent = text;
+          }
+        } else if (j.JSXExpressionContainer.check(child) && j.StringLiteral.check(child.expression)) {
+          textContent = child.expression.value;
+        } else {
+          hasComplexChildren = true;
+        }
+      } else {
+        // Multiple children or complex structure
+        hasComplexChildren = true;
+      }
+    }
+
+    // Process attributes
+    (_element$openingEleme2 = element.openingElement.attributes) === null || _element$openingEleme2 === void 0 || _element$openingEleme2.forEach(function (attr) {
+      if (!j.JSXAttribute.check(attr) || !j.JSXIdentifier.check(attr.name)) {
+        return;
+      }
+      var attrName = attr.name.name;
+      switch (attrName) {
+        case 'appearance':
+          var colorValue = 'standard';
+          if (j.StringLiteral.check(attr.value)) {
+            var appearanceValue = attr.value.value;
+            colorValue = appearanceToColorMap[appearanceValue] || appearanceValue;
+            if (!appearanceToColorMap[appearanceValue]) {
+              hasUnknownAppearance = true;
+              unknownAppearanceValue = appearanceValue;
+            }
+          } else if (j.JSXExpressionContainer.check(attr.value)) {
+            // Dynamic appearance
+            dynamicAppearance = true;
+            colorValue = attr.value;
+          }
+          colorAttribute = j.jsxAttribute(j.jsxIdentifier('color'), typeof colorValue === 'string' ? j.stringLiteral(colorValue) : colorValue);
+          break;
+        case 'isBold':
+          // Skip isBold, already handled above
+          break;
+        case 'maxWidth':
+          hasMaxWidthProp = true;
+          break;
+        case 'style':
+          hasStyleProp = true;
+          otherAttributes.push(attr);
+          break;
+        default:
+          // Keep other attributes (testId, etc.)
+          otherAttributes.push(attr);
+          break;
+      }
+    });
+
+    // Assemble attributes in correct order: text, other props, color
+    if (textContent && !hasComplexChildren) {
+      newAttributes.push(j.jsxAttribute(j.jsxIdentifier('text'), j.stringLiteral(textContent)));
+    }
+
+    // Add other attributes
+    newAttributes.push.apply(newAttributes, otherAttributes);
+
+    // Add color attribute last (default to 'standard' if no appearance was found)
+    if (colorAttribute) {
+      newAttributes.push(colorAttribute);
+    } else {
+      // Default color when no appearance is specified
+      newAttributes.push(j.jsxAttribute(j.jsxIdentifier('color'), j.stringLiteral('standard')));
+    }
+
+    // Create new Tag element
+    var newElement = j.jsxElement(j.jsxOpeningElement(j.jsxIdentifier('Tag'), newAttributes, true), null, []);
+
+    // Add warning comments as needed
+    var warnings = [];
+    if (hasComplexChildren) {
+      warnings.push("FIXME: This Tag component has complex children that couldn't be automatically migrated to the text prop.\nTag component only supports simple text via the text prop. Please manually convert the children content.");
+    }
+    if (hasMaxWidthProp) {
+      warnings.push('FIXME: maxWidth prop was removed during migration from Lozenge to Tag.\nTag component does not support maxWidth. Please review if width constraints are needed.');
+    }
+    if (hasStyleProp) {
+      warnings.push('FIXME: This Tag component has a style prop that was kept during migration.\nTag component has limited style support. Please review if custom styles are compatible.');
+    }
+    if (hasUnknownAppearance) {
+      warnings.push("FIXME: This Tag component uses an unknown appearance value \"".concat(unknownAppearanceValue, "\".\nPlease update to a valid Tag color: standard, green, lime, blue, red, purple, magenta, grey, teal, orange, yellow."));
+    }
+    if (dynamicAppearance) {
+      warnings.push('FIXME: This Tag component uses a dynamic `appearance` prop that has been renamed to `color`.\nPlease verify that the values being passed are valid color values (semantic: default, inprogress, moved, new, removed, success).');
+    }
+
+    // Replace the element first
+    elementPath.replace(newElement);
+
+    // Add warning comments using addCommentBefore if needed
+    if (warnings.length > 0) {
+      var commentText = warnings.join('\n');
+      (0, _codemodUtils.addCommentBefore)(j, j(elementPath), commentText);
+    }
+    hasTransformed = true;
+  });
+
+  // Add Tag import if we transformed any elements
+  if (hasTransformed) {
+    // Check if Tag import already exists
+    var tagImports = source.find(j.ImportDeclaration).filter(function (path) {
+      return path.node.source.value === '@atlaskit/tag';
+    });
+    if (tagImports.length === 0) {
+      // Add Tag import after Lozenge import
+      var lozengeImportPath = lozengeImports.at(0);
+      var tagImport = j.importDeclaration([j.importDefaultSpecifier(j.identifier('Tag'))], j.stringLiteral('@atlaskit/tag'));
+      lozengeImportPath.insertAfter(tagImport);
+    }
+
+    // Check if there are any remaining Lozenge usages
+    var remainingLozengeUsages = source.find(j.JSXElement).filter(function (elementPath) {
+      var element = elementPath.node;
+      if (!j.JSXIdentifier.check(element.openingElement.name)) {
+        return false;
+      }
+      return element.openingElement.name.name === lozengeImportName;
+    });
+
+    // Also check for other usages like function calls, type references, etc.
+    var remainingLozengeReferences = source.find(j.Identifier).filter(function (identifierPath) {
+      // Skip JSX element names as they're already checked above
+      if (j.JSXElement.check(identifierPath.parent.node) || j.JSXOpeningElement.check(identifierPath.parent.node) || j.JSXClosingElement.check(identifierPath.parent.node)) {
+        return false;
+      }
+
+      // Skip import declaration identifiers
+      if (j.ImportDeclaration.check(identifierPath.parent.node) || j.ImportDefaultSpecifier.check(identifierPath.parent.node) || j.ImportSpecifier.check(identifierPath.parent.node)) {
+        return false;
+      }
+      return identifierPath.node.name === lozengeImportName;
+    });
+
+    // If no remaining usages, remove the Lozenge import
+    if (remainingLozengeUsages.length === 0 && remainingLozengeReferences.length === 0) {
+      lozengeImports.remove();
+    }
+    return source.toSource();
+  }
+  return source.toSource();
+};
+var _default = exports.default = transformer;

package/dist/cjs/presets/lozenge-to-tag-migration/lozenge-to-tag-migration.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 _lozengeToTagMigration = _interopRequireDefault(require("./codemods/lozenge-to-tag-migration"));
+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 = [_lozengeToTagMigration.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/reporter.js

@@ -15,7 +15,7 @@ var _path = _interopRequireDefault(require("path"));
 var _uuid = require("uuid");
 function _createForOfIteratorHelper(r, e) { var t = "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (!t) { if (Array.isArray(r) || (t = _unsupportedIterableToArray(r)) || e && r && "number" == typeof r.length) { t && (r = t); var _n = 0, F = function F() {}; return { s: F, n: function n() { return _n >= r.length ? { done: !0 } : { done: !1, value: r[_n++] }; }, e: function e(r) { throw r; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var o, a = !0, u = !1; return { s: function s() { t = t.call(r); }, n: function n() { var r = t.next(); return a = r.done, r; }, e: function e(r) { u = !0, o = r; }, f: function f() { try { a || null == t.return || t.return(); } finally { if (u) throw o; } } }; }
 function _unsupportedIterableToArray(r, a) { if (r) { if ("string" == typeof r) return _arrayLikeToArray(r, a); var t = {}.toString.call(r).slice(8, -1); return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0; } }
-function _arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length); for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e]; return n; } /* eslint-disable no-console */
+function _arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length); for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e]; return n; } /* eslint-disable no-console */ // eslint-disable-next-line @atlaskit/platform/prefer-crypto-random-uuid -- Use crypto.randomUUID instead
 function writeToCsv(_x, _x2) {
   return _writeToCsv.apply(this, arguments);
 }
@@ -296,7 +296,8 @@ function _writeReports() {
     return _regenerator.default.wrap(function _callee6$(_context6) {
       while (1) switch (_context6.prev = _context6.next) {
         case 0:
-          replacementsFilePath = _path.default.join(reportFolder, "".concat((0, _uuid.v4)(), "_success.csv"));
+          // eslint-disable-next-line @atlaskit/platform/prefer-crypto-random-uuid -- Use crypto.randomUUID instead
+          replacementsFilePath = _path.default.join(reportFolder, "".concat((0, _uuid.v4)(), "_success.csv")); // eslint-disable-next-line @atlaskit/platform/prefer-crypto-random-uuid -- Use crypto.randomUUID instead
           nonReplacementsFilePath = _path.default.join(reportFolder, "".concat((0, _uuid.v4)(), "_failed.csv"));
           _context6.next = 4;
           return _promises.default.mkdir(reportFolder, {

package/dist/es2019/presets/index.js

@@ -13,5 +13,6 @@ import './upgrade-pragmatic-drag-and-drop-to-stable/upgrade-pragmatic-drag-and-d
 import './remove-dark-theme-vr-options/remove-dark-theme-vr-options';
 import './remove-token-fallbacks/remove-token-fallbacks';
 import './lozenge-appearance-to-color/lozenge-appearance-to-color';
-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-to-color'].map(preset => path.join(__dirname, preset, `${preset}.@(ts|js|tsx)`));
+import './lozenge-to-tag-migration/lozenge-to-tag-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-to-color', 'lozenge-to-tag-migration'].map(preset => path.join(__dirname, preset, `${preset}.@(ts|js|tsx)`));
 export default presets;

package/dist/es2019/presets/lozenge-to-tag-migration/codemods/lozenge-to-tag-migration.js

@@ -0,0 +1,242 @@
+import { addCommentBefore } from '@atlaskit/codemod-utils';
+const transformer = (file, api) => {
+  const j = api.jscodeshift;
+  const source = j(file.source);
+
+  // Check if file has Lozenge imports
+  const lozengeImports = source.find(j.ImportDeclaration).filter(path => path.node.source.value === '@atlaskit/lozenge');
+  if (lozengeImports.length === 0) {
+    return file.source;
+  }
+
+  // Get the import name for Lozenge (could be renamed)
+  let lozengeImportName = 'Lozenge';
+  lozengeImports.forEach(importPath => {
+    var _importPath$node$spec;
+    (_importPath$node$spec = importPath.node.specifiers) === null || _importPath$node$spec === void 0 ? void 0 : _importPath$node$spec.forEach(specifier => {
+      if (j.ImportDefaultSpecifier.check(specifier)) {
+        var _specifier$local;
+        lozengeImportName = ((_specifier$local = specifier.local) === null || _specifier$local === void 0 ? void 0 : _specifier$local.name) || 'Lozenge';
+      } else if (j.ImportSpecifier.check(specifier)) {
+        // Handle { default as Badge } syntax
+        if (j.Identifier.check(specifier.imported) && specifier.imported.name === 'default') {
+          var _specifier$local2;
+          lozengeImportName = ((_specifier$local2 = specifier.local) === null || _specifier$local2 === void 0 ? void 0 : _specifier$local2.name) || 'Lozenge';
+        }
+      }
+    });
+  });
+
+  // Appearance to color mapping
+  const appearanceToColorMap = {
+    success: 'lime',
+    default: 'standard',
+    removed: 'red',
+    inprogress: 'blue',
+    new: 'purple',
+    moved: 'orange'
+  };
+  let hasTransformed = false;
+
+  // Find and transform Lozenge elements
+  source.find(j.JSXElement).forEach(elementPath => {
+    var _element$openingEleme, _element$openingEleme2;
+    const element = elementPath.node;
+    if (!j.JSXIdentifier.check(element.openingElement.name)) {
+      return;
+    }
+    if (element.openingElement.name.name !== lozengeImportName) {
+      return;
+    }
+
+    // Check isBold attribute
+    const isBoldAttr = (_element$openingEleme = element.openingElement.attributes) === null || _element$openingEleme === void 0 ? void 0 : _element$openingEleme.find(attr => j.JSXAttribute.check(attr) && j.JSXIdentifier.check(attr.name) && attr.name.name === 'isBold');
+
+    // Don't transform if isBold is true or boolean prop without value
+    if (isBoldAttr) {
+      if (j.JSXExpressionContainer.check(isBoldAttr.value)) {
+        const expression = isBoldAttr.value.expression;
+
+        // If it's a boolean literal true, don't transform
+        if (j.BooleanLiteral.check(expression) && expression.value === true) {
+          return;
+        }
+
+        // If it's a boolean literal false, we can transform
+        if (j.BooleanLiteral.check(expression) && expression.value === false) {
+          // Continue with transformation
+        } else {
+          // If it's not a boolean literal (dynamic value), add warning and don't transform
+          addCommentBefore(j, j(elementPath), `FIXME: This Lozenge component uses a dynamic \`isBold\` prop. Please manually review if this should be migrated to Tag component.
+If isBold is typically false, consider migrating to <Tag /> from '@atlaskit/tag'.`);
+          return;
+        }
+      } else if (!isBoldAttr.value) {
+        // isBold prop without value (boolean shorthand) means true, don't transform
+        return;
+      }
+    }
+
+    // Create new Tag element
+    const newAttributes = [];
+    const otherAttributes = [];
+    let colorAttribute = null;
+    let textContent = '';
+    let hasComplexChildren = false;
+    let hasStyleProp = false;
+    let hasMaxWidthProp = false;
+    let hasUnknownAppearance = false;
+    let dynamicAppearance = false;
+    let unknownAppearanceValue = '';
+
+    // Process children to extract text
+    if (element.children && element.children.length > 0) {
+      if (element.children.length === 1) {
+        const child = element.children[0];
+        if (j.JSXText.check(child)) {
+          const text = child.value.trim();
+          if (text) {
+            textContent = text;
+          }
+        } else if (j.JSXExpressionContainer.check(child) && j.StringLiteral.check(child.expression)) {
+          textContent = child.expression.value;
+        } else {
+          hasComplexChildren = true;
+        }
+      } else {
+        // Multiple children or complex structure
+        hasComplexChildren = true;
+      }
+    }
+
+    // Process attributes
+    (_element$openingEleme2 = element.openingElement.attributes) === null || _element$openingEleme2 === void 0 ? void 0 : _element$openingEleme2.forEach(attr => {
+      if (!j.JSXAttribute.check(attr) || !j.JSXIdentifier.check(attr.name)) {
+        return;
+      }
+      const attrName = attr.name.name;
+      switch (attrName) {
+        case 'appearance':
+          let colorValue = 'standard';
+          if (j.StringLiteral.check(attr.value)) {
+            const appearanceValue = attr.value.value;
+            colorValue = appearanceToColorMap[appearanceValue] || appearanceValue;
+            if (!appearanceToColorMap[appearanceValue]) {
+              hasUnknownAppearance = true;
+              unknownAppearanceValue = appearanceValue;
+            }
+          } else if (j.JSXExpressionContainer.check(attr.value)) {
+            // Dynamic appearance
+            dynamicAppearance = true;
+            colorValue = attr.value;
+          }
+          colorAttribute = j.jsxAttribute(j.jsxIdentifier('color'), typeof colorValue === 'string' ? j.stringLiteral(colorValue) : colorValue);
+          break;
+        case 'isBold':
+          // Skip isBold, already handled above
+          break;
+        case 'maxWidth':
+          hasMaxWidthProp = true;
+          break;
+        case 'style':
+          hasStyleProp = true;
+          otherAttributes.push(attr);
+          break;
+        default:
+          // Keep other attributes (testId, etc.)
+          otherAttributes.push(attr);
+          break;
+      }
+    });
+
+    // Assemble attributes in correct order: text, other props, color
+    if (textContent && !hasComplexChildren) {
+      newAttributes.push(j.jsxAttribute(j.jsxIdentifier('text'), j.stringLiteral(textContent)));
+    }
+
+    // Add other attributes
+    newAttributes.push(...otherAttributes);
+
+    // Add color attribute last (default to 'standard' if no appearance was found)
+    if (colorAttribute) {
+      newAttributes.push(colorAttribute);
+    } else {
+      // Default color when no appearance is specified
+      newAttributes.push(j.jsxAttribute(j.jsxIdentifier('color'), j.stringLiteral('standard')));
+    }
+
+    // Create new Tag element
+    const newElement = j.jsxElement(j.jsxOpeningElement(j.jsxIdentifier('Tag'), newAttributes, true), null, []);
+
+    // Add warning comments as needed
+    const warnings = [];
+    if (hasComplexChildren) {
+      warnings.push("FIXME: This Tag component has complex children that couldn't be automatically migrated to the text prop.\nTag component only supports simple text via the text prop. Please manually convert the children content.");
+    }
+    if (hasMaxWidthProp) {
+      warnings.push('FIXME: maxWidth prop was removed during migration from Lozenge to Tag.\nTag component does not support maxWidth. Please review if width constraints are needed.');
+    }
+    if (hasStyleProp) {
+      warnings.push('FIXME: This Tag component has a style prop that was kept during migration.\nTag component has limited style support. Please review if custom styles are compatible.');
+    }
+    if (hasUnknownAppearance) {
+      warnings.push(`FIXME: This Tag component uses an unknown appearance value "${unknownAppearanceValue}".\nPlease update to a valid Tag color: standard, green, lime, blue, red, purple, magenta, grey, teal, orange, yellow.`);
+    }
+    if (dynamicAppearance) {
+      warnings.push('FIXME: This Tag component uses a dynamic `appearance` prop that has been renamed to `color`.\nPlease verify that the values being passed are valid color values (semantic: default, inprogress, moved, new, removed, success).');
+    }
+
+    // Replace the element first
+    elementPath.replace(newElement);
+
+    // Add warning comments using addCommentBefore if needed
+    if (warnings.length > 0) {
+      const commentText = warnings.join('\n');
+      addCommentBefore(j, j(elementPath), commentText);
+    }
+    hasTransformed = true;
+  });
+
+  // Add Tag import if we transformed any elements
+  if (hasTransformed) {
+    // Check if Tag import already exists
+    const tagImports = source.find(j.ImportDeclaration).filter(path => path.node.source.value === '@atlaskit/tag');
+    if (tagImports.length === 0) {
+      // Add Tag import after Lozenge import
+      const lozengeImportPath = lozengeImports.at(0);
+      const tagImport = j.importDeclaration([j.importDefaultSpecifier(j.identifier('Tag'))], j.stringLiteral('@atlaskit/tag'));
+      lozengeImportPath.insertAfter(tagImport);
+    }
+
+    // Check if there are any remaining Lozenge usages
+    const remainingLozengeUsages = source.find(j.JSXElement).filter(elementPath => {
+      const element = elementPath.node;
+      if (!j.JSXIdentifier.check(element.openingElement.name)) {
+        return false;
+      }
+      return element.openingElement.name.name === lozengeImportName;
+    });
+
+    // Also check for other usages like function calls, type references, etc.
+    const remainingLozengeReferences = source.find(j.Identifier).filter(identifierPath => {
+      // Skip JSX element names as they're already checked above
+      if (j.JSXElement.check(identifierPath.parent.node) || j.JSXOpeningElement.check(identifierPath.parent.node) || j.JSXClosingElement.check(identifierPath.parent.node)) {
+        return false;
+      }
+
+      // Skip import declaration identifiers
+      if (j.ImportDeclaration.check(identifierPath.parent.node) || j.ImportDefaultSpecifier.check(identifierPath.parent.node) || j.ImportSpecifier.check(identifierPath.parent.node)) {
+        return false;
+      }
+      return identifierPath.node.name === lozengeImportName;
+    });
+
+    // If no remaining usages, remove the Lozenge import
+    if (remainingLozengeUsages.length === 0 && remainingLozengeReferences.length === 0) {
+      lozengeImports.remove();
+    }
+    return source.toSource();
+  }
+  return source.toSource();
+};
+export default transformer;

package/dist/es2019/presets/lozenge-to-tag-migration/lozenge-to-tag-migration.js

@@ -0,0 +1,18 @@
+import lozengeToTagMigrationTransformer from './codemods/lozenge-to-tag-migration';
+export default async function transformer(file, api) {
+  const transformers = [lozengeToTagMigrationTransformer];
+  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/reporter.js

@@ -1,6 +1,8 @@
 /* eslint-disable no-console */
 import fs from 'fs/promises';
 import path from 'path';
+
+// eslint-disable-next-line @atlaskit/platform/prefer-crypto-random-uuid -- Use crypto.randomUUID instead
 import { v4 as uuidv4 } from 'uuid';
 async function writeToCsv(filePath, data) {
   await fs.writeFile(filePath, data.join('\n'), 'utf-8');
@@ -112,7 +114,9 @@ function prepareCsvData(items) {
   });
 }
 export async function writeReports(details, reportFolder) {
+  // eslint-disable-next-line @atlaskit/platform/prefer-crypto-random-uuid -- Use crypto.randomUUID instead
   const replacementsFilePath = path.join(reportFolder, `${uuidv4()}_success.csv`);
+  // eslint-disable-next-line @atlaskit/platform/prefer-crypto-random-uuid -- Use crypto.randomUUID instead
   const nonReplacementsFilePath = path.join(reportFolder, `${uuidv4()}_failed.csv`);
   await fs.mkdir(reportFolder, {
     recursive: true

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.29.2", _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.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

@@ -13,7 +13,8 @@ import './upgrade-pragmatic-drag-and-drop-to-stable/upgrade-pragmatic-drag-and-d
 import './remove-dark-theme-vr-options/remove-dark-theme-vr-options';
 import './remove-token-fallbacks/remove-token-fallbacks';
 import './lozenge-appearance-to-color/lozenge-appearance-to-color';
-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-to-color'].map(function (preset) {
+import './lozenge-to-tag-migration/lozenge-to-tag-migration';
+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-to-color', 'lozenge-to-tag-migration'].map(function (preset) {
   return path.join(__dirname, preset, "".concat(preset, ".@(ts|js|tsx)"));
 });
 export default presets;

package/dist/esm/presets/lozenge-to-tag-migration/codemods/lozenge-to-tag-migration.js

@@ -0,0 +1,247 @@
+import { addCommentBefore } from '@atlaskit/codemod-utils';
+var transformer = function transformer(file, api) {
+  var j = api.jscodeshift;
+  var source = j(file.source);
+
+  // Check if file has Lozenge imports
+  var lozengeImports = source.find(j.ImportDeclaration).filter(function (path) {
+    return path.node.source.value === '@atlaskit/lozenge';
+  });
+  if (lozengeImports.length === 0) {
+    return file.source;
+  }
+
+  // Get the import name for Lozenge (could be renamed)
+  var lozengeImportName = 'Lozenge';
+  lozengeImports.forEach(function (importPath) {
+    var _importPath$node$spec;
+    (_importPath$node$spec = importPath.node.specifiers) === null || _importPath$node$spec === void 0 || _importPath$node$spec.forEach(function (specifier) {
+      if (j.ImportDefaultSpecifier.check(specifier)) {
+        var _specifier$local;
+        lozengeImportName = ((_specifier$local = specifier.local) === null || _specifier$local === void 0 ? void 0 : _specifier$local.name) || 'Lozenge';
+      } else if (j.ImportSpecifier.check(specifier)) {
+        // Handle { default as Badge } syntax
+        if (j.Identifier.check(specifier.imported) && specifier.imported.name === 'default') {
+          var _specifier$local2;
+          lozengeImportName = ((_specifier$local2 = specifier.local) === null || _specifier$local2 === void 0 ? void 0 : _specifier$local2.name) || 'Lozenge';
+        }
+      }
+    });
+  });
+
+  // Appearance to color mapping
+  var appearanceToColorMap = {
+    success: 'lime',
+    default: 'standard',
+    removed: 'red',
+    inprogress: 'blue',
+    new: 'purple',
+    moved: 'orange'
+  };
+  var hasTransformed = false;
+
+  // Find and transform Lozenge elements
+  source.find(j.JSXElement).forEach(function (elementPath) {
+    var _element$openingEleme, _element$openingEleme2;
+    var element = elementPath.node;
+    if (!j.JSXIdentifier.check(element.openingElement.name)) {
+      return;
+    }
+    if (element.openingElement.name.name !== lozengeImportName) {
+      return;
+    }
+
+    // Check isBold attribute
+    var isBoldAttr = (_element$openingEleme = element.openingElement.attributes) === null || _element$openingEleme === void 0 ? void 0 : _element$openingEleme.find(function (attr) {
+      return j.JSXAttribute.check(attr) && j.JSXIdentifier.check(attr.name) && attr.name.name === 'isBold';
+    });
+
+    // Don't transform if isBold is true or boolean prop without value
+    if (isBoldAttr) {
+      if (j.JSXExpressionContainer.check(isBoldAttr.value)) {
+        var expression = isBoldAttr.value.expression;
+
+        // If it's a boolean literal true, don't transform
+        if (j.BooleanLiteral.check(expression) && expression.value === true) {
+          return;
+        }
+
+        // If it's a boolean literal false, we can transform
+        if (j.BooleanLiteral.check(expression) && expression.value === false) {
+          // Continue with transformation
+        } else {
+          // If it's not a boolean literal (dynamic value), add warning and don't transform
+          addCommentBefore(j, j(elementPath), "FIXME: This Lozenge component uses a dynamic `isBold` prop. Please manually review if this should be migrated to Tag component.\nIf isBold is typically false, consider migrating to <Tag /> from '@atlaskit/tag'.");
+          return;
+        }
+      } else if (!isBoldAttr.value) {
+        // isBold prop without value (boolean shorthand) means true, don't transform
+        return;
+      }
+    }
+
+    // Create new Tag element
+    var newAttributes = [];
+    var otherAttributes = [];
+    var colorAttribute = null;
+    var textContent = '';
+    var hasComplexChildren = false;
+    var hasStyleProp = false;
+    var hasMaxWidthProp = false;
+    var hasUnknownAppearance = false;
+    var dynamicAppearance = false;
+    var unknownAppearanceValue = '';
+
+    // Process children to extract text
+    if (element.children && element.children.length > 0) {
+      if (element.children.length === 1) {
+        var child = element.children[0];
+        if (j.JSXText.check(child)) {
+          var text = child.value.trim();
+          if (text) {
+            textContent = text;
+          }
+        } else if (j.JSXExpressionContainer.check(child) && j.StringLiteral.check(child.expression)) {
+          textContent = child.expression.value;
+        } else {
+          hasComplexChildren = true;
+        }
+      } else {
+        // Multiple children or complex structure
+        hasComplexChildren = true;
+      }
+    }
+
+    // Process attributes
+    (_element$openingEleme2 = element.openingElement.attributes) === null || _element$openingEleme2 === void 0 || _element$openingEleme2.forEach(function (attr) {
+      if (!j.JSXAttribute.check(attr) || !j.JSXIdentifier.check(attr.name)) {
+        return;
+      }
+      var attrName = attr.name.name;
+      switch (attrName) {
+        case 'appearance':
+          var colorValue = 'standard';
+          if (j.StringLiteral.check(attr.value)) {
+            var appearanceValue = attr.value.value;
+            colorValue = appearanceToColorMap[appearanceValue] || appearanceValue;
+            if (!appearanceToColorMap[appearanceValue]) {
+              hasUnknownAppearance = true;
+              unknownAppearanceValue = appearanceValue;
+            }
+          } else if (j.JSXExpressionContainer.check(attr.value)) {
+            // Dynamic appearance
+            dynamicAppearance = true;
+            colorValue = attr.value;
+          }
+          colorAttribute = j.jsxAttribute(j.jsxIdentifier('color'), typeof colorValue === 'string' ? j.stringLiteral(colorValue) : colorValue);
+          break;
+        case 'isBold':
+          // Skip isBold, already handled above
+          break;
+        case 'maxWidth':
+          hasMaxWidthProp = true;
+          break;
+        case 'style':
+          hasStyleProp = true;
+          otherAttributes.push(attr);
+          break;
+        default:
+          // Keep other attributes (testId, etc.)
+          otherAttributes.push(attr);
+          break;
+      }
+    });
+
+    // Assemble attributes in correct order: text, other props, color
+    if (textContent && !hasComplexChildren) {
+      newAttributes.push(j.jsxAttribute(j.jsxIdentifier('text'), j.stringLiteral(textContent)));
+    }
+
+    // Add other attributes
+    newAttributes.push.apply(newAttributes, otherAttributes);
+
+    // Add color attribute last (default to 'standard' if no appearance was found)
+    if (colorAttribute) {
+      newAttributes.push(colorAttribute);
+    } else {
+      // Default color when no appearance is specified
+      newAttributes.push(j.jsxAttribute(j.jsxIdentifier('color'), j.stringLiteral('standard')));
+    }
+
+    // Create new Tag element
+    var newElement = j.jsxElement(j.jsxOpeningElement(j.jsxIdentifier('Tag'), newAttributes, true), null, []);
+
+    // Add warning comments as needed
+    var warnings = [];
+    if (hasComplexChildren) {
+      warnings.push("FIXME: This Tag component has complex children that couldn't be automatically migrated to the text prop.\nTag component only supports simple text via the text prop. Please manually convert the children content.");
+    }
+    if (hasMaxWidthProp) {
+      warnings.push('FIXME: maxWidth prop was removed during migration from Lozenge to Tag.\nTag component does not support maxWidth. Please review if width constraints are needed.');
+    }
+    if (hasStyleProp) {
+      warnings.push('FIXME: This Tag component has a style prop that was kept during migration.\nTag component has limited style support. Please review if custom styles are compatible.');
+    }
+    if (hasUnknownAppearance) {
+      warnings.push("FIXME: This Tag component uses an unknown appearance value \"".concat(unknownAppearanceValue, "\".\nPlease update to a valid Tag color: standard, green, lime, blue, red, purple, magenta, grey, teal, orange, yellow."));
+    }
+    if (dynamicAppearance) {
+      warnings.push('FIXME: This Tag component uses a dynamic `appearance` prop that has been renamed to `color`.\nPlease verify that the values being passed are valid color values (semantic: default, inprogress, moved, new, removed, success).');
+    }
+
+    // Replace the element first
+    elementPath.replace(newElement);
+
+    // Add warning comments using addCommentBefore if needed
+    if (warnings.length > 0) {
+      var commentText = warnings.join('\n');
+      addCommentBefore(j, j(elementPath), commentText);
+    }
+    hasTransformed = true;
+  });
+
+  // Add Tag import if we transformed any elements
+  if (hasTransformed) {
+    // Check if Tag import already exists
+    var tagImports = source.find(j.ImportDeclaration).filter(function (path) {
+      return path.node.source.value === '@atlaskit/tag';
+    });
+    if (tagImports.length === 0) {
+      // Add Tag import after Lozenge import
+      var lozengeImportPath = lozengeImports.at(0);
+      var tagImport = j.importDeclaration([j.importDefaultSpecifier(j.identifier('Tag'))], j.stringLiteral('@atlaskit/tag'));
+      lozengeImportPath.insertAfter(tagImport);
+    }
+
+    // Check if there are any remaining Lozenge usages
+    var remainingLozengeUsages = source.find(j.JSXElement).filter(function (elementPath) {
+      var element = elementPath.node;
+      if (!j.JSXIdentifier.check(element.openingElement.name)) {
+        return false;
+      }
+      return element.openingElement.name.name === lozengeImportName;
+    });
+
+    // Also check for other usages like function calls, type references, etc.
+    var remainingLozengeReferences = source.find(j.Identifier).filter(function (identifierPath) {
+      // Skip JSX element names as they're already checked above
+      if (j.JSXElement.check(identifierPath.parent.node) || j.JSXOpeningElement.check(identifierPath.parent.node) || j.JSXClosingElement.check(identifierPath.parent.node)) {
+        return false;
+      }
+
+      // Skip import declaration identifiers
+      if (j.ImportDeclaration.check(identifierPath.parent.node) || j.ImportDefaultSpecifier.check(identifierPath.parent.node) || j.ImportSpecifier.check(identifierPath.parent.node)) {
+        return false;
+      }
+      return identifierPath.node.name === lozengeImportName;
+    });
+
+    // If no remaining usages, remove the Lozenge import
+    if (remainingLozengeUsages.length === 0 && remainingLozengeReferences.length === 0) {
+      lozengeImports.remove();
+    }
+    return source.toSource();
+  }
+  return source.toSource();
+};
+export default transformer;

package/dist/esm/presets/lozenge-to-tag-migration/lozenge-to-tag-migration.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 lozengeToTagMigrationTransformer from './codemods/lozenge-to-tag-migration';
+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 = [lozengeToTagMigrationTransformer];
+          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/reporter.js

@@ -7,6 +7,8 @@ import _regeneratorRuntime from "@babel/runtime/regenerator";
 /* eslint-disable no-console */
 import fs from 'fs/promises';
 import path from 'path';
+
+// eslint-disable-next-line @atlaskit/platform/prefer-crypto-random-uuid -- Use crypto.randomUUID instead
 import { v4 as uuidv4 } from 'uuid';
 function writeToCsv(_x, _x2) {
   return _writeToCsv.apply(this, arguments);
@@ -288,7 +290,8 @@ function _writeReports() {
     return _regeneratorRuntime.wrap(function _callee6$(_context6) {
       while (1) switch (_context6.prev = _context6.next) {
         case 0:
-          replacementsFilePath = path.join(reportFolder, "".concat(uuidv4(), "_success.csv"));
+          // eslint-disable-next-line @atlaskit/platform/prefer-crypto-random-uuid -- Use crypto.randomUUID instead
+          replacementsFilePath = path.join(reportFolder, "".concat(uuidv4(), "_success.csv")); // eslint-disable-next-line @atlaskit/platform/prefer-crypto-random-uuid -- Use crypto.randomUUID instead
           nonReplacementsFilePath = path.join(reportFolder, "".concat(uuidv4(), "_failed.csv"));
           _context6.next = 4;
           return fs.mkdir(reportFolder, {

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

@@ -11,5 +11,6 @@ import './upgrade-pragmatic-drag-and-drop-to-stable/upgrade-pragmatic-drag-and-d
 import './remove-dark-theme-vr-options/remove-dark-theme-vr-options';
 import './remove-token-fallbacks/remove-token-fallbacks';
 import './lozenge-appearance-to-color/lozenge-appearance-to-color';
+import './lozenge-to-tag-migration/lozenge-to-tag-migration';
 declare const presets: string[];
 export default presets;

package/dist/types/presets/lozenge-to-tag-migration/codemods/lozenge-to-tag-migration.d.ts

@@ -0,0 +1,3 @@
+import type { API, FileInfo } from 'jscodeshift';
+declare const transformer: (file: FileInfo, api: API) => string | undefined;
+export default transformer;

package/dist/types/presets/lozenge-to-tag-migration/lozenge-to-tag-migration.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

@@ -11,5 +11,6 @@ import './upgrade-pragmatic-drag-and-drop-to-stable/upgrade-pragmatic-drag-and-d
 import './remove-dark-theme-vr-options/remove-dark-theme-vr-options';
 import './remove-token-fallbacks/remove-token-fallbacks';
 import './lozenge-appearance-to-color/lozenge-appearance-to-color';
+import './lozenge-to-tag-migration/lozenge-to-tag-migration';
 declare const presets: string[];
 export default presets;

package/dist/types-ts4.5/presets/lozenge-to-tag-migration/codemods/lozenge-to-tag-migration.d.ts

@@ -0,0 +1,3 @@
+import type { API, FileInfo } from 'jscodeshift';
+declare const transformer: (file: FileInfo, api: API) => string | undefined;
+export default transformer;

package/dist/types-ts4.5/presets/lozenge-to-tag-migration/lozenge-to-tag-migration.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.30.0",
+	"version": "0.31.1",
 	"description": "A cli for distributing codemods for atlassian-frontend components and services",
 	"publishConfig": {
 		"registry": "https://registry.npmjs.org/"
@@ -29,7 +29,7 @@
 	"bin": "./bin/codemod-cli.js",
 	"dependencies": {
 		"@atlaskit/codemod-utils": "^4.2.0",
-		"@atlaskit/tokens": "^7.0.0",
+		"@atlaskit/tokens": "^8.0.0",
 		"@babel/runtime": "^7.0.0",
 		"@codeshift/utils": "^0.2.4",
 		"@hypermod/utils": "^0.4.2",