@atlaskit/eslint-plugin-design-system 15.1.0 → 15.1.1

package/CHANGELOG.md

@@ -1,5 +1,20 @@
 # @atlaskit/eslint-plugin-design-system
 
+## 15.1.1
+
+### Patch Changes
+
+- [`2b3eee14e8063`](https://bitbucket.org/atlassian/atlassian-frontend-monorepo/commits/2b3eee14e8063) -
+  Update lozenge-badge-tag-labelling-system-migration ESLint rule and codemod for the new Lozenge
+  API.
+  - Lozenges no longer migrate to `<Tag>`. The `<Lozenge>` component stays as `<Lozenge>`.
+  - Legacy `appearance` values are now auto-fixed in-place to new semantic values: `default` →
+    `neutral`, `inprogress` → `information`, `moved` → `warning`, `removed` → `danger`, `new` →
+    `discovery`. The value `success` is unchanged.
+  - `isBold` is intentionally not flagged: while the feature flag
+    `platform-dst-lozenge-tag-badge-visual-uplifts` is OFF, users still need `isBold` to render
+    subtle Lozenges. It will be cleaned up in a separate pass after rollout.
+
 ## 15.1.0
 
 ### Minor Changes

package/dist/cjs/rules/lozenge-badge-tag-labelling-system-migration/index.js

@@ -22,9 +22,7 @@ var rule = (0, _createLintRule.createLintRule)({
     },
     messages: {
       updateAppearance: 'Update appearance value to new semantic value.',
-      migrateTag: 'Non-bold <Lozenge> variants should migrate to <Tag> component. For safe, staged rollout, use the `migration_fallback="lozenge"` prop which renders as Lozenge when the feature flag is off.',
-      manualReview: "Dynamic 'isBold' props require manual review before migration.",
-      dynamicLozengeAppearance: "Dynamic 'appearance' prop values require manual review before migrating to Tag. Please verify the appearance value and manually convert it to the appropriate color prop value.",
+      migrateTag: '<SimpleTag> and <RemovableTag> components should migrate to the new <Tag> or <AvatarTag> component.',
       updateBadgeAppearance: 'Update Badge appearance value "{{oldValue}}" to new semantic value "{{newValue}}".',
       dynamicBadgeAppearance: 'Dynamic appearance prop values require manual review to ensure they use the new semantic values: neutral, information, inverse, danger, success.'
     }
@@ -70,13 +68,6 @@ var rule = (0, _createLintRule.createLintRule)({
      */
     var newTagImports = {};
 
-    /**
-     * Check if a JSX attribute value is a literal false
-     */
-    function isLiteralFalse(node) {
-      return node && node.type === 'JSXExpressionContainer' && node.expression && node.expression.type === 'Literal' && node.expression.value === false;
-    }
-
     /**
      * Check if a JSX attribute value is dynamic (not a static literal value)
      * Can be used for any prop type (boolean, string, etc.)
@@ -113,37 +104,22 @@ var rule = (0, _createLintRule.createLintRule)({
     }
 
     /**
-     * Map old appearance values to new semantic appearance values
-     * Both Lozenge and Tag now use the same appearance prop with new semantic values
+     * Map old Lozenge appearance values to new semantic appearance values.
+     * The new Lozenge no longer uses legacy values — it uses semantic color names
+     * that align with the new labelling system.
      */
     function mapToNewAppearanceValue(oldValue) {
       var mapping = {
-        success: 'success',
-        default: 'default',
-        removed: 'removed',
-        inprogress: 'inprogress',
-        new: 'new',
-        moved: 'moved'
+        default: 'neutral',
+        inprogress: 'information',
+        moved: 'warning',
+        removed: 'danger',
+        new: 'discovery',
+        success: 'success'
       };
       return mapping[oldValue] || oldValue;
     }
 
-    /**
-     * Map Lozenge appearance values to Tag color values
-     * Used when migrating Lozenge to Tag component
-     */
-    function mapLozengeAppearanceToTagColor(appearanceValue) {
-      var mapping = {
-        success: 'lime',
-        default: 'gray',
-        removed: 'red',
-        inprogress: 'blue',
-        new: 'purple',
-        moved: 'yellow'
-      };
-      return mapping[appearanceValue] || appearanceValue;
-    }
-
     /**
      * Map Badge old appearance values to new semantic appearance values
      */
@@ -269,7 +245,7 @@ var rule = (0, _createLintRule.createLintRule)({
 
     /**
      * Generate the replacement JSX element text for Tag migration
-     * Handles both regular Tag and avatarTag migrations
+     * Handles both regular Tag and AvatarTag migrations for SimpleTag/RemovableTag.
      */
     function generateTagReplacement(node) {
       var _context$sourceCode;
@@ -288,20 +264,7 @@ var rule = (0, _createLintRule.createLintRule)({
             return;
           }
           if (attrName === 'appearance') {
-            // For Lozenge migrations, convert appearance to color prop
-            // For SimpleTag/RemovableTag migrations, delete appearance prop
-            if (options.isLozengeMigration) {
-              // Map Lozenge appearance value to Tag color value and change prop name from appearance to color
-              var stringValue = extractStringValue(attr.value);
-              if (stringValue && typeof stringValue === 'string') {
-                var mappedColor = mapLozengeAppearanceToTagColor(stringValue);
-                newAttributes.push("color=\"".concat(mappedColor, "\""));
-              }
-              // If we can't extract the string value (dynamic expression), skip it
-              // Dynamic expressions should be caught earlier and require manual review
-              // This code path shouldn't be reached, but we skip to be safe
-            }
-            // For SimpleTag/RemovableTag migrations, skip appearance prop (delete it)
+            // Delete appearance prop — not used in new Tag/AvatarTag API
             return;
           }
           if (attrName === 'color') {
@@ -310,10 +273,10 @@ var rule = (0, _createLintRule.createLintRule)({
             if (options.isAvatarTag) {
               return;
             }
-            var _stringValue = extractStringValue(attr.value);
-            if (_stringValue && typeof _stringValue === 'string') {
-              var _mappedColor = mapTagColorValue(_stringValue);
-              newAttributes.push("color=\"".concat(_mappedColor, "\""));
+            var stringValue = extractStringValue(attr.value);
+            if (stringValue && typeof stringValue === 'string') {
+              var mappedColor = mapTagColorValue(stringValue);
+              newAttributes.push("color=\"".concat(mappedColor, "\""));
             } else {
               // If we can't extract the string value, keep as-is
               var value = attr.value ? sourceCode.getText(attr.value) : '';
@@ -363,15 +326,10 @@ var rule = (0, _createLintRule.createLintRule)({
         }
       });
 
-      // Add isRemovable={false} for SimpleTag migrations and Lozenge migrations
-      if (options.isSimpleTag || options.isLozengeMigration) {
+      // Add isRemovable={false} for SimpleTag migrations
+      if (options.isSimpleTag) {
         newAttributes.push('isRemovable={false}');
       }
-
-      // Add migration_fallback="lozenge" for Lozenge migrations to enable safe staged rollout
-      if (options.isLozengeMigration) {
-        newAttributes.push('migration_fallback="lozenge"');
-      }
       var attributesText = newAttributes.length > 0 ? " ".concat(newAttributes.join(' ')) : '';
       var children = node.children.length > 0 ? sourceCode.getText().slice(node.openingElement.range[1], node.closingElement ? node.closingElement.range[0] : node.range[1]) : '';
       var componentName = options.preserveComponentName ? node.openingElement.name.name : options.isAvatarTag ? 'AvatarTag' : 'Tag';
@@ -642,77 +600,22 @@ var rule = (0, _createLintRule.createLintRule)({
         }
         var attributesMap = getAttributesMap(node.openingElement.attributes);
         var appearanceProp = attributesMap.appearance;
-        var isBoldProp = attributesMap.isBold;
 
-        // Handle appearance prop value migration
+        // Handle appearance prop value migration — always update to new semantic values.
+        // isBold is intentionally not flagged: users may still need it while the feature flag
+        // platform-dst-lozenge-tag-badge-visual-uplifts is OFF (subtle variant still rendered).
         if (appearanceProp) {
-          var shouldMigrateToTag = !isBoldProp || isLiteralFalse(isBoldProp.value);
-          if (!shouldMigrateToTag) {
-            // Only update appearance values for Lozenge components that stay as Lozenge
-            var _stringValue2 = extractStringValue(appearanceProp.value);
-            if (_stringValue2 && typeof _stringValue2 === 'string') {
-              var _mappedValue = mapToNewAppearanceValue(_stringValue2);
-              if (_mappedValue !== _stringValue2) {
-                context.report({
-                  node: appearanceProp,
-                  messageId: 'updateAppearance',
-                  fix: createAppearanceFixer(appearanceProp.value, _mappedValue)
-                });
-              }
-            }
-          }
-        }
-
-        // Handle isBold prop and Tag migration
-        if (isBoldProp) {
-          if (isLiteralFalse(isBoldProp.value)) {
-            // isBold={false} should migrate to Tag
-            // Check if appearance is dynamic - if so, require manual review
-            if (appearanceProp && isDynamicExpression(appearanceProp.value)) {
+          var _stringValue = extractStringValue(appearanceProp.value);
+          if (_stringValue && typeof _stringValue === 'string') {
+            var _mappedValue = mapToNewAppearanceValue(_stringValue);
+            if (_mappedValue !== _stringValue) {
               context.report({
                 node: appearanceProp,
-                messageId: 'dynamicLozengeAppearance'
+                messageId: 'updateAppearance',
+                fix: createAppearanceFixer(appearanceProp.value, _mappedValue)
               });
-              return;
             }
-            context.report({
-              node: node,
-              messageId: 'migrateTag',
-              fix: function fix(fixer) {
-                var replacement = generateTagReplacement(node, {
-                  isLozengeMigration: true
-                });
-                return fixer.replaceText(node, replacement);
-              }
-            });
-          } else if (isDynamicExpression(isBoldProp.value)) {
-            // Dynamic isBold requires manual review
-            context.report({
-              node: isBoldProp,
-              messageId: 'manualReview'
-            });
           }
-          // isBold={true} or isBold (implicit true) - no action needed
-        } else {
-          // No isBold prop means implicit false, should migrate to Tag
-          // Check if appearance is dynamic - if so, require manual review
-          if (appearanceProp && isDynamicExpression(appearanceProp.value)) {
-            context.report({
-              node: appearanceProp,
-              messageId: 'dynamicLozengeAppearance'
-            });
-            return;
-          }
-          context.report({
-            node: node,
-            messageId: 'migrateTag',
-            fix: function fix(fixer) {
-              var replacement = generateTagReplacement(node, {
-                isLozengeMigration: true
-              });
-              return fixer.replaceText(node, replacement);
-            }
-          });
         }
       }
     };

package/dist/es2019/rules/lozenge-badge-tag-labelling-system-migration/index.js

@@ -12,9 +12,7 @@ const rule = createLintRule({
     },
     messages: {
       updateAppearance: 'Update appearance value to new semantic value.',
-      migrateTag: 'Non-bold <Lozenge> variants should migrate to <Tag> component. For safe, staged rollout, use the `migration_fallback="lozenge"` prop which renders as Lozenge when the feature flag is off.',
-      manualReview: "Dynamic 'isBold' props require manual review before migration.",
-      dynamicLozengeAppearance: "Dynamic 'appearance' prop values require manual review before migrating to Tag. Please verify the appearance value and manually convert it to the appropriate color prop value.",
+      migrateTag: '<SimpleTag> and <RemovableTag> components should migrate to the new <Tag> or <AvatarTag> component.',
       updateBadgeAppearance: 'Update Badge appearance value "{{oldValue}}" to new semantic value "{{newValue}}".',
       dynamicBadgeAppearance: 'Dynamic appearance prop values require manual review to ensure they use the new semantic values: neutral, information, inverse, danger, success.'
     }
@@ -60,13 +58,6 @@ const rule = createLintRule({
      */
     const newTagImports = {};
 
-    /**
-     * Check if a JSX attribute value is a literal false
-     */
-    function isLiteralFalse(node) {
-      return node && node.type === 'JSXExpressionContainer' && node.expression && node.expression.type === 'Literal' && node.expression.value === false;
-    }
-
     /**
      * Check if a JSX attribute value is dynamic (not a static literal value)
      * Can be used for any prop type (boolean, string, etc.)
@@ -103,37 +94,22 @@ const rule = createLintRule({
     }
 
     /**
-     * Map old appearance values to new semantic appearance values
-     * Both Lozenge and Tag now use the same appearance prop with new semantic values
+     * Map old Lozenge appearance values to new semantic appearance values.
+     * The new Lozenge no longer uses legacy values — it uses semantic color names
+     * that align with the new labelling system.
      */
     function mapToNewAppearanceValue(oldValue) {
       const mapping = {
-        success: 'success',
-        default: 'default',
-        removed: 'removed',
-        inprogress: 'inprogress',
-        new: 'new',
-        moved: 'moved'
+        default: 'neutral',
+        inprogress: 'information',
+        moved: 'warning',
+        removed: 'danger',
+        new: 'discovery',
+        success: 'success'
       };
       return mapping[oldValue] || oldValue;
     }
 
-    /**
-     * Map Lozenge appearance values to Tag color values
-     * Used when migrating Lozenge to Tag component
-     */
-    function mapLozengeAppearanceToTagColor(appearanceValue) {
-      const mapping = {
-        success: 'lime',
-        default: 'gray',
-        removed: 'red',
-        inprogress: 'blue',
-        new: 'purple',
-        moved: 'yellow'
-      };
-      return mapping[appearanceValue] || appearanceValue;
-    }
-
     /**
      * Map Badge old appearance values to new semantic appearance values
      */
@@ -259,7 +235,7 @@ const rule = createLintRule({
 
     /**
      * Generate the replacement JSX element text for Tag migration
-     * Handles both regular Tag and avatarTag migrations
+     * Handles both regular Tag and AvatarTag migrations for SimpleTag/RemovableTag.
      */
     function generateTagReplacement(node, options = {}) {
       var _context$sourceCode;
@@ -277,20 +253,7 @@ const rule = createLintRule({
             return;
           }
           if (attrName === 'appearance') {
-            // For Lozenge migrations, convert appearance to color prop
-            // For SimpleTag/RemovableTag migrations, delete appearance prop
-            if (options.isLozengeMigration) {
-              // Map Lozenge appearance value to Tag color value and change prop name from appearance to color
-              const stringValue = extractStringValue(attr.value);
-              if (stringValue && typeof stringValue === 'string') {
-                const mappedColor = mapLozengeAppearanceToTagColor(stringValue);
-                newAttributes.push(`color="${mappedColor}"`);
-              }
-              // If we can't extract the string value (dynamic expression), skip it
-              // Dynamic expressions should be caught earlier and require manual review
-              // This code path shouldn't be reached, but we skip to be safe
-            }
-            // For SimpleTag/RemovableTag migrations, skip appearance prop (delete it)
+            // Delete appearance prop — not used in new Tag/AvatarTag API
             return;
           }
           if (attrName === 'color') {
@@ -352,15 +315,10 @@ const rule = createLintRule({
         }
       });
 
-      // Add isRemovable={false} for SimpleTag migrations and Lozenge migrations
-      if (options.isSimpleTag || options.isLozengeMigration) {
+      // Add isRemovable={false} for SimpleTag migrations
+      if (options.isSimpleTag) {
         newAttributes.push('isRemovable={false}');
       }
-
-      // Add migration_fallback="lozenge" for Lozenge migrations to enable safe staged rollout
-      if (options.isLozengeMigration) {
-        newAttributes.push('migration_fallback="lozenge"');
-      }
       const attributesText = newAttributes.length > 0 ? ` ${newAttributes.join(' ')}` : '';
       const children = node.children.length > 0 ? sourceCode.getText().slice(node.openingElement.range[1], node.closingElement ? node.closingElement.range[0] : node.range[1]) : '';
       const componentName = options.preserveComponentName ? node.openingElement.name.name : options.isAvatarTag ? 'AvatarTag' : 'Tag';
@@ -632,77 +590,22 @@ const rule = createLintRule({
         }
         const attributesMap = getAttributesMap(node.openingElement.attributes);
         const appearanceProp = attributesMap.appearance;
-        const isBoldProp = attributesMap.isBold;
 
-        // Handle appearance prop value migration
+        // Handle appearance prop value migration — always update to new semantic values.
+        // isBold is intentionally not flagged: users may still need it while the feature flag
+        // platform-dst-lozenge-tag-badge-visual-uplifts is OFF (subtle variant still rendered).
         if (appearanceProp) {
-          const shouldMigrateToTag = !isBoldProp || isLiteralFalse(isBoldProp.value);
-          if (!shouldMigrateToTag) {
-            // Only update appearance values for Lozenge components that stay as Lozenge
-            const stringValue = extractStringValue(appearanceProp.value);
-            if (stringValue && typeof stringValue === 'string') {
-              const mappedValue = mapToNewAppearanceValue(stringValue);
-              if (mappedValue !== stringValue) {
-                context.report({
-                  node: appearanceProp,
-                  messageId: 'updateAppearance',
-                  fix: createAppearanceFixer(appearanceProp.value, mappedValue)
-                });
-              }
-            }
-          }
-        }
-
-        // Handle isBold prop and Tag migration
-        if (isBoldProp) {
-          if (isLiteralFalse(isBoldProp.value)) {
-            // isBold={false} should migrate to Tag
-            // Check if appearance is dynamic - if so, require manual review
-            if (appearanceProp && isDynamicExpression(appearanceProp.value)) {
+          const stringValue = extractStringValue(appearanceProp.value);
+          if (stringValue && typeof stringValue === 'string') {
+            const mappedValue = mapToNewAppearanceValue(stringValue);
+            if (mappedValue !== stringValue) {
               context.report({
                 node: appearanceProp,
-                messageId: 'dynamicLozengeAppearance'
+                messageId: 'updateAppearance',
+                fix: createAppearanceFixer(appearanceProp.value, mappedValue)
               });
-              return;
             }
-            context.report({
-              node: node,
-              messageId: 'migrateTag',
-              fix: fixer => {
-                const replacement = generateTagReplacement(node, {
-                  isLozengeMigration: true
-                });
-                return fixer.replaceText(node, replacement);
-              }
-            });
-          } else if (isDynamicExpression(isBoldProp.value)) {
-            // Dynamic isBold requires manual review
-            context.report({
-              node: isBoldProp,
-              messageId: 'manualReview'
-            });
-          }
-          // isBold={true} or isBold (implicit true) - no action needed
-        } else {
-          // No isBold prop means implicit false, should migrate to Tag
-          // Check if appearance is dynamic - if so, require manual review
-          if (appearanceProp && isDynamicExpression(appearanceProp.value)) {
-            context.report({
-              node: appearanceProp,
-              messageId: 'dynamicLozengeAppearance'
-            });
-            return;
           }
-          context.report({
-            node: node,
-            messageId: 'migrateTag',
-            fix: fixer => {
-              const replacement = generateTagReplacement(node, {
-                isLozengeMigration: true
-              });
-              return fixer.replaceText(node, replacement);
-            }
-          });
         }
       }
     };

package/dist/esm/rules/lozenge-badge-tag-labelling-system-migration/index.js

@@ -15,9 +15,7 @@ var rule = createLintRule({
     },
     messages: {
       updateAppearance: 'Update appearance value to new semantic value.',
-      migrateTag: 'Non-bold <Lozenge> variants should migrate to <Tag> component. For safe, staged rollout, use the `migration_fallback="lozenge"` prop which renders as Lozenge when the feature flag is off.',
-      manualReview: "Dynamic 'isBold' props require manual review before migration.",
-      dynamicLozengeAppearance: "Dynamic 'appearance' prop values require manual review before migrating to Tag. Please verify the appearance value and manually convert it to the appropriate color prop value.",
+      migrateTag: '<SimpleTag> and <RemovableTag> components should migrate to the new <Tag> or <AvatarTag> component.',
       updateBadgeAppearance: 'Update Badge appearance value "{{oldValue}}" to new semantic value "{{newValue}}".',
       dynamicBadgeAppearance: 'Dynamic appearance prop values require manual review to ensure they use the new semantic values: neutral, information, inverse, danger, success.'
     }
@@ -63,13 +61,6 @@ var rule = createLintRule({
      */
     var newTagImports = {};
 
-    /**
-     * Check if a JSX attribute value is a literal false
-     */
-    function isLiteralFalse(node) {
-      return node && node.type === 'JSXExpressionContainer' && node.expression && node.expression.type === 'Literal' && node.expression.value === false;
-    }
-
     /**
      * Check if a JSX attribute value is dynamic (not a static literal value)
      * Can be used for any prop type (boolean, string, etc.)
@@ -106,37 +97,22 @@ var rule = createLintRule({
     }
 
     /**
-     * Map old appearance values to new semantic appearance values
-     * Both Lozenge and Tag now use the same appearance prop with new semantic values
+     * Map old Lozenge appearance values to new semantic appearance values.
+     * The new Lozenge no longer uses legacy values — it uses semantic color names
+     * that align with the new labelling system.
      */
     function mapToNewAppearanceValue(oldValue) {
       var mapping = {
-        success: 'success',
-        default: 'default',
-        removed: 'removed',
-        inprogress: 'inprogress',
-        new: 'new',
-        moved: 'moved'
+        default: 'neutral',
+        inprogress: 'information',
+        moved: 'warning',
+        removed: 'danger',
+        new: 'discovery',
+        success: 'success'
       };
       return mapping[oldValue] || oldValue;
     }
 
-    /**
-     * Map Lozenge appearance values to Tag color values
-     * Used when migrating Lozenge to Tag component
-     */
-    function mapLozengeAppearanceToTagColor(appearanceValue) {
-      var mapping = {
-        success: 'lime',
-        default: 'gray',
-        removed: 'red',
-        inprogress: 'blue',
-        new: 'purple',
-        moved: 'yellow'
-      };
-      return mapping[appearanceValue] || appearanceValue;
-    }
-
     /**
      * Map Badge old appearance values to new semantic appearance values
      */
@@ -262,7 +238,7 @@ var rule = createLintRule({
 
     /**
      * Generate the replacement JSX element text for Tag migration
-     * Handles both regular Tag and avatarTag migrations
+     * Handles both regular Tag and AvatarTag migrations for SimpleTag/RemovableTag.
      */
     function generateTagReplacement(node) {
       var _context$sourceCode;
@@ -281,20 +257,7 @@ var rule = createLintRule({
             return;
           }
           if (attrName === 'appearance') {
-            // For Lozenge migrations, convert appearance to color prop
-            // For SimpleTag/RemovableTag migrations, delete appearance prop
-            if (options.isLozengeMigration) {
-              // Map Lozenge appearance value to Tag color value and change prop name from appearance to color
-              var stringValue = extractStringValue(attr.value);
-              if (stringValue && typeof stringValue === 'string') {
-                var mappedColor = mapLozengeAppearanceToTagColor(stringValue);
-                newAttributes.push("color=\"".concat(mappedColor, "\""));
-              }
-              // If we can't extract the string value (dynamic expression), skip it
-              // Dynamic expressions should be caught earlier and require manual review
-              // This code path shouldn't be reached, but we skip to be safe
-            }
-            // For SimpleTag/RemovableTag migrations, skip appearance prop (delete it)
+            // Delete appearance prop — not used in new Tag/AvatarTag API
             return;
           }
           if (attrName === 'color') {
@@ -303,10 +266,10 @@ var rule = createLintRule({
             if (options.isAvatarTag) {
               return;
             }
-            var _stringValue = extractStringValue(attr.value);
-            if (_stringValue && typeof _stringValue === 'string') {
-              var _mappedColor = mapTagColorValue(_stringValue);
-              newAttributes.push("color=\"".concat(_mappedColor, "\""));
+            var stringValue = extractStringValue(attr.value);
+            if (stringValue && typeof stringValue === 'string') {
+              var mappedColor = mapTagColorValue(stringValue);
+              newAttributes.push("color=\"".concat(mappedColor, "\""));
             } else {
               // If we can't extract the string value, keep as-is
               var value = attr.value ? sourceCode.getText(attr.value) : '';
@@ -356,15 +319,10 @@ var rule = createLintRule({
         }
       });
 
-      // Add isRemovable={false} for SimpleTag migrations and Lozenge migrations
-      if (options.isSimpleTag || options.isLozengeMigration) {
+      // Add isRemovable={false} for SimpleTag migrations
+      if (options.isSimpleTag) {
         newAttributes.push('isRemovable={false}');
       }
-
-      // Add migration_fallback="lozenge" for Lozenge migrations to enable safe staged rollout
-      if (options.isLozengeMigration) {
-        newAttributes.push('migration_fallback="lozenge"');
-      }
       var attributesText = newAttributes.length > 0 ? " ".concat(newAttributes.join(' ')) : '';
       var children = node.children.length > 0 ? sourceCode.getText().slice(node.openingElement.range[1], node.closingElement ? node.closingElement.range[0] : node.range[1]) : '';
       var componentName = options.preserveComponentName ? node.openingElement.name.name : options.isAvatarTag ? 'AvatarTag' : 'Tag';
@@ -635,77 +593,22 @@ var rule = createLintRule({
         }
         var attributesMap = getAttributesMap(node.openingElement.attributes);
         var appearanceProp = attributesMap.appearance;
-        var isBoldProp = attributesMap.isBold;
 
-        // Handle appearance prop value migration
+        // Handle appearance prop value migration — always update to new semantic values.
+        // isBold is intentionally not flagged: users may still need it while the feature flag
+        // platform-dst-lozenge-tag-badge-visual-uplifts is OFF (subtle variant still rendered).
         if (appearanceProp) {
-          var shouldMigrateToTag = !isBoldProp || isLiteralFalse(isBoldProp.value);
-          if (!shouldMigrateToTag) {
-            // Only update appearance values for Lozenge components that stay as Lozenge
-            var _stringValue2 = extractStringValue(appearanceProp.value);
-            if (_stringValue2 && typeof _stringValue2 === 'string') {
-              var _mappedValue = mapToNewAppearanceValue(_stringValue2);
-              if (_mappedValue !== _stringValue2) {
-                context.report({
-                  node: appearanceProp,
-                  messageId: 'updateAppearance',
-                  fix: createAppearanceFixer(appearanceProp.value, _mappedValue)
-                });
-              }
-            }
-          }
-        }
-
-        // Handle isBold prop and Tag migration
-        if (isBoldProp) {
-          if (isLiteralFalse(isBoldProp.value)) {
-            // isBold={false} should migrate to Tag
-            // Check if appearance is dynamic - if so, require manual review
-            if (appearanceProp && isDynamicExpression(appearanceProp.value)) {
+          var _stringValue = extractStringValue(appearanceProp.value);
+          if (_stringValue && typeof _stringValue === 'string') {
+            var _mappedValue = mapToNewAppearanceValue(_stringValue);
+            if (_mappedValue !== _stringValue) {
               context.report({
                 node: appearanceProp,
-                messageId: 'dynamicLozengeAppearance'
+                messageId: 'updateAppearance',
+                fix: createAppearanceFixer(appearanceProp.value, _mappedValue)
               });
-              return;
             }
-            context.report({
-              node: node,
-              messageId: 'migrateTag',
-              fix: function fix(fixer) {
-                var replacement = generateTagReplacement(node, {
-                  isLozengeMigration: true
-                });
-                return fixer.replaceText(node, replacement);
-              }
-            });
-          } else if (isDynamicExpression(isBoldProp.value)) {
-            // Dynamic isBold requires manual review
-            context.report({
-              node: isBoldProp,
-              messageId: 'manualReview'
-            });
           }
-          // isBold={true} or isBold (implicit true) - no action needed
-        } else {
-          // No isBold prop means implicit false, should migrate to Tag
-          // Check if appearance is dynamic - if so, require manual review
-          if (appearanceProp && isDynamicExpression(appearanceProp.value)) {
-            context.report({
-              node: appearanceProp,
-              messageId: 'dynamicLozengeAppearance'
-            });
-            return;
-          }
-          context.report({
-            node: node,
-            messageId: 'migrateTag',
-            fix: function fix(fixer) {
-              var replacement = generateTagReplacement(node, {
-                isLozengeMigration: true
-              });
-              return fixer.replaceText(node, replacement);
-            }
-          });
         }
       }
     };

package/package.json

@@ -1,7 +1,7 @@
 {
 	"name": "@atlaskit/eslint-plugin-design-system",
 	"description": "The essential plugin for use with the Atlassian Design System.",
-	"version": "15.1.0",
+	"version": "15.1.1",
 	"author": "Atlassian Pty Ltd",
 	"license": "Apache-2.0",
 	"publishConfig": {