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

package/dist/es2019/rules/no-utility-icons/checks.js

@@ -1,177 +0,0 @@
-import { isNodeOfType } from 'eslint-codemod-utils';
-const specialCases = {
-  '@atlaskit/icon/utility/migration/cross--editor-close': '@atlaskit/icon/core/migration/cross--editor-close'
-};
-const iconPropsinNewButton = ['icon', 'iconBefore', 'iconAfter'];
-export const createChecks = context => {
-  const importStatementsUtility = {};
-  const importStatementsCore = {};
-  const newButtonImports = new Set();
-  const errors = {};
-
-  /**
-   * Gets the value of a boolean configuration flag
-   * @param key the key of the configuration flag
-   * @param defaultValue The default value of the configuration flag
-   * @returns defaultValue if the configuration flag is not set, the defaultValue of the configuration flag otherwise
-   */
-  const getConfigFlag = (key, defaultValue) => {
-    if (context.options && context.options.length > 0 && context.options[0] && context.options[0].hasOwnProperty(key)) {
-      return context.options[0][key] === !defaultValue ? !defaultValue : defaultValue;
-    }
-    return defaultValue;
-  };
-  const checkImportDeclarations = node => {
-    const moduleSource = node.source.value;
-    if (typeof moduleSource !== 'string') {
-      return;
-    }
-    if (moduleSource.startsWith('@atlaskit/icon/utility/')) {
-      for (const specifier of node.specifiers) {
-        if (specifier.type === 'ImportDefaultSpecifier') {
-          importStatementsUtility[specifier.local.name] = node;
-        }
-      }
-    } else if (moduleSource.startsWith('@atlaskit/icon/core/')) {
-      for (const specifier of node.specifiers) {
-        if (specifier.type === 'ImportDefaultSpecifier') {
-          importStatementsCore[moduleSource] = {
-            node,
-            localName: specifier.local.name
-          };
-        }
-      }
-    } else if (moduleSource.startsWith('@atlaskit/button/')) {
-      for (const specifier of node.specifiers) {
-        newButtonImports.add(specifier.local.name);
-      }
-    }
-  };
-  const checkJSXElement = node => {
-    if (!(isNodeOfType(node, 'JSXElement') && isNodeOfType(node.openingElement.name, 'JSXIdentifier') && importStatementsUtility.hasOwnProperty(node.openingElement.name.name) && typeof importStatementsUtility[node.openingElement.name.name].source.value === 'string')) {
-      return;
-    }
-    if (!errors.hasOwnProperty(node.openingElement.name.name)) {
-      errors[node.openingElement.name.name] = [];
-    }
-    errors[node.openingElement.name.name].push({
-      node,
-      messageId: 'noUtilityIconsJSXElement',
-      localName: node.openingElement.name.name,
-      fixable: true,
-      inNewButton: false
-    });
-  };
-
-  // Cases: As Props, In Function Calls, In Arrays, In Maps, In Exports
-  const checkIconReference = node => {
-    //if this is an import statement then exit early
-    if (node.parent && (isNodeOfType(node.parent, 'ImportSpecifier') || isNodeOfType(node.parent, 'ImportDefaultSpecifier'))) {
-      return;
-    }
-
-    //check the reference to see if it's a utility icon, if not exit early
-    if (!importStatementsUtility.hasOwnProperty(node.name)) {
-      return;
-    }
-
-    // if it is in new Button then we can fix it
-    if (node.parent && node.parent.parent && node.parent.parent.parent && isNodeOfType(node.parent, 'JSXExpressionContainer') && isNodeOfType(node.parent.parent, 'JSXAttribute') && isNodeOfType(node.parent.parent.name, 'JSXIdentifier') && iconPropsinNewButton.includes(node.parent.parent.name.name) && isNodeOfType(node.parent.parent.parent, 'JSXOpeningElement') && isNodeOfType(node.parent.parent.parent.name, 'JSXIdentifier') && newButtonImports.has(node.parent.parent.parent.name.name)) {
-      // if it is in new Button then we can fix it
-      if (!errors.hasOwnProperty(node.name)) {
-        errors[node.name] = [];
-      }
-      errors[node.name].push({
-        node,
-        messageId: 'noUtilityIconsReference',
-        localName: node.name,
-        fixable: true,
-        inNewButton: true
-      });
-      return;
-    }
-
-    // manually error
-    if (!errors.hasOwnProperty(node.name)) {
-      errors[node.name] = [];
-    }
-    errors[node.name].push({
-      node,
-      messageId: 'noUtilityIconsReference',
-      localName: node.name,
-      fixable: false,
-      inNewButton: false
-    });
-  };
-
-  /**
-   * Throws the relevant errors in the correct order.
-   */
-  const throwErrors = () => {
-    const shouldAutoFix = getConfigFlag('enableAutoFixer', false);
-    for (const utilityIcon of Object.keys(errors)) {
-      const allFixable = errors[utilityIcon].every(x => x.fixable); // Check if ALL errors for a giving import are fixable
-      const originalImportNode = importStatementsUtility[utilityIcon];
-      const oldImportName = importStatementsUtility[utilityIcon].source.value;
-      const newImportName = specialCases.hasOwnProperty(oldImportName) ? specialCases[oldImportName] : oldImportName.replace('@atlaskit/icon/utility/', '@atlaskit/icon/core/');
-      const existingImport = importStatementsCore.hasOwnProperty(newImportName) ? importStatementsCore[newImportName].localName : null;
-      let replacementImportName = existingImport ? existingImport : allFixable ? utilityIcon : `${utilityIcon}Core`;
-      let importFixAdded = false;
-      for (const [index, error] of errors[utilityIcon].entries()) {
-        if (error.fixable && shouldAutoFix) {
-          context.report({
-            node: error.node,
-            messageId: error.messageId,
-            fix: fixer => {
-              const fixes = [];
-
-              // Add a new import statement if it doesn't already exist
-              if (!existingImport && !importFixAdded) {
-                importFixAdded = true;
-                fixes.push(fixer.insertTextBefore(originalImportNode, `import ${replacementImportName} from '${newImportName}';\n`));
-              }
-
-              // Handle JSX elements differently if they are in a "new Button"
-              if (error.inNewButton) {
-                // Replace the icon with a function that wraps it with iconProps and size="small"
-                const wrappedIcon = `(iconProps) => <${replacementImportName} {...iconProps} size="small" />`;
-                fixes.push(fixer.replaceText(error.node, wrappedIcon));
-              } else if (isNodeOfType(error.node, 'JSXElement') && isNodeOfType(error.node.openingElement.name, 'JSXIdentifier')) {
-                // Replace the JSX element's closing tag with size="small"
-                const newOpeningElementText = context.sourceCode.getText(error.node.openingElement).replace(/\s*\/\s*>$/, ` size="small"\/>`).replace(new RegExp('<s*' + error.node.openingElement.name.name), `<${replacementImportName}`);
-                fixes.push(fixer.replaceText(error.node.openingElement, newOpeningElementText));
-              }
-
-              // Handle the first fixable error for import removal if all fixable for this import
-              if (index === 0 && allFixable) {
-                fixes.push(fixer.remove(originalImportNode));
-              }
-              return fixes;
-            }
-          });
-        } else {
-          // Report non-fixable errors
-          context.report({
-            node: error.node,
-            messageId: error.messageId
-          });
-        }
-      }
-    }
-
-    // If other utility icons are imported but there were no errors for them - (this should only be unused imports but good to have as a backup), report them
-    const otherUtilityImportsWithoutErrors = Object.keys(importStatementsUtility).filter(utilityIcon => !errors.hasOwnProperty(utilityIcon));
-    for (const utilityIcon of otherUtilityImportsWithoutErrors) {
-      context.report({
-        node: importStatementsUtility[utilityIcon],
-        messageId: 'noUtilityIconsImport'
-      });
-    }
-  };
-  return {
-    checkImportDeclarations,
-    checkJSXElement,
-    checkIconReference,
-    throwErrors
-  };
-};

package/dist/es2019/rules/no-utility-icons/index.js

@@ -1,44 +0,0 @@
-import { createLintRule } from '../utils/create-rule';
-import { createChecks } from './checks';
-const rule = createLintRule({
-  meta: {
-    name: 'no-utility-icons',
-    fixable: 'code',
-    hasSuggestions: true,
-    type: 'problem',
-    schema: [{
-      type: 'object',
-      properties: {
-        enableAutoFixer: {
-          type: 'boolean'
-        }
-      },
-      additionalProperties: false
-    }],
-    docs: {
-      description: 'Disallow use of deprecated utility icons, in favor of core icons with `size="small"`.',
-      recommended: true,
-      severity: 'warn'
-    },
-    messages: {
-      noUtilityIconsJSXElement: `Utility icons are deprecated. Please use core icons instead with the size prop set to small.`,
-      noUtilityIconsImport: `Utility icons are deprecated. Please do not import them, use core icons instead.`,
-      noUtilityIconsReference: `Utility icons are deprecated. To replace them, please use core icons with the size prop set to small instead.`
-    }
-  },
-  create(context) {
-    const {
-      checkImportDeclarations,
-      checkJSXElement,
-      checkIconReference,
-      throwErrors
-    } = createChecks(context);
-    return {
-      ImportDeclaration: checkImportDeclarations,
-      JSXElement: checkJSXElement,
-      Identifier: checkIconReference,
-      'Program:exit': throwErrors
-    };
-  }
-});
-export default rule;

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

@@ -1,326 +0,0 @@
-import { isNodeOfType } from 'eslint-codemod-utils';
-import { createLintRule } from '../utils/create-rule';
-var rule = 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 (!isNodeOfType(node, 'JSXElement')) {
-          return;
-        }
-        if (!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);
-            }
-          });
-        }
-      }
-    };
-  }
-});
-export default rule;