@atlaskit/eslint-plugin-design-system 10.16.0 → 10.17.0

package/dist/esm/rules/no-legacy-icons/helpers.js

@@ -1,5 +1,5 @@
 import _slicedToArray from "@babel/runtime/helpers/slicedToArray";
-import { isNodeOfType } from 'eslint-codemod-utils';
+import { isNodeOfType, literal } from 'eslint-codemod-utils';
 import baseMigrationMap, { migrationOutcomeDescriptionMap } from '@atlaskit/icon/UNSAFE_migration-map';
 import { getImportName } from '../utils/get-import-name';
 import { upcomingIcons } from './upcoming-icons';
@@ -53,12 +53,33 @@ export var canAutoMigrateNewIconBasedOnSize = function canAutoMigrateNewIconBase
   return ['swap', 'swap-slight-visual-change', 'swap-visual-change', 'swap-size-shift-utility'].includes(guidance || '');
 };
 
+/**
+ *
+ * @param iconPackage string
+ * @returns object of new icon name and import path
+ */
+export var getNewIconNameAndImportPath = function getNewIconNameAndImportPath(iconPackage, shouldUseMigrationPath) {
+  var legacyIconName = getIconKey(iconPackage);
+  var migrationMapObject = getMigrationMapObject(iconPackage);
+  if (!migrationMapObject || !migrationMapObject.newIcon) {
+    return {};
+  }
+  var newIcon = migrationMapObject.newIcon;
+  var migrationPath = newIcon.name === legacyIconName ? "".concat(newIcon.package, "/").concat(newIcon.type, "/migration/").concat(newIcon.name) : "".concat(newIcon.package, "/").concat(newIcon.type, "/migration/").concat(newIcon.name, "--").concat(legacyIconName.replaceAll('/', '-'));
+  return {
+    iconName: newIcon.name,
+    importPath: shouldUseMigrationPath ? migrationPath : "".concat(newIcon.package, "/").concat(newIcon.type, "/").concat(newIcon.name)
+  };
+};
+
 /**
  * Creates the written guidance for migrating a legacy icon to a new icon
  */
-export var createGuidance = function createGuidance(iconPackage) {
-  var insideNewButton = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
-  var size = arguments.length > 2 ? arguments[2] : undefined;
+export var createGuidance = function createGuidance(_ref) {
+  var iconPackage = _ref.iconPackage,
+    insideNewButton = _ref.insideNewButton,
+    size = _ref.size,
+    shouldUseMigrationPath = _ref.shouldUseMigrationPath;
   var migrationMapObject = getMigrationMapObject(iconPackage);
   var upcomingIcon = getUpcomingIcons(iconPackage);
   if (upcomingIcon) {
@@ -90,21 +111,24 @@ export var createGuidance = function createGuidance(iconPackage) {
     if (!newIcon) {
       return 'No equivalent icon in new set. An option is to contribute a custom icon into icon-labs package instead.\n';
     }
+    var _getNewIconNameAndImp = getNewIconNameAndImportPath(iconPackage, shouldUseMigrationPath),
+      iconName = _getNewIconNameAndImp.iconName,
+      importPath = _getNewIconNameAndImp.importPath;
     var buttonGuidanceStr = "Please set 'spacing' property of the new icon to 'none', to ensure appropriate spacing inside `@atlaskit/button`.\n";
     var _guidance = '';
     if (size) {
       if (migrationMapObject.sizeGuidance[size] && canAutoMigrateNewIconBasedOnSize(migrationMapObject.sizeGuidance[size])) {
-        _guidance += "Fix: Use ".concat(newIcon.name, " from ").concat(newIcon.package, "/").concat(newIcon.type, "/").concat(newIcon.name, " instead.");
+        _guidance += "Fix: Use ".concat(iconName, " from ").concat(importPath, " instead.");
       } else {
         _guidance += "No equivalent icon for this size, ".concat(size, ", in new set.");
       }
       _guidance += "".concat(Object.keys(migrationOutcomeDescriptionMap).includes(migrationMapObject.sizeGuidance[size]) ? " Please: ".concat(migrationOutcomeDescriptionMap[migrationMapObject.sizeGuidance[size]]) : ' No migration size advice given.', "\n");
     } else {
-      _guidance = "Use ".concat(newIcon.name, " from ").concat(newIcon.package, "/").concat(newIcon.type, "/").concat(newIcon.name, " instead.\nMigration suggestions, depending on the legacy icon size:\n");
-      Object.entries(migrationMapObject.sizeGuidance).forEach(function (_ref) {
-        var _ref2 = _slicedToArray(_ref, 2),
-          size = _ref2[0],
-          value = _ref2[1];
+      _guidance = "Use ".concat(iconName, " from ").concat(importPath, " instead.\nMigration suggestions, depending on the legacy icon size:\n");
+      Object.entries(migrationMapObject.sizeGuidance).forEach(function (_ref2) {
+        var _ref3 = _slicedToArray(_ref2, 2),
+          size = _ref3[0],
+          value = _ref3[1];
         _guidance += "\t- ".concat(size, ": ");
         if (!Object.keys(migrationOutcomeDescriptionMap).includes(value)) {
           _guidance += 'No migration advice given.\n';
@@ -234,13 +258,22 @@ export var createCantMigrateSizeUnknown = function createCantMigrateSizeUnknown(
   };
   pushManualError(locToString(node), errors, myError, importSource, iconName);
 };
-export var createAutoMigrationError = function createAutoMigrationError(node, importSource, iconName, errors) {
+export var createAutoMigrationError = function createAutoMigrationError(_ref4) {
+  var node = _ref4.node,
+    importSource = _ref4.importSource,
+    iconName = _ref4.iconName,
+    errors = _ref4.errors,
+    shouldAddSpaciousSpacing = _ref4.shouldAddSpaciousSpacing,
+    insideNewButton = _ref4.insideNewButton;
   var myError = {
     node: node,
     messageId: 'noLegacyIconsAutoMigration',
     data: {
       importSource: importSource,
-      iconName: iconName
+      iconName: iconName,
+      spacing: shouldAddSpaciousSpacing ? 'spacious' : '',
+      // value type need to be a string in Rule.ReportDescriptor
+      insideNewButton: String(insideNewButton)
     }
   };
   errors[locToString(node)] = myError;
@@ -304,9 +337,9 @@ export var createHelpers = function createHelpers(context) {
      * Extracts the primaryColor value from a JSXAttribute
      */
     getPrimaryColor: function getPrimaryColor(attr) {
-      var _ref3, _getLiteralStringValu;
+      var _ref5, _getLiteralStringValu;
       var value = attr.value;
-      return (_ref3 = (_getLiteralStringValu = getLiteralStringValue(value)) !== null && _getLiteralStringValu !== void 0 ? _getLiteralStringValu : getTokenCallValue(value)) !== null && _ref3 !== void 0 ? _ref3 : null;
+      return (_ref5 = (_getLiteralStringValu = getLiteralStringValue(value)) !== null && _getLiteralStringValu !== void 0 ? _getLiteralStringValu : getTokenCallValue(value)) !== null && _ref5 !== void 0 ? _ref5 : null;
     },
     getTokenCallValue: getTokenCallValue,
     getConfigFlag: getConfigFlag
@@ -329,4 +362,171 @@ export var isInRangeList = function isInRangeList(node, sortedListOfRangesForErr
     return range[0] >= currRange.start && range[1] <= currRange.end;
   });
   return !!found;
+};
+
+/**
+ *
+ * @param node Icon JSXelement
+ * @param newButtonImports list of new button import specifiers
+ * @returns if Icon is inside a new button
+ */
+export var isInsideNewButton = function isInsideNewButton(node, newButtonImports) {
+  var _node$parent, _node$parent2;
+  var insideNewButton = false;
+  if (node.parent && isNodeOfType(node.parent, 'ArrowFunctionExpression') && (_node$parent = node.parent) !== null && _node$parent !== void 0 && (_node$parent = _node$parent.parent) !== null && _node$parent !== void 0 && _node$parent.parent && isNodeOfType(node.parent.parent.parent, 'JSXAttribute') && isNodeOfType(node.parent.parent.parent.name, 'JSXIdentifier') && (_node$parent2 = node.parent) !== null && _node$parent2 !== void 0 && (_node$parent2 = _node$parent2.parent) !== null && _node$parent2 !== void 0 && (_node$parent2 = _node$parent2.parent) !== null && _node$parent2 !== void 0 && _node$parent2.parent && isNodeOfType(node.parent.parent.parent.parent, 'JSXOpeningElement') && isNodeOfType(node.parent.parent.parent.parent.name, 'JSXIdentifier') && newButtonImports.has(node.parent.parent.parent.parent.name.name)) {
+    insideNewButton = true;
+  }
+  return insideNewButton;
+};
+
+/**
+ *
+ * @param node Icon JSXelement
+ * @param newButtonImports list of legacy button import specifiers
+ * @returns if Icon is inside a legacy button
+ */
+export var isInsideLegacyButton = function isInsideLegacyButton(node, legacyButtonImports) {
+  var _node$parent3, _node$parent4, _node$parent5, _node$parent6;
+  var insideLegacyButton = false;
+  if (node.parent && isNodeOfType(node.parent, 'JSXExpressionContainer') && (_node$parent3 = node.parent) !== null && _node$parent3 !== void 0 && _node$parent3.parent && isNodeOfType(node.parent.parent, 'JSXAttribute') && (node.parent.parent.name.name === 'iconBefore' || node.parent.parent.name.name === 'iconAfter') && isNodeOfType((_node$parent4 = node.parent) === null || _node$parent4 === void 0 || (_node$parent4 = _node$parent4.parent) === null || _node$parent4 === void 0 ? void 0 : _node$parent4.parent, 'JSXOpeningElement') && isNodeOfType((_node$parent5 = node.parent) === null || _node$parent5 === void 0 || (_node$parent5 = _node$parent5.parent) === null || _node$parent5 === void 0 ? void 0 : _node$parent5.parent.name, 'JSXIdentifier') && legacyButtonImports.has((_node$parent6 = node.parent) === null || _node$parent6 === void 0 || (_node$parent6 = _node$parent6.parent) === null || _node$parent6 === void 0 ? void 0 : _node$parent6.parent.name.name)) {
+    insideLegacyButton = true;
+  }
+  return insideLegacyButton;
+};
+var findProp = function findProp(attributes, propName) {
+  return attributes.find(function (attr) {
+    return attr.type === 'JSXAttribute' && attr.name.name === propName;
+  });
+};
+
+/**
+ *
+ * Creates a list of fixers to update the icon import path
+ * @param metadata Metadata including the import source and spacing
+ * @param fixer The original fix function
+ * @param legacyImportNode The import declaration node to replace
+ * @param shouldUseMigrationPath The eslint rule config, whether to use migration entrypoint or not
+ * @param migrationImportNode The migration import declaration node to replace, only present if shouldUseMigrationPath is false
+ * @returns A list of fixers to migrate the icon
+ */
+export var createImportFix = function createImportFix(_ref6) {
+  var fixer = _ref6.fixer,
+    legacyImportNode = _ref6.legacyImportNode,
+    metadata = _ref6.metadata,
+    shouldUseMigrationPath = _ref6.shouldUseMigrationPath,
+    migrationImportNode = _ref6.migrationImportNode;
+  var fixes = [];
+  var importSource = metadata.importSource;
+  var importPath = migrationImportNode ? importSource.replace('/migration', '').split('--')[0] : getNewIconNameAndImportPath(importSource, shouldUseMigrationPath).importPath;
+
+  // replace old icon import with icon import
+  if (legacyImportNode && importPath) {
+    fixes.push(fixer.replaceText(legacyImportNode.source, "'".concat(literal(importPath), "'")));
+  }
+  if (migrationImportNode && !shouldUseMigrationPath && importPath) {
+    fixes.push(fixer.replaceText(migrationImportNode.source, "'".concat(literal(importPath), "'")));
+  }
+  return fixes;
+};
+
+/**
+ * Creates a list of fixers to update the icon props
+ * @param node The Icon element to migrate
+ * @param metadata Metadata including the import source and spacing
+ * @param fixer The original fix function
+ * @param legacyImportNode The import declaration node to replace
+ * @param shouldUseMigrationPath The eslint rule config, whether to use migration entrypoint or not
+ * @param migrationImportNode The migration import declaration node to replace, only present if shouldUseMigrationPath is false
+ * @returns A list of fixers to migrate the icon
+ */
+export var createPropFixes = function createPropFixes(_ref7) {
+  var node = _ref7.node,
+    fixer = _ref7.fixer,
+    legacyImportNode = _ref7.legacyImportNode,
+    metadata = _ref7.metadata,
+    shouldUseMigrationPath = _ref7.shouldUseMigrationPath,
+    migrationImportNode = _ref7.migrationImportNode;
+  var fixes = [];
+  var importSource = metadata.importSource,
+    spacing = metadata.spacing,
+    insideNewButton = metadata.insideNewButton;
+  if (shouldUseMigrationPath && !legacyImportNode) {
+    return fixes;
+  }
+  var importPath = migrationImportNode ? importSource.replace('/migration', '').split('--')[0] : getNewIconNameAndImportPath(importSource, shouldUseMigrationPath).importPath;
+  var iconType = importPath !== null && importPath !== void 0 && importPath.startsWith('@atlaskit/icon/core') ? 'core' : 'utility';
+  if (node.type === 'JSXElement') {
+    var openingElement = node.openingElement;
+    var attributes = openingElement.attributes;
+
+    // replace primaryColor prop with color
+    var primaryColor = findProp(attributes, 'primaryColor');
+    if (primaryColor && primaryColor.type === 'JSXAttribute') {
+      fixes.push(fixer.replaceText(primaryColor.name, 'color'));
+    }
+
+    // add color="currentColor" if
+    // 1. primaryColor prop is not set
+    // 2. icon is not imported from migration entrypoint
+    // 3. icon element is not inside a new button
+    if (legacyImportNode && !primaryColor && !migrationImportNode &&
+    // value type need to be a string in Rule.ReportDescriptor
+    insideNewButton !== 'true') {
+      fixes.push(fixer.insertTextAfter(openingElement.name, " color=\"currentColor\""));
+    }
+
+    // rename or remove size prop based on shouldUseMigrationPath,
+    // add spacing="spacious" if
+    // 1. it's in error metadata, which means size is medium
+    // 2. no existing spacing prop
+    // 3. iconType is "core"
+    // 4. icon is not imported from migration entrypoint
+    var sizeProp = findProp(attributes, 'size');
+    var spacingProp = findProp(attributes, 'spacing');
+    if (spacing && !spacingProp && iconType === 'core' && !migrationImportNode) {
+      fixes.push(fixer.insertTextAfter(sizeProp || openingElement.name, " spacing=\"".concat(spacing, "\"")));
+    }
+    if (sizeProp && sizeProp.type === 'JSXAttribute') {
+      fixes.push(shouldUseMigrationPath ?
+      // replace size prop with LEGACY_size,
+      fixer.replaceText(sizeProp.name, 'LEGACY_size') :
+      // remove size prop if shouldUseMigrationPath is false
+      fixer.remove(sizeProp));
+    }
+
+    // rename or remove secondaryColor prop based on shouldUseMigrationPath
+    var secondaryColorProp = findProp(attributes, 'secondaryColor');
+    if (secondaryColorProp && secondaryColorProp.type === 'JSXAttribute') {
+      fixes.push(shouldUseMigrationPath ?
+      // replace secondaryColor prop with LEGACY_secondaryColor
+      fixer.replaceText(secondaryColorProp.name, 'LEGACY_secondaryColor') :
+      // remove secondaryColor prop if shouldUseMigrationPath is false
+      fixer.remove(secondaryColorProp));
+    }
+
+    // remove LEGACY props
+    if (!shouldUseMigrationPath) {
+      ['LEGACY_size', 'LEGACY_margin', 'LEGACY_fallbackIcon', 'LEGACY_secondaryColor'].forEach(function (propName) {
+        var legacyProp = findProp(attributes, propName);
+        if (legacyProp && legacyProp.type === 'JSXAttribute') {
+          fixes.push(fixer.remove(legacyProp));
+        }
+      });
+    }
+  }
+  return fixes;
+};
+
+/**
+ * Check if the new icon exists in the migration map
+ */
+export var checkIfNewIconExist = function checkIfNewIconExist(error) {
+  var _error$data;
+  if (!((_error$data = error.data) !== null && _error$data !== void 0 && _error$data.importSource)) {
+    return false;
+  }
+  var iconKey = getIconKey(error.data.importSource);
+  var _ref8 = baseMigrationMap[iconKey] || {},
+    newIcon = _ref8.newIcon;
+  return Boolean(newIcon);
 };

package/dist/esm/rules/no-legacy-icons/index.js

@@ -5,6 +5,7 @@ import { createHelpers } from './helpers';
 var rule = createLintRule({
   meta: {
     name: 'no-legacy-icons',
+    fixable: 'code',
     type: 'problem',
     docs: {
       description: 'Enforces no legacy icons are used.',
@@ -22,6 +23,9 @@ var rule = createLintRule({
         },
         quiet: {
           type: 'boolean'
+        },
+        shouldUseMigrationPath: {
+          type: 'boolean'
         }
       },
       additionalProperties: false

package/dist/types/rules/no-legacy-icons/helpers.d.ts

@@ -1,5 +1,5 @@
 import type { Rule } from 'eslint';
-import { type JSXAttribute, type Node } from 'eslint-codemod-utils';
+import { type ImportDeclaration, type JSXAttribute, type Node } from 'eslint-codemod-utils';
 import { type IconMigrationSizeGuidance } from '@atlaskit/icon/UNSAFE_migration-map';
 export type IconMigrationError = Rule.ReportDescriptor;
 export type RangeList = {
@@ -47,10 +47,24 @@ export declare const getUpcomingIcons: (iconPackage: string) => {
  * Checks if a new icon can be auto-migrated based on guidance from the migration map
  */
 export declare const canAutoMigrateNewIconBasedOnSize: (guidance?: string) => boolean;
+/**
+ *
+ * @param iconPackage string
+ * @returns object of new icon name and import path
+ */
+export declare const getNewIconNameAndImportPath: (iconPackage: string, shouldUseMigrationPath?: boolean) => {
+    iconName?: string;
+    importPath?: string;
+};
 /**
  * Creates the written guidance for migrating a legacy icon to a new icon
  */
-export declare const createGuidance: (iconPackage: string, insideNewButton?: boolean, size?: Size) => string;
+export declare const createGuidance: ({ iconPackage, insideNewButton, size, shouldUseMigrationPath, }: {
+    iconPackage: string;
+    insideNewButton?: boolean | undefined;
+    size?: "small" | "medium" | "large" | "xlarge" | undefined;
+    shouldUseMigrationPath?: boolean | undefined;
+}) => string;
 /**
  * Checks if the color can be migrated
  * @param color String representing the color to check
@@ -66,7 +80,14 @@ export declare const createCantMigrateFunctionUnknownError: (node: Node, importS
 export declare const createCantMigrateColorError: (node: Node, colorValue: string, errors: ErrorListManual, importSource: string, iconName: string) => void;
 export declare const createCantMigrateSpreadPropsError: (node: Node, missingProps: string[], errors: ErrorListManual, importSource: string, iconName: string) => void;
 export declare const createCantMigrateSizeUnknown: (node: Node, errors: ErrorListManual, importSource: string, iconName: string) => void;
-export declare const createAutoMigrationError: (node: Node, importSource: string, iconName: string, errors: ErrorListAuto) => void;
+export declare const createAutoMigrationError: ({ node, importSource, iconName, errors, shouldAddSpaciousSpacing, insideNewButton, }: {
+    node: Node;
+    importSource: string;
+    iconName: string;
+    errors: ErrorListAuto;
+    shouldAddSpaciousSpacing?: boolean | undefined;
+    insideNewButton?: boolean | undefined;
+}) => void;
 export declare const getLiteralStringValue: (value: any) => string | undefined;
 export declare const createHelpers: (context: Rule.RuleContext) => {
     /**
@@ -78,4 +99,68 @@ export declare const createHelpers: (context: Rule.RuleContext) => {
 };
 export declare const addToListOfRanges: (node: Node, sortedListOfRangesForErrors: RangeList) => void;
 export declare const isInRangeList: (node: Node, sortedListOfRangesForErrors: RangeList) => boolean;
+/**
+ *
+ * @param node Icon JSXelement
+ * @param newButtonImports list of new button import specifiers
+ * @returns if Icon is inside a new button
+ */
+export declare const isInsideNewButton: (node: Rule.Node, newButtonImports: Set<string>) => boolean;
+/**
+ *
+ * @param node Icon JSXelement
+ * @param newButtonImports list of legacy button import specifiers
+ * @returns if Icon is inside a legacy button
+ */
+export declare const isInsideLegacyButton: (node: Rule.Node, legacyButtonImports: Set<string>) => boolean;
+/**
+ *
+ * Creates a list of fixers to update the icon import path
+ * @param metadata Metadata including the import source and spacing
+ * @param fixer The original fix function
+ * @param legacyImportNode The import declaration node to replace
+ * @param shouldUseMigrationPath The eslint rule config, whether to use migration entrypoint or not
+ * @param migrationImportNode The migration import declaration node to replace, only present if shouldUseMigrationPath is false
+ * @returns A list of fixers to migrate the icon
+ */
+export declare const createImportFix: ({ fixer, legacyImportNode, metadata, shouldUseMigrationPath, migrationImportNode, }: {
+    fixer: Rule.RuleFixer;
+    metadata: {
+        importSource: string;
+        spacing: string;
+    };
+    legacyImportNode?: ImportDeclaration | undefined;
+    shouldUseMigrationPath: boolean;
+    migrationImportNode?: ImportDeclaration | undefined;
+}) => Rule.Fix[];
+/**
+ * Creates a list of fixers to update the icon props
+ * @param node The Icon element to migrate
+ * @param metadata Metadata including the import source and spacing
+ * @param fixer The original fix function
+ * @param legacyImportNode The import declaration node to replace
+ * @param shouldUseMigrationPath The eslint rule config, whether to use migration entrypoint or not
+ * @param migrationImportNode The migration import declaration node to replace, only present if shouldUseMigrationPath is false
+ * @returns A list of fixers to migrate the icon
+ */
+export declare const createPropFixes: ({ node, fixer, legacyImportNode, metadata, shouldUseMigrationPath, migrationImportNode, }: {
+    node: Node;
+    fixer: Rule.RuleFixer;
+    metadata: {
+        importSource: string;
+        spacing: string;
+        insideNewButton: string;
+    };
+    legacyImportNode?: ImportDeclaration | undefined;
+    shouldUseMigrationPath: boolean;
+    migrationImportNode?: ImportDeclaration | undefined;
+}) => Rule.Fix[];
+/**
+ * Check if the new icon exists in the migration map
+ */
+export declare const checkIfNewIconExist: (error: {
+    data?: {
+        importSource?: string;
+    };
+}) => boolean;
 export {};

package/dist/types-ts4.5/rules/no-legacy-icons/helpers.d.ts

@@ -1,5 +1,5 @@
 import type { Rule } from 'eslint';
-import { type JSXAttribute, type Node } from 'eslint-codemod-utils';
+import { type ImportDeclaration, type JSXAttribute, type Node } from 'eslint-codemod-utils';
 import { type IconMigrationSizeGuidance } from '@atlaskit/icon/UNSAFE_migration-map';
 export type IconMigrationError = Rule.ReportDescriptor;
 export type RangeList = {
@@ -52,10 +52,24 @@ export declare const getUpcomingIcons: (iconPackage: string) => {
  * Checks if a new icon can be auto-migrated based on guidance from the migration map
  */
 export declare const canAutoMigrateNewIconBasedOnSize: (guidance?: string) => boolean;
+/**
+ *
+ * @param iconPackage string
+ * @returns object of new icon name and import path
+ */
+export declare const getNewIconNameAndImportPath: (iconPackage: string, shouldUseMigrationPath?: boolean) => {
+    iconName?: string;
+    importPath?: string;
+};
 /**
  * Creates the written guidance for migrating a legacy icon to a new icon
  */
-export declare const createGuidance: (iconPackage: string, insideNewButton?: boolean, size?: Size) => string;
+export declare const createGuidance: ({ iconPackage, insideNewButton, size, shouldUseMigrationPath, }: {
+    iconPackage: string;
+    insideNewButton?: boolean | undefined;
+    size?: "small" | "medium" | "large" | "xlarge" | undefined;
+    shouldUseMigrationPath?: boolean | undefined;
+}) => string;
 /**
  * Checks if the color can be migrated
  * @param color String representing the color to check
@@ -71,7 +85,14 @@ export declare const createCantMigrateFunctionUnknownError: (node: Node, importS
 export declare const createCantMigrateColorError: (node: Node, colorValue: string, errors: ErrorListManual, importSource: string, iconName: string) => void;
 export declare const createCantMigrateSpreadPropsError: (node: Node, missingProps: string[], errors: ErrorListManual, importSource: string, iconName: string) => void;
 export declare const createCantMigrateSizeUnknown: (node: Node, errors: ErrorListManual, importSource: string, iconName: string) => void;
-export declare const createAutoMigrationError: (node: Node, importSource: string, iconName: string, errors: ErrorListAuto) => void;
+export declare const createAutoMigrationError: ({ node, importSource, iconName, errors, shouldAddSpaciousSpacing, insideNewButton, }: {
+    node: Node;
+    importSource: string;
+    iconName: string;
+    errors: ErrorListAuto;
+    shouldAddSpaciousSpacing?: boolean | undefined;
+    insideNewButton?: boolean | undefined;
+}) => void;
 export declare const getLiteralStringValue: (value: any) => string | undefined;
 export declare const createHelpers: (context: Rule.RuleContext) => {
     /**
@@ -83,4 +104,68 @@ export declare const createHelpers: (context: Rule.RuleContext) => {
 };
 export declare const addToListOfRanges: (node: Node, sortedListOfRangesForErrors: RangeList) => void;
 export declare const isInRangeList: (node: Node, sortedListOfRangesForErrors: RangeList) => boolean;
+/**
+ *
+ * @param node Icon JSXelement
+ * @param newButtonImports list of new button import specifiers
+ * @returns if Icon is inside a new button
+ */
+export declare const isInsideNewButton: (node: Rule.Node, newButtonImports: Set<string>) => boolean;
+/**
+ *
+ * @param node Icon JSXelement
+ * @param newButtonImports list of legacy button import specifiers
+ * @returns if Icon is inside a legacy button
+ */
+export declare const isInsideLegacyButton: (node: Rule.Node, legacyButtonImports: Set<string>) => boolean;
+/**
+ *
+ * Creates a list of fixers to update the icon import path
+ * @param metadata Metadata including the import source and spacing
+ * @param fixer The original fix function
+ * @param legacyImportNode The import declaration node to replace
+ * @param shouldUseMigrationPath The eslint rule config, whether to use migration entrypoint or not
+ * @param migrationImportNode The migration import declaration node to replace, only present if shouldUseMigrationPath is false
+ * @returns A list of fixers to migrate the icon
+ */
+export declare const createImportFix: ({ fixer, legacyImportNode, metadata, shouldUseMigrationPath, migrationImportNode, }: {
+    fixer: Rule.RuleFixer;
+    metadata: {
+        importSource: string;
+        spacing: string;
+    };
+    legacyImportNode?: ImportDeclaration | undefined;
+    shouldUseMigrationPath: boolean;
+    migrationImportNode?: ImportDeclaration | undefined;
+}) => Rule.Fix[];
+/**
+ * Creates a list of fixers to update the icon props
+ * @param node The Icon element to migrate
+ * @param metadata Metadata including the import source and spacing
+ * @param fixer The original fix function
+ * @param legacyImportNode The import declaration node to replace
+ * @param shouldUseMigrationPath The eslint rule config, whether to use migration entrypoint or not
+ * @param migrationImportNode The migration import declaration node to replace, only present if shouldUseMigrationPath is false
+ * @returns A list of fixers to migrate the icon
+ */
+export declare const createPropFixes: ({ node, fixer, legacyImportNode, metadata, shouldUseMigrationPath, migrationImportNode, }: {
+    node: Node;
+    fixer: Rule.RuleFixer;
+    metadata: {
+        importSource: string;
+        spacing: string;
+        insideNewButton: string;
+    };
+    legacyImportNode?: ImportDeclaration | undefined;
+    shouldUseMigrationPath: boolean;
+    migrationImportNode?: ImportDeclaration | undefined;
+}) => Rule.Fix[];
+/**
+ * Check if the new icon exists in the migration map
+ */
+export declare const checkIfNewIconExist: (error: {
+    data?: {
+        importSource?: string;
+    };
+}) => boolean;
 export {};

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": "10.16.0",
+	"version": "10.17.0",
 	"author": "Atlassian Pty Ltd",
 	"license": "Apache-2.0",
 	"publishConfig": {
@@ -55,7 +55,7 @@
 	},
 	"devDependencies": {
 		"@af/formatting": "*",
-		"@atlaskit/ds-lib": "^2.4.0",
+		"@atlaskit/ds-lib": "^2.5.0",
 		"@atlaskit/theme": "^13.0.0",
 		"@atlassian/codegen": "*",
 		"@atlassian/eslint-utils": "^0.5.0",