@atlaskit/codemod-cli 0.33.1 → 0.34.0

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/migrate-deprecated-icon/codemods/migrate-deprecated-icon.js

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

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

@@ -0,0 +1,18 @@
+import migrateDeprecatedIconTransformer from './codemods/migrate-deprecated-icon';
+export default async function transformer(file, api) {
+  const transformers = [migrateDeprecatedIconTransformer];
+  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/migrate-deprecated-icon/utils/mock.js

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

package/dist/esm/main.js

@@ -355,7 +355,7 @@ function _main() {
         case 4:
           _yield$parseArgs = _context6.sent;
           packages = _yield$parseArgs.packages;
-          _process$env$_PACKAGE = "0.33.0", _PACKAGE_VERSION_ = _process$env$_PACKAGE === void 0 ? '0.0.0-dev' : _process$env$_PACKAGE;
+          _process$env$_PACKAGE = "0.0.0-development", _PACKAGE_VERSION_ = _process$env$_PACKAGE === void 0 ? '0.0.0-dev' : _process$env$_PACKAGE;
           logger.log(chalk.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,9 +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';
-var presets = ['styled-to-emotion', 'theme-remove-deprecated-mixins', 'migrate-to-link', 'migrate-to-new-buttons', 'migrate-icon-object-to-object', 'upgrade-pragmatic-drag-and-drop-to-stable', 'remove-dark-theme-vr-options', 'remove-token-fallbacks', 'lozenge-appearance-semantic-migration', 'lozenge-to-tag-migration', 'badge-appearance-semantic-migration', 'tag-to-newTag-migration'].map(function (preset) {
+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', '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;