@atlaskit/eslint-plugin-design-system 13.30.1 → 13.32.0

package/dist/esm/rules/no-placeholder/index.js

@@ -0,0 +1,154 @@
+import { isNodeOfType } from 'eslint-codemod-utils';
+import * as ast from '../../ast-nodes';
+import { createLintRule } from '../utils/create-rule';
+export var AFFECTED_HTML_ELEMENTS = ['input', 'textarea'];
+export var AFFECTED_ATLASKIT_PACKAGES = {
+  '@atlaskit/datetime-picker': ['DatePicker', 'TimePicker', 'DateTimePicker'],
+  '@atlaskit/select': ['default', 'AsyncCreatableSelect', 'CheckboxSelect', 'CountrySelect', 'CreatableSelect', 'PopupSelect', 'RadioSelect'],
+  '@atlaskit/textarea': ['default'],
+  '@atlaskit/textfield': ['default']
+};
+export var ATLASKIT_FORM_PACKAGE = '@atlaskit/form';
+export var ATLASKIT_FIELD_IMPORT = 'Field';
+var rule = createLintRule({
+  meta: {
+    name: 'no-placeholder',
+    type: 'problem',
+    docs: {
+      description: 'Placeholders should not be used. If information should be given to the user about the proper type or formatting of a value, this should be included using a helper message that is associated to the input instead.',
+      recommended: true,
+      severity: 'warn'
+    },
+    messages: {
+      noPlaceholder: 'Placeholders should not be used. Use separate information to help users associated using `aria-describedby` instead.',
+      noPlaceholderOnSimpleField: 'Placeholders should not be used. Use the `helperMessage` prop instead.',
+      noPlaceholderOnComplexField: 'Placeholders should not be used. Use the `HelperMessage` component instead.'
+    }
+  },
+  create: function create(context) {
+    var hasFieldImport = false;
+    var fieldLocalName = null;
+    var localComponentNames = [];
+    return {
+      ImportDeclaration: function ImportDeclaration(node) {
+        var source = node.source.value;
+        if (typeof source !== 'string') {
+          return;
+        }
+
+        // Ignore non-atlaskit input/form packages
+        if (!Object.keys(AFFECTED_ATLASKIT_PACKAGES).includes(source) && ATLASKIT_FORM_PACKAGE !== source) {
+          return;
+        }
+        if (!node.specifiers.length) {
+          return;
+        }
+        var defaultImport = node.specifiers.filter(function (spec) {
+          return spec.type === 'ImportDefaultSpecifier';
+        });
+        var namedImport = node.specifiers.filter(function (spec) {
+          return spec.type === 'ImportSpecifier';
+        });
+        if (source === ATLASKIT_FORM_PACKAGE) {
+          if (namedImport.length && namedImport[0].type === 'ImportSpecifier' && 'name' in namedImport[0].imported && namedImport[0].imported.name === ATLASKIT_FIELD_IMPORT) {
+            hasFieldImport = true;
+            fieldLocalName = namedImport[0].local.name;
+          }
+        } else {
+          var importNames = AFFECTED_ATLASKIT_PACKAGES[source];
+          var usesDefaultImport = importNames.includes('default');
+          var possibleNamedImports = importNames.filter(function (importName) {
+            return importName !== 'default';
+          });
+          if (usesDefaultImport && defaultImport.length && defaultImport[0].local) {
+            localComponentNames.push(defaultImport[0].local.name);
+            // or if popup and using a named import
+          } else if (possibleNamedImports.length >= 1 && namedImport.length) {
+            namedImport.forEach(function (imp) {
+              if (imp.type === 'ImportSpecifier' && 'name' in imp.imported && possibleNamedImports.includes(imp.imported.name)) {
+                localComponentNames.push(imp.local.name);
+              }
+            });
+          }
+        }
+      },
+      JSXElement: function JSXElement(node) {
+        if (!isNodeOfType(node, 'JSXElement')) {
+          return false;
+        }
+        var elName = ast.JSXElement.getName(node);
+        if (!elName) {
+          return false;
+        }
+
+        // If it is one of the affected native HTML elements
+        if (AFFECTED_HTML_ELEMENTS.includes(elName)) {
+          // if has a placeholder attribute
+          var hasPlaceholderAttribute = node.openingElement.attributes.find(function (attr) {
+            return isNodeOfType(attr, 'JSXAttribute') && attr.name.name === 'placeholder';
+          });
+          if (hasPlaceholderAttribute) {
+            return context.report({
+              node: node.openingElement,
+              messageId: 'noPlaceholder'
+            });
+          }
+          // Else, it is a React component
+        } else {
+          // if none of the affected packages is imported, return
+          if (localComponentNames.length === 0) {
+            return;
+          }
+          // if component name is not in the list, exit
+          if (!isNodeOfType(node.openingElement.name, 'JSXIdentifier') || !localComponentNames.includes(node.openingElement.name.name)) {
+            return;
+          }
+          if (hasFieldImport && fieldLocalName) {
+            var _node = node;
+            var hasParentField = false;
+            var fieldType = 'Complex';
+            // If node is a Field element or if
+            while (isNodeOfType(_node, 'JSXElement') && isNodeOfType(_node.openingElement.name, 'JSXIdentifier') && !hasParentField) {
+              var name = _node.openingElement.name.name;
+              hasParentField = hasParentField || name === fieldLocalName;
+              _node = _node.parent;
+              // Skip up until a JSXElement or JSXAttribute is reached
+              if (isNodeOfType(_node, 'JSXFragment') || isNodeOfType(_node, 'ArrowFunctionExpression') || isNodeOfType(_node, 'JSXExpressionContainer') || isNodeOfType(_node, 'JSXAttribute')) {
+                while (_node && !isNodeOfType(_node, 'JSXElement') && !isNodeOfType(_node, 'Program')) {
+                  if (isNodeOfType(_node, 'JSXAttribute')) {
+                    fieldType = 'Simple';
+                  }
+                  _node = _node.parent;
+                }
+              }
+            }
+            if (hasParentField) {
+              // if has a placeholder attribute
+              var _hasPlaceholderAttribute = node.openingElement.attributes.find(function (attr) {
+                return isNodeOfType(attr, 'JSXAttribute') && attr.name.name === 'placeholder';
+              });
+              if (_hasPlaceholderAttribute) {
+                return context.report({
+                  node: node.openingElement,
+                  messageId: "noPlaceholderOn".concat(fieldType, "Field")
+                });
+              }
+            }
+          } else {
+            // if has a placeholder attribute
+            var _hasPlaceholderAttribute2 = node.openingElement.attributes.find(function (attr) {
+              return isNodeOfType(attr, 'JSXAttribute') && attr.name.name === 'placeholder';
+            });
+            if (_hasPlaceholderAttribute2) {
+              return context.report({
+                node: node.openingElement,
+                messageId: 'noPlaceholder'
+              });
+            }
+          }
+        }
+      }
+    };
+  }
+});
+export default rule;

package/dist/types/presets/all-flat.codegen.d.ts

@@ -1,6 +1,6 @@
 /**
  * THIS FILE WAS CREATED VIA CODEGEN DO NOT MODIFY {@see http://go/af-codegen}
- * @codegen <<SignedSource::131350ebc877f42247042c6e7327fe18>>
+ * @codegen <<SignedSource::4fa72535ce2bc0a19a6fb01c951150db>>
  * @codegenCommand yarn workspace @atlaskit/eslint-plugin-design-system codegen
  */
 import type { Linter } from 'eslint';

package/dist/types/presets/all.codegen.d.ts

@@ -1,6 +1,6 @@
 /**
  * THIS FILE WAS CREATED VIA CODEGEN DO NOT MODIFY {@see http://go/af-codegen}
- * @codegen <<SignedSource::b3ddf9ee0a27aaf8a318a6579d48ce99>>
+ * @codegen <<SignedSource::dcf6bf4496c97fd6ad4c1d8d65337a6b>>
  * @codegenCommand yarn workspace @atlaskit/eslint-plugin-design-system codegen
  */
 import type { ESLint } from 'eslint';

package/dist/types/presets/recommended-flat.codegen.d.ts

@@ -1,6 +1,6 @@
 /**
  * THIS FILE WAS CREATED VIA CODEGEN DO NOT MODIFY {@see http://go/af-codegen}
- * @codegen <<SignedSource::ba71ef89188bdc20d0ec948cc00f6436>>
+ * @codegen <<SignedSource::27c9a3631c47b134bfb9da3e921e0601>>
  * @codegenCommand yarn workspace @atlaskit/eslint-plugin-design-system codegen
  */
 import type { Linter } from 'eslint';

package/dist/types/presets/recommended.codegen.d.ts

@@ -1,6 +1,6 @@
 /**
  * THIS FILE WAS CREATED VIA CODEGEN DO NOT MODIFY {@see http://go/af-codegen}
- * @codegen <<SignedSource::5c119e0ab08e1f39d471b2b827bbb4de>>
+ * @codegen <<SignedSource::52a31bc6cdeb7a9818a0e225d21c88f2>>
  * @codegenCommand yarn workspace @atlaskit/eslint-plugin-design-system codegen
  */
 import type { ESLint } from 'eslint';

package/dist/types/rules/index.codegen.d.ts

@@ -1,6 +1,6 @@
 /**
  * THIS FILE WAS CREATED VIA CODEGEN DO NOT MODIFY {@see http://go/af-codegen}
- * @codegen <<SignedSource::02be73e0813b6f22038f0f3f2ad6865d>>
+ * @codegen <<SignedSource::ca89575f70ae79af2f43113bdc77c0c5>>
  * @codegenCommand yarn workspace @atlaskit/eslint-plugin-design-system codegen
  */
 import type { Rule } from 'eslint';

package/dist/types/rules/no-placeholder/index.d.ts

@@ -0,0 +1,6 @@
+export declare const AFFECTED_HTML_ELEMENTS: string[];
+export declare const AFFECTED_ATLASKIT_PACKAGES: Record<string, string[]>;
+export declare const ATLASKIT_FORM_PACKAGE = "@atlaskit/form";
+export declare const ATLASKIT_FIELD_IMPORT = "Field";
+declare const rule: import("eslint").Rule.RuleModule;
+export default rule;

package/dist/types-ts4.5/presets/all-flat.codegen.d.ts

@@ -1,6 +1,6 @@
 /**
  * THIS FILE WAS CREATED VIA CODEGEN DO NOT MODIFY {@see http://go/af-codegen}
- * @codegen <<SignedSource::131350ebc877f42247042c6e7327fe18>>
+ * @codegen <<SignedSource::4fa72535ce2bc0a19a6fb01c951150db>>
  * @codegenCommand yarn workspace @atlaskit/eslint-plugin-design-system codegen
  */
 import type { Linter } from 'eslint';

package/dist/types-ts4.5/presets/all.codegen.d.ts

@@ -1,6 +1,6 @@
 /**
  * THIS FILE WAS CREATED VIA CODEGEN DO NOT MODIFY {@see http://go/af-codegen}
- * @codegen <<SignedSource::b3ddf9ee0a27aaf8a318a6579d48ce99>>
+ * @codegen <<SignedSource::dcf6bf4496c97fd6ad4c1d8d65337a6b>>
  * @codegenCommand yarn workspace @atlaskit/eslint-plugin-design-system codegen
  */
 import type { ESLint } from 'eslint';

package/dist/types-ts4.5/presets/recommended-flat.codegen.d.ts

@@ -1,6 +1,6 @@
 /**
  * THIS FILE WAS CREATED VIA CODEGEN DO NOT MODIFY {@see http://go/af-codegen}
- * @codegen <<SignedSource::ba71ef89188bdc20d0ec948cc00f6436>>
+ * @codegen <<SignedSource::27c9a3631c47b134bfb9da3e921e0601>>
  * @codegenCommand yarn workspace @atlaskit/eslint-plugin-design-system codegen
  */
 import type { Linter } from 'eslint';

package/dist/types-ts4.5/presets/recommended.codegen.d.ts

@@ -1,6 +1,6 @@
 /**
  * THIS FILE WAS CREATED VIA CODEGEN DO NOT MODIFY {@see http://go/af-codegen}
- * @codegen <<SignedSource::5c119e0ab08e1f39d471b2b827bbb4de>>
+ * @codegen <<SignedSource::52a31bc6cdeb7a9818a0e225d21c88f2>>
  * @codegenCommand yarn workspace @atlaskit/eslint-plugin-design-system codegen
  */
 import type { ESLint } from 'eslint';

package/dist/types-ts4.5/rules/index.codegen.d.ts

@@ -1,6 +1,6 @@
 /**
  * THIS FILE WAS CREATED VIA CODEGEN DO NOT MODIFY {@see http://go/af-codegen}
- * @codegen <<SignedSource::02be73e0813b6f22038f0f3f2ad6865d>>
+ * @codegen <<SignedSource::ca89575f70ae79af2f43113bdc77c0c5>>
  * @codegenCommand yarn workspace @atlaskit/eslint-plugin-design-system codegen
  */
 import type { Rule } from 'eslint';

package/dist/types-ts4.5/rules/no-placeholder/index.d.ts

@@ -0,0 +1,6 @@
+export declare const AFFECTED_HTML_ELEMENTS: string[];
+export declare const AFFECTED_ATLASKIT_PACKAGES: Record<string, string[]>;
+export declare const ATLASKIT_FORM_PACKAGE = "@atlaskit/form";
+export declare const ATLASKIT_FIELD_IMPORT = "Field";
+declare const rule: import("eslint").Rule.RuleModule;
+export default rule;

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": "13.30.1",
+	"version": "13.32.0",
 	"author": "Atlassian Pty Ltd",
 	"license": "Apache-2.0",
 	"publishConfig": {
@@ -40,7 +40,7 @@
 	"dependencies": {
 		"@atlaskit/eslint-utils": "^2.0.0",
 		"@atlaskit/icon": "^29.4.0",
-		"@atlaskit/icon-lab": "^5.13.0",
+		"@atlaskit/icon-lab": "^5.14.0",
 		"@atlaskit/tokens": "^9.1.0",
 		"@babel/runtime": "^7.0.0",
 		"@typescript-eslint/utils": "^7.1.0",

package/dist/cjs/rules/lozenge-isBold-and-lozenge-badge-appearance-migration/index.js

@@ -1,332 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = void 0;
-var _eslintCodemodUtils = require("eslint-codemod-utils");
-var _createRule = require("../utils/create-rule");
-var rule = (0, _createRule.createLintRule)({
-  meta: {
-    name: 'lozenge-isBold-and-lozenge-badge-appearance-migration',
-    fixable: 'code',
-    type: 'suggestion',
-    docs: {
-      description: 'Helps migrate Lozenge isBold prop and appearance values (for both Lozenge and Badge components) as part of the Labelling System Phase 1 migration.',
-      recommended: false,
-      severity: 'warn'
-    },
-    messages: {
-      updateAppearance: 'Update appearance value to new semantic value.',
-      migrateTag: 'Non-bold <Lozenge> variants should migrate to <Tag> component.',
-      manualReview: "Dynamic 'isBold' props require manual review before migration.",
-      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.'
-    }
-  },
-  create: function create(context) {
-    /**
-     * Contains a map of imported Lozenge components.
-     */
-    var lozengeImports = {}; // local name -> import source
-
-    /**
-     * Contains a map of imported Badge components.
-     */
-    var badgeImports = {}; // local name -> import source
-
-    /**
-     * 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.)
-     */
-    function isDynamicExpression(node) {
-      if (!node) {
-        return false;
-      }
-
-      // If it's a plain literal (e.g., appearance="value"), it's not dynamic
-      if (node.type === 'Literal') {
-        return false;
-      }
-
-      // If it's an expression container with a non-literal expression, it's dynamic
-      if (node.type === 'JSXExpressionContainer') {
-        var expr = node.expression;
-        return expr && expr.type !== 'Literal';
-      }
-      return false;
-    }
-
-    /**
-     * Get all attributes as an object for easier manipulation
-     */
-    function getAttributesMap(attributes) {
-      var map = {};
-      attributes.forEach(function (attr) {
-        if (attr.type === 'JSXAttribute' && attr.name.type === 'JSXIdentifier') {
-          map[attr.name.name] = attr;
-        }
-      });
-      return map;
-    }
-
-    /**
-     * Map old appearance values to new semantic appearance values
-     * Both Lozenge and Tag now use the same appearance prop with new semantic values
-     */
-    function mapToNewAppearanceValue(oldValue) {
-      var mapping = {
-        success: 'success',
-        default: 'default',
-        removed: 'removed',
-        inprogress: 'inprogress',
-        new: 'new',
-        moved: 'moved'
-      };
-      // TODO: Update this mapping based on actual new semantic values when provided
-      return mapping[oldValue] || oldValue;
-    }
-
-    /**
-     * Map Badge old appearance values to new semantic appearance values
-     */
-    function mapBadgeToNewAppearanceValue(oldValue) {
-      var mapping = {
-        added: 'success',
-        removed: 'danger',
-        default: 'neutral',
-        primary: 'information',
-        primaryInverted: 'inverse',
-        important: 'danger'
-      };
-      return mapping[oldValue] || oldValue;
-    }
-
-    /**
-     * Extract the string value from a JSX attribute value
-     */
-    function extractStringValue(attrValue) {
-      if (!attrValue) {
-        return null;
-      }
-      if (attrValue.type === 'Literal') {
-        return attrValue.value;
-      }
-      if (attrValue.type === 'JSXExpressionContainer' && attrValue.expression && attrValue.expression.type === 'Literal') {
-        return attrValue.expression.value;
-      }
-      return null;
-    }
-
-    /**
-     * Create a fixer function to replace an appearance prop value
-     * Handles both Literal and JSXExpressionContainer with Literal
-     */
-    function createAppearanceFixer(attrValue, newValue) {
-      return function (fixer) {
-        if (!attrValue) {
-          return null;
-        }
-        if (attrValue.type === 'Literal') {
-          return fixer.replaceText(attrValue, "\"".concat(newValue, "\""));
-        }
-        if (attrValue.type === 'JSXExpressionContainer' && 'expression' in attrValue && attrValue.expression && attrValue.expression.type === 'Literal') {
-          return fixer.replaceText(attrValue.expression, "\"".concat(newValue, "\""));
-        }
-        return null;
-      };
-    }
-
-    /**
-     * Generate the replacement JSX element text
-     */
-    function generateTagReplacement(node) {
-      var sourceCode = context.getSourceCode();
-      var attributes = node.openingElement.attributes;
-
-      // Build new attributes array, excluding isBold and mapping appearance values to new semantics
-      var newAttributes = [];
-      attributes.forEach(function (attr) {
-        if (attr.type === 'JSXAttribute' && attr.name.type === 'JSXIdentifier') {
-          var attrName = attr.name.name;
-          if (attrName === 'isBold') {
-            // Skip isBold attribute
-            return;
-          }
-          if (attrName === 'appearance') {
-            // Map appearance value to new semantic value but keep the prop name as appearance
-            var stringValue = extractStringValue(attr.value);
-            if (stringValue && typeof stringValue === 'string') {
-              var mappedAppearance = mapToNewAppearanceValue(stringValue);
-              newAttributes.push("appearance=\"".concat(mappedAppearance, "\""));
-            } else {
-              // If we can't extract the string value, keep as-is with appearance prop
-              var value = attr.value ? sourceCode.getText(attr.value) : '';
-              newAttributes.push("appearance".concat(value ? "=".concat(value) : ''));
-            }
-            return;
-          }
-
-          // Keep all other attributes
-          newAttributes.push(sourceCode.getText(attr));
-        } else if (attr.type === 'JSXSpreadAttribute') {
-          // Keep spread attributes
-          newAttributes.push(sourceCode.getText(attr));
-        }
-      });
-      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]) : '';
-      if (node.closingElement) {
-        return "<Tag".concat(attributesText, ">").concat(children, "</Tag>");
-      } else {
-        return "<Tag".concat(attributesText, " />");
-      }
-    }
-    return {
-      ImportDeclaration: function ImportDeclaration(node) {
-        var moduleSource = node.source.value;
-        if (typeof moduleSource === 'string') {
-          // Track Lozenge imports
-          if (moduleSource === '@atlaskit/lozenge' || moduleSource.startsWith('@atlaskit/lozenge')) {
-            node.specifiers.forEach(function (spec) {
-              if (spec.type === 'ImportDefaultSpecifier') {
-                lozengeImports[spec.local.name] = moduleSource;
-              } else if (spec.type === 'ImportSpecifier' && spec.imported.type === 'Identifier') {
-                if (spec.imported.name === 'Lozenge') {
-                  lozengeImports[spec.local.name] = moduleSource;
-                }
-              }
-            });
-          }
-          // Track Badge imports
-          if (moduleSource === '@atlaskit/badge' || moduleSource.startsWith('@atlaskit/badge')) {
-            node.specifiers.forEach(function (spec) {
-              if (spec.type === 'ImportDefaultSpecifier') {
-                badgeImports[spec.local.name] = moduleSource;
-              } else if (spec.type === 'ImportSpecifier' && spec.imported.type === 'Identifier') {
-                if (spec.imported.name === 'Badge' || spec.imported.name === 'default') {
-                  badgeImports[spec.local.name] = moduleSource;
-                }
-              }
-            });
-          }
-        }
-      },
-      JSXElement: function JSXElement(node) {
-        if (!(0, _eslintCodemodUtils.isNodeOfType)(node, 'JSXElement')) {
-          return;
-        }
-        if (!(0, _eslintCodemodUtils.isNodeOfType)(node.openingElement.name, 'JSXIdentifier')) {
-          return;
-        }
-        var elementName = node.openingElement.name.name;
-
-        // Handle Badge components
-        if (badgeImports[elementName]) {
-          // Find the appearance prop
-          var _appearanceProp = node.openingElement.attributes.find(function (attr) {
-            return attr.type === 'JSXAttribute' && attr.name.type === 'JSXIdentifier' && attr.name.name === 'appearance';
-          });
-          if (!_appearanceProp || _appearanceProp.type !== 'JSXAttribute') {
-            // No appearance prop or it's a spread attribute, nothing to migrate
-            return;
-          }
-
-          // Check if it's a dynamic expression
-          if (isDynamicExpression(_appearanceProp.value)) {
-            context.report({
-              node: _appearanceProp,
-              messageId: 'dynamicBadgeAppearance'
-            });
-            return;
-          }
-
-          // Extract the string value
-          var stringValue = extractStringValue(_appearanceProp.value);
-          if (stringValue && typeof stringValue === 'string') {
-            var mappedValue = mapBadgeToNewAppearanceValue(stringValue);
-            if (mappedValue !== stringValue) {
-              context.report({
-                node: _appearanceProp,
-                messageId: 'updateBadgeAppearance',
-                data: {
-                  oldValue: stringValue,
-                  newValue: mappedValue
-                },
-                fix: createAppearanceFixer(_appearanceProp.value, mappedValue)
-              });
-            }
-          }
-          return;
-        }
-
-        // Only process if this is a Lozenge component we've imported
-        if (!lozengeImports[elementName]) {
-          return;
-        }
-        var attributesMap = getAttributesMap(node.openingElement.attributes);
-        var appearanceProp = attributesMap.appearance;
-        var isBoldProp = attributesMap.isBold;
-
-        // Handle appearance prop value migration
-        if (appearanceProp) {
-          var shouldMigrateToTag = !isBoldProp || isLiteralFalse(isBoldProp.value);
-          if (!shouldMigrateToTag) {
-            // Only update appearance values for Lozenge components that stay as Lozenge
-            var _stringValue = extractStringValue(appearanceProp.value);
-            if (_stringValue && typeof _stringValue === 'string') {
-              var _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
-            context.report({
-              node: node,
-              messageId: 'migrateTag',
-              fix: function fix(fixer) {
-                var replacement = generateTagReplacement(node);
-                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
-          context.report({
-            node: node,
-            messageId: 'migrateTag',
-            fix: function fix(fixer) {
-              var replacement = generateTagReplacement(node);
-              return fixer.replaceText(node, replacement);
-            }
-          });
-        }
-      }
-    };
-  }
-});
-var _default = exports.default = rule;