@atlaskit/eslint-plugin-design-system 10.17.3 → 10.18.1

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

@@ -1,13 +1,8 @@
-import _toConsumableArray from "@babel/runtime/helpers/toConsumableArray";
-import _defineProperty from "@babel/runtime/helpers/defineProperty";
-import _slicedToArray from "@babel/runtime/helpers/slicedToArray";
-function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
-function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
 function _createForOfIteratorHelper(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = it.call(o); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it.return != null) it.return(); } finally { if (didErr) throw err; } } }; }
 function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
 function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; return arr2; }
 import { isNodeOfType } from 'eslint-codemod-utils';
-import { addToListOfRanges, canAutoMigrateNewIconBasedOnSize, canMigrateColor, checkIfNewIconExist, createAutoMigrationError, createCantFindSuitableReplacementError, createCantMigrateColorError, createCantMigrateFunctionUnknownError, createCantMigrateIdentifierError, createCantMigrateIdentifierMapOrArrayError, createCantMigrateReExportError, createCantMigrateSizeUnknown, createCantMigrateSpreadPropsError, createGuidance, createHelpers, createImportFix, createPropFixes, getMigrationMapObject, getUpcomingIcons, isInRangeList, isInsideLegacyButton, isInsideNewButton, isSize, locToString } from './helpers';
+import { addToListOfRanges, canAutoMigrateNewIconBasedOnSize, canMigrateColor, createAutoMigrationError, createCantFindSuitableReplacementError, createCantMigrateColorError, createCantMigrateFunctionUnknownError, createCantMigrateIdentifierError, createCantMigrateIdentifierMapOrArrayError, createCantMigrateReExportError, createCantMigrateSizeUnknown, createCantMigrateSpreadPropsError, createGuidance, createHelpers, getMigrationMapObject, getUpcomingIcons, isInsideLegacyButton, isInsideNewButton, isSize, locToString, throwAutoErrors, throwManualErrors } from './helpers';
 export var createChecks = function createChecks(context) {
   //create global variables to be shared by the checks
   var _createHelpers = createHelpers(context),
@@ -20,7 +15,6 @@ export var createChecks = function createChecks(context) {
   var errorsManual = {};
   var errorsAuto = {};
   var guidance = {};
-  var autoIconJSXElementOccurrenceCount = 0;
 
   // Extract parameters
   var shouldErrorForManualMigration = getConfigFlag('shouldErrorForManualMigration', true);
@@ -51,7 +45,8 @@ export var createChecks = function createChecks(context) {
             legacyIconImports[spec.local.name] = {
               packageName: moduleSource,
               exported: false,
-              importNode: node
+              importNode: node,
+              importSpecifier: spec.local.name
             };
           }
         }
@@ -69,7 +64,8 @@ export var createChecks = function createChecks(context) {
           migrationIconImports[spec.local.name] = {
             packageName: moduleSource,
             exported: false,
-            importNode: node
+            importNode: node,
+            importSpecifier: spec.local.name
           };
         }
       });
@@ -130,7 +126,9 @@ export var createChecks = function createChecks(context) {
             if (Object.keys(legacyIconImports).includes(decl.init.name)) {
               legacyIconImports[decl.id.name] = {
                 packageName: legacyIconImports[decl.init.name].packageName,
-                exported: legacyIconImports[decl.init.name].exported || isExported
+                exported: legacyIconImports[decl.init.name].exported || isExported,
+                importNode: legacyIconImports[decl.init.name].importNode,
+                importSpecifier: legacyIconImports[decl.init.name].importSpecifier
               };
             } else if (newButtonImports.has(decl.init.name)) {
               newButtonImports.add(decl.id.name);
@@ -174,7 +172,7 @@ export var createChecks = function createChecks(context) {
    * @param node The named export node found by ESLint
    */
   var checkExportNamedVariables = function checkExportNamedVariables(node) {
-    // export {default as AddIcon} from '@atlaskit/icon/glyph/add';
+    // Case: export {default as AddIcon} from '@atlaskit/icon/glyph/add';
     if (node.source && isNodeOfType(node.source, 'Literal') && Object.keys(node.source).includes('value')) {
       var moduleSource = node.source.value;
       if (typeof moduleSource === 'string' && ['@atlaskit/icon/glyph/', '@atlaskit/icon-object/glyph/'].find(function (val) {
@@ -199,7 +197,7 @@ export var createChecks = function createChecks(context) {
         }
       }
     } else if (node.declaration && isNodeOfType(node.declaration, 'VariableDeclaration')) {
-      // export const Icon = AddIcon;
+      // Case: export const Icon = AddIcon;
       var _iterator6 = _createForOfIteratorHelper(node.declaration.declarations),
         _step6;
       try {
@@ -235,7 +233,9 @@ export var createChecks = function createChecks(context) {
             //update legacy imports to be exported
             legacyIconImports[_spec3.local.name] = {
               packageName: legacyIconImports[_spec3.local.name].packageName,
-              exported: true
+              exported: true,
+              importNode: legacyIconImports[_spec3.local.name].importNode,
+              importSpecifier: legacyIconImports[_spec3.local.name].importSpecifier
             };
             createCantMigrateReExportError(_spec3, legacyIconImports[_spec3.local.name].packageName, _spec3.exported.name, errorsManual);
             addToListOfRanges(_spec3, errorRanges);
@@ -490,7 +490,6 @@ export var createChecks = function createChecks(context) {
       });
       var _shouldAddSpaciousSpacing = (_sizeProp && _sizeProp.type === 'JSXAttribute' && ((_sizeProp$value2 = _sizeProp.value) === null || _sizeProp$value2 === void 0 ? void 0 : _sizeProp$value2.type) === 'Literal' && _sizeProp.value.value === 'medium' || !_sizeProp) && !_insideNewButton && !insideLegacyButton;
       if (!hasManualMigration && (newIcon || upcomingIcon) && isNewIconMigratable) {
-        autoIconJSXElementOccurrenceCount++;
         createAutoMigrationError({
           node: node,
           importSource: legacyIconImports[name].packageName,
@@ -544,132 +543,26 @@ export var createChecks = function createChecks(context) {
    * Throws the relevant errors in the correct order based on configs.
    */
   var throwErrors = function throwErrors() {
+    // Throw manual errors
     if (shouldErrorForManualMigration) {
-      for (var _i = 0, _Object$entries = Object.entries(errorsManual); _i < _Object$entries.length; _i++) {
-        var _Object$entries$_i = _slicedToArray(_Object$entries[_i], 2),
-          _key = _Object$entries$_i[0],
-          errorList = _Object$entries$_i[1];
-        var _node = 'node' in errorList.errors[0] ? errorList.errors[0].node : null;
-        var cantMigrateIdentifierError = errorList.errors.find(function (x) {
-          return 'messageId' in x && x.messageId === 'cantMigrateIdentifier';
-        });
-        if (_node) {
-          var isInRange = false;
-          if (cantMigrateIdentifierError && isInRangeList(_node, errorRanges)) {
-            isInRange = true;
-          }
-          if (isInRange && errorList.errors.length - 1 > 0 || !isInRange && errorList.errors.length > 0) {
-            var guidanceMessage = Object.keys(guidance).includes(_key) ? guidance[_key] : '';
-            context.report({
-              node: _node,
-              messageId: 'noLegacyIconsManualMigration',
-              data: {
-                iconName: errorList.iconName,
-                importSource: errorList.importSource,
-                guidance: isQuietMode ? guidanceMessage : "".concat(guidanceMessage, "For more information see the below errors.\n")
-              }
-            });
-            if (!isQuietMode) {
-              var _iterator10 = _createForOfIteratorHelper(errorList.errors),
-                _step10;
-              try {
-                for (_iterator10.s(); !(_step10 = _iterator10.n()).done;) {
-                  var error = _step10.value;
-                  if ('messageId' in error && (error.messageId !== 'cantMigrateIdentifier' || error.messageId === 'cantMigrateIdentifier' && !isInRange)) {
-                    context.report(error);
-                  }
-                }
-              } catch (err) {
-                _iterator10.e(err);
-              } finally {
-                _iterator10.f();
-              }
-            }
-          }
-        }
-      }
+      throwManualErrors({
+        errorsManual: errorsManual,
+        errorRanges: errorRanges,
+        guidance: guidance,
+        context: context,
+        isQuietMode: isQuietMode
+      });
     }
     if (shouldErrorForAutoMigration) {
-      var _loop = function _loop() {
-        var _Object$entries2$_i = _slicedToArray(_Object$entries2[_i2], 2),
-          key = _Object$entries2$_i[0],
-          error = _Object$entries2$_i[1];
-        // If there's a manual error that exists for this same component,
-        // don't throw the auto error
-        if (Object.keys(errorsManual).includes(key)) {
-          var _cantMigrateIdentifierError = errorsManual[key].errors.find(function (x) {
-            return 'messageId' in x && x.messageId === 'cantMigrateIdentifier';
-          });
-          if (!_cantMigrateIdentifierError || _cantMigrateIdentifierError && errorsManual[key].errors.length > 1) {
-            delete errorsAuto[key];
-            return 1; // continue
-          }
-        }
-        var node = 'node' in error ? error.node : null;
-        if (node) {
-          var _guidanceMessage = Object.keys(guidance).includes(key) ? guidance[key] : '';
-          if (Object.keys(error).includes('data') && error.data) {
-            error.data.guidance = _guidanceMessage;
-          }
-          context.report(_objectSpread(_objectSpread({}, error), {}, {
-            fix: function fix(fixer) {
-              var _legacyIconImports$er, _migrationIconImports;
-              // don't migration if the new icon is not available
-              if (!error.data || shouldUseMigrationPath && !checkIfNewIconExist(error)) {
-                return [];
-              }
-              var fixArguments = {
-                metadata: error.data,
-                legacyImportNode: (_legacyIconImports$er = legacyIconImports[error.data.iconName]) === null || _legacyIconImports$er === void 0 ? void 0 : _legacyIconImports$er.importNode,
-                migrationImportNode: (_migrationIconImports = migrationIconImports[error.data.iconName]) === null || _migrationIconImports === void 0 ? void 0 : _migrationIconImports.importNode,
-                shouldUseMigrationPath: shouldUseMigrationPath
-              };
-              var propsFixes = createPropFixes(_objectSpread(_objectSpread({}, fixArguments), {}, {
-                node: node,
-                fixer: fixer
-              }));
-              var importFixes = [];
-              // Otherwise if there are multiple occurrences of the icon, import path will be handled after the prop fix
-              if (autoIconJSXElementOccurrenceCount <= 1) {
-                importFixes = createImportFix(_objectSpread(_objectSpread({}, fixArguments), {}, {
-                  fixer: fixer
-                }));
-              }
-              return [].concat(_toConsumableArray(propsFixes), _toConsumableArray(importFixes));
-            }
-          }));
-        }
-      };
-      for (var _i2 = 0, _Object$entries2 = Object.entries(errorsAuto); _i2 < _Object$entries2.length; _i2++) {
-        if (_loop()) continue;
-      }
-
-      // Update import path at the end if there are multiple occurrences of the icon
-      if (autoIconJSXElementOccurrenceCount > 1) {
-        var _loop2 = function _loop2() {
-          var _Object$entries3$_i = _slicedToArray(_Object$entries3[_i3], 2),
-            _ = _Object$entries3$_i[0],
-            error = _Object$entries3$_i[1];
-          context.report(_objectSpread(_objectSpread({}, error), {}, {
-            fix: function fix(fixer) {
-              var _legacyIconImports$er2, _migrationIconImports2;
-              if (!error.data || shouldUseMigrationPath && !checkIfNewIconExist(error)) {
-                return [];
-              }
-              return createImportFix({
-                metadata: error.data,
-                fixer: fixer,
-                legacyImportNode: (_legacyIconImports$er2 = legacyIconImports[error.data.iconName]) === null || _legacyIconImports$er2 === void 0 ? void 0 : _legacyIconImports$er2.importNode,
-                migrationImportNode: (_migrationIconImports2 = migrationIconImports[error.data.iconName]) === null || _migrationIconImports2 === void 0 ? void 0 : _migrationIconImports2.importNode,
-                shouldUseMigrationPath: shouldUseMigrationPath
-              });
-            }
-          }));
-        };
-        for (var _i3 = 0, _Object$entries3 = Object.entries(errorsAuto); _i3 < _Object$entries3.length; _i3++) {
-          _loop2();
-        }
-      }
+      throwAutoErrors({
+        errorsManual: errorsManual,
+        errorsAuto: errorsAuto,
+        legacyIconImports: legacyIconImports,
+        guidance: guidance,
+        migrationIconImports: migrationIconImports,
+        shouldUseMigrationPath: shouldUseMigrationPath,
+        context: context
+      });
     }
   };
   return {

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

@@ -1,4 +1,11 @@
+import _toConsumableArray from "@babel/runtime/helpers/toConsumableArray";
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
 import _slicedToArray from "@babel/runtime/helpers/slicedToArray";
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+function _createForOfIteratorHelper(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = it.call(o); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it.return != null) it.return(); } finally { if (didErr) throw err; } } }; }
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; return arr2; }
 import { isNodeOfType, literal } from 'eslint-codemod-utils';
 import baseMigrationMap, { migrationOutcomeDescriptionMap } from '@atlaskit/icon/UNSAFE_migration-map';
 import { upcomingIcons } from './upcoming-icons';
@@ -57,7 +64,7 @@ export var canAutoMigrateNewIconBasedOnSize = function canAutoMigrateNewIconBase
  * @param iconPackage string
  * @returns object of new icon name and import path
  */
-export var getNewIconNameAndImportPath = function getNewIconNameAndImportPath(iconPackage, shouldUseMigrationPath) {
+var getNewIconNameAndImportPath = function getNewIconNameAndImportPath(iconPackage, shouldUseMigrationPath) {
   var legacyIconName = getIconKey(iconPackage);
   var migrationMapObject = getMigrationMapObject(iconPackage);
   if (!migrationMapObject || !migrationMapObject.newIcon) {
@@ -288,7 +295,7 @@ var pushManualError = function pushManualError(key, errors, myError, importSourc
     };
   }
 };
-export var getLiteralStringValue = function getLiteralStringValue(value) {
+var getLiteralStringValue = function getLiteralStringValue(value) {
   if (!value) {
     return;
   }
@@ -356,7 +363,7 @@ export var addToListOfRanges = function addToListOfRanges(node, sortedListOfRang
     });
   }
 };
-export var isInRangeList = function isInRangeList(node, sortedListOfRangesForErrors) {
+var isInRangeList = function isInRangeList(node, sortedListOfRangesForErrors) {
   var range = node.range;
   if (!range || range.length < 2) {
     return false;
@@ -401,6 +408,18 @@ var findProp = function findProp(attributes, propName) {
     return attr.type === 'JSXAttribute' && attr.name.name === propName;
   });
 };
+var getNewIconNameForRenaming = function getNewIconNameForRenaming(isInManualArray, importSource, importSpecifier) {
+  var newIconName;
+  if (isInManualArray) {
+    newIconName = getNewIconNameAndImportPath(importSource).iconName;
+    var keyToName = newIconName ? newIconName[0].toUpperCase() + newIconName.slice(1) + 'Icon' : undefined;
+    newIconName = keyToName;
+    if (newIconName === undefined || importSpecifier === keyToName) {
+      newIconName = "".concat(keyToName, "New");
+    }
+  }
+  return newIconName;
+};
 
 /**
  *
@@ -412,22 +431,22 @@ var findProp = function findProp(attributes, propName) {
  * @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 createImportFix = function createImportFix(_ref6) {
   var fixer = _ref6.fixer,
     legacyImportNode = _ref6.legacyImportNode,
     metadata = _ref6.metadata,
     shouldUseMigrationPath = _ref6.shouldUseMigrationPath,
-    migrationImportNode = _ref6.migrationImportNode;
+    migrationImportNode = _ref6.migrationImportNode,
+    newIconName = _ref6.newIconName;
   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), "'")));
+  var useMigrationPath = legacyImportNode && importPath;
+  var useFinalPath = migrationImportNode && !shouldUseMigrationPath && importPath;
+  if (useMigrationPath) {
+    fixes.push(newIconName ? fixer.insertTextBefore(legacyImportNode, "import ".concat(newIconName, " from '").concat(importPath, "';\n")) : fixer.replaceText(legacyImportNode.source, "'".concat(literal(importPath), "'")));
+  } else if (useFinalPath) {
+    fixes.push(newIconName ? fixer.insertTextBefore(migrationImportNode, "import ".concat(newIconName, " from '").concat(importPath, "';\n")) : fixer.replaceText(migrationImportNode.source, "'".concat(literal(importPath), "'")));
   }
   return fixes;
 };
@@ -442,13 +461,14 @@ export var createImportFix = function createImportFix(_ref6) {
  * @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 createPropFixes = function createPropFixes(_ref7) {
   var node = _ref7.node,
     fixer = _ref7.fixer,
     legacyImportNode = _ref7.legacyImportNode,
     metadata = _ref7.metadata,
     shouldUseMigrationPath = _ref7.shouldUseMigrationPath,
-    migrationImportNode = _ref7.migrationImportNode;
+    migrationImportNode = _ref7.migrationImportNode,
+    newIconName = _ref7.newIconName;
   var fixes = [];
   var importSource = metadata.importSource,
     spacing = metadata.spacing,
@@ -460,6 +480,9 @@ export var createPropFixes = function createPropFixes(_ref7) {
   var iconType = importPath !== null && importPath !== void 0 && importPath.startsWith('@atlaskit/icon/core') ? 'core' : 'utility';
   if (node.type === 'JSXElement') {
     var openingElement = node.openingElement;
+    if (newIconName) {
+      fixes.push(fixer.replaceText(openingElement.name, newIconName));
+    }
     var attributes = openingElement.attributes;
 
     // replace primaryColor prop with color
@@ -516,6 +539,8 @@ export var createPropFixes = function createPropFixes(_ref7) {
         }
       });
     }
+  } else if (node.type === 'Identifier' && newIconName) {
+    fixes.push(fixer.replaceText(node, newIconName));
   }
   return fixes;
 };
@@ -523,7 +548,7 @@ export var createPropFixes = function createPropFixes(_ref7) {
 /**
  * Check if the new icon exists in the migration map
  */
-export var checkIfNewIconExist = function checkIfNewIconExist(error) {
+var checkIfNewIconExist = function checkIfNewIconExist(error) {
   var _error$data;
   if (!((_error$data = error.data) !== null && _error$data !== void 0 && _error$data.importSource)) {
     return false;
@@ -532,4 +557,210 @@ export var checkIfNewIconExist = function checkIfNewIconExist(error) {
   var _ref8 = baseMigrationMap[iconKey] || {},
     newIcon = _ref8.newIcon;
   return Boolean(newIcon);
+};
+export var throwManualErrors = function throwManualErrors(_ref9) {
+  var errorsManual = _ref9.errorsManual,
+    errorRanges = _ref9.errorRanges,
+    guidance = _ref9.guidance,
+    context = _ref9.context,
+    isQuietMode = _ref9.isQuietMode;
+  for (var _i2 = 0, _Object$entries2 = Object.entries(errorsManual); _i2 < _Object$entries2.length; _i2++) {
+    var _Object$entries2$_i = _slicedToArray(_Object$entries2[_i2], 2),
+      _key = _Object$entries2$_i[0],
+      errorList = _Object$entries2$_i[1];
+    var node = 'node' in errorList.errors[0] ? errorList.errors[0].node : null;
+    if (!node) {
+      return;
+    }
+    var cantMigrateIdentifierError = errorList.errors.find(function (x) {
+      return 'messageId' in x && x.messageId === 'cantMigrateIdentifier';
+    });
+    var isInRange = false;
+    if (cantMigrateIdentifierError && isInRangeList(node, errorRanges)) {
+      isInRange = true;
+    }
+    if (isInRange && errorList.errors.length - 1 > 0 || !isInRange && errorList.errors.length > 0) {
+      var guidanceMessage = Object.keys(guidance).includes(_key) ? guidance[_key] : '';
+      context.report({
+        node: node,
+        messageId: 'noLegacyIconsManualMigration',
+        data: {
+          iconName: errorList.iconName,
+          importSource: errorList.importSource,
+          guidance: isQuietMode ? guidanceMessage : "".concat(guidanceMessage, "For more information see the below errors.\n")
+        }
+      });
+      if (!isQuietMode) {
+        var _iterator = _createForOfIteratorHelper(errorList.errors),
+          _step;
+        try {
+          for (_iterator.s(); !(_step = _iterator.n()).done;) {
+            var error = _step.value;
+            if ('messageId' in error && (error.messageId !== 'cantMigrateIdentifier' || error.messageId === 'cantMigrateIdentifier' && !isInRange)) {
+              context.report(error);
+            }
+          }
+        } catch (err) {
+          _iterator.e(err);
+        } finally {
+          _iterator.f();
+        }
+      }
+    }
+  }
+};
+
+// Loops through automatic errors and them after adding the required suggestion/fix
+export var throwAutoErrors = function throwAutoErrors(_ref10) {
+  var errorsManual = _ref10.errorsManual,
+    errorsAuto = _ref10.errorsAuto,
+    legacyIconImports = _ref10.legacyIconImports,
+    guidance = _ref10.guidance,
+    migrationIconImports = _ref10.migrationIconImports,
+    shouldUseMigrationPath = _ref10.shouldUseMigrationPath,
+    context = _ref10.context;
+  // Set of all the import sources that have manual errors (required later to check if a source has both manual and auto
+  // errors in one file making it impossible to just remove the legacy import)
+  var allManualErrorSources = Object.entries(errorsManual).reduce(function (result, option) {
+    var _option = _slicedToArray(option, 2),
+      key = _option[0],
+      errorInfo = _option[1];
+    if (!errorsAuto.hasOwnProperty(key)) {
+      result.add(errorInfo.importSource);
+    }
+    return result;
+  }, new Set());
+  //group errors by import source and remove any unwanted errors
+  var groupedErrorList = Object.entries(errorsAuto).reduce(function (result, option) {
+    var _option2 = _slicedToArray(option, 2),
+      key = _option2[0],
+      error = _option2[1];
+    //return early if no data
+    if (!error.data) {
+      return result;
+    }
+    if (Object.keys(errorsManual).includes(key)) {
+      var cantMigrateIdentifierError = errorsManual[key].errors.find(function (x) {
+        return 'messageId' in x && x.messageId === 'cantMigrateIdentifier';
+      });
+      // If cantMigrateIdentifier is the only manual error found we still want to throw the auto error
+      if (!(cantMigrateIdentifierError && errorsManual[key].errors.length === 1)) {
+        return result;
+      }
+    }
+    var importSource = error.data.importSource;
+    if (!result.hasOwnProperty(importSource)) {
+      result[importSource] = [];
+    }
+    result[importSource].push(_objectSpread({
+      key: key
+    }, error));
+    return result;
+  }, {});
+  var _loop = function _loop() {
+    var _Object$entries3$_i = _slicedToArray(_Object$entries3[_i3], 2),
+      importSource = _Object$entries3$_i[0],
+      errorList = _Object$entries3$_i[1];
+    var autoFixers = [];
+    // appliedErrorsForImport will contain all the errors FOR A SINGLE IMPORT and will be merged into errorListForReport
+    var appliedErrorsForImport = [];
+    // Loop over auto errors for a single import source
+    var _iterator2 = _createForOfIteratorHelper(errorList.entries()),
+      _step2;
+    try {
+      var _loop2 = function _loop2() {
+          var _legacyIconImports$er, _legacyIconImports$er2, _migrationIconImports;
+          var _step2$value = _slicedToArray(_step2.value, 2),
+            _ = _step2$value[0],
+            error = _step2$value[1];
+          var key = error.key;
+          var node = 'node' in error ? error.node : null;
+          // Check if there is a manual error for the same import source somewhere else in the same file
+          // If that is the case we'll need to provide a suggestion instead of auto-fixing as the suggestion will
+          // add another import without removing the old import and this needs to be validated
+          var isInManualArray = allManualErrorSources.has(importSource);
+          // New icon name for renaming if the icon is in the manual array
+          var newIconName = getNewIconNameForRenaming(isInManualArray, importSource, errorList[0].data ? (_legacyIconImports$er = legacyIconImports[errorList[0].data.iconName]) === null || _legacyIconImports$er === void 0 ? void 0 : _legacyIconImports$er.importSpecifier : undefined);
+          if (!node) {
+            return 0; // continue
+          }
+          var guidanceMessage = guidance.hasOwnProperty(key) ? guidance[key] : '';
+          if (Object.keys(error).includes('data') && error.data) {
+            error.data.guidance = guidanceMessage;
+          }
+          var fixArguments = error.data ? {
+            metadata: error.data,
+            legacyImportNode: (_legacyIconImports$er2 = legacyIconImports[error.data.iconName]) === null || _legacyIconImports$er2 === void 0 ? void 0 : _legacyIconImports$er2.importNode,
+            migrationImportNode: (_migrationIconImports = migrationIconImports[error.data.iconName]) === null || _migrationIconImports === void 0 ? void 0 : _migrationIconImports.importNode,
+            shouldUseMigrationPath: shouldUseMigrationPath,
+            newIconName: isInManualArray ? newIconName : undefined
+          } : null;
+          if (!error.data || shouldUseMigrationPath && !checkIfNewIconExist(error) || !fixArguments) {
+            return 0; // continue
+          }
+          if (isInManualArray) {
+            // provide suggestion if there is a manual error for the same import source and thus the legacy import can't be removed
+            error.suggest = [{
+              desc: 'Rename icon import, import from the new package, and update props.',
+              fix: function fix(fixer) {
+                return [].concat(_toConsumableArray(createPropFixes(_objectSpread(_objectSpread({}, fixArguments), {}, {
+                  node: node,
+                  fixer: fixer
+                }))), _toConsumableArray(createImportFix(_objectSpread(_objectSpread({}, fixArguments), {}, {
+                  fixer: fixer
+                }))));
+              }
+            }];
+          } else {
+            // Update Guidance message for auto-fixing
+            if (error.data) {
+              error.data.guidance = error.data.guidance + "\nTo automatically fix this icon, run the auto-fixer attached to the first use of ".concat(importSource, " in this file - either manually, or by saving this file.");
+            }
+            // There should only be 1 import fix for each import source and thus only add this at the start of the list
+            if (autoFixers.length === 0) {
+              autoFixers.push(function (fixer) {
+                return createImportFix(_objectSpread(_objectSpread({}, fixArguments), {}, {
+                  fixer: fixer
+                }));
+              });
+            }
+            // Push the prop fix regardless
+            autoFixers.push(function (fixer) {
+              return createPropFixes(_objectSpread(_objectSpread({}, fixArguments), {}, {
+                node: node,
+                fixer: fixer
+              }));
+            });
+          }
+          // Add the error to the appliedErrorsForImport, ready to be thrown later
+          appliedErrorsForImport.push(error);
+        },
+        _ret;
+      for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+        _ret = _loop2();
+        if (_ret === 0) continue;
+      }
+      // We want to have only 1 fix for each import source that is not in the manual array
+      // NOTE: If in the manual array, suggestions have been applied above and autoFixers.length will be 0 which will mean no fix is added
+    } catch (err) {
+      _iterator2.e(err);
+    } finally {
+      _iterator2.f();
+    }
+    if (autoFixers.length > 0) {
+      // Add the fix to only one of the errors in the list of errors from the current import source
+      appliedErrorsForImport[0].fix = function (fixer) {
+        return autoFixers.flatMap(function (autoFixer) {
+          return autoFixer(fixer);
+        });
+      };
+    }
+    // throw errors
+    appliedErrorsForImport.forEach(function (error) {
+      context.report(error);
+    });
+  };
+  for (var _i3 = 0, _Object$entries3 = Object.entries(groupedErrorList); _i3 < _Object$entries3.length; _i3++) {
+    _loop();
+  }
 };

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

@@ -6,6 +6,7 @@ var rule = createLintRule({
   meta: {
     name: 'no-legacy-icons',
     fixable: 'code',
+    hasSuggestions: true,
     type: 'problem',
     docs: {
       description: 'Enforces no legacy icons are used.',

package/dist/esm/rules/use-latest-xcss-syntax-typography/config/index.js

@@ -1,5 +1,6 @@
 var defaults = {
-  failSilently: false
+  failSilently: false,
+  patterns: ['restricted-property', 'wrapped-token-value']
 };
 export var getConfig = function getConfig(overrides) {
   return Object.assign({}, defaults, overrides);

package/dist/esm/rules/use-latest-xcss-syntax-typography/index.js

@@ -1,7 +1,8 @@
 import { createLintRule } from '../utils/create-rule';
 import { errorBoundary } from '../utils/error-boundary';
 import { getConfig } from './config';
-import { BannedProperty } from './linters';
+import { RestrictedProperty, WrappedTokenValue } from './linters';
+var typescriptErrorMessage = 'There is ongoing work to make this a TypeScript error. Once that happens, you will have to delete/refactor anyway.';
 var rule = createLintRule({
   meta: {
     name: 'use-latest-xcss-syntax-typography',
@@ -14,20 +15,36 @@ var rule = createLintRule({
       severity: 'warn'
     },
     messages: {
-      noUnsafeTypographyProperties: "Don't set '{{ property }}' on xcss. They are unsafe as they allow invalid combinations of typography tokens. There is ongoing work to make this a TypeScript error. Once that happens, you will have to delete/refactor anyway."
+      noRestrictedTypographyProperties: "Don't set '{{ property }}' on xcss as it allows invalid combinations of typography tokens. ".concat(typescriptErrorMessage),
+      noRestrictedTypographyPropertiesHeading: "Don't set '{{ property }}' on xcss in combination with 'font' heading tokens. ".concat(typescriptErrorMessage),
+      noWrappedTokenTypographyValues: "Don't wrap typography tokens in xcss. ".concat(typescriptErrorMessage)
     }
   },
   create: function create(context) {
     var config = getConfig(context.options[0]);
     return errorBoundary({
       'CallExpression[callee.name="xcss"] ObjectExpression > Property > Identifier[name=/(fontSize|lineHeight|fontWeight|letterSpacing)/]': function CallExpressionCalleeNameXcssObjectExpressionPropertyIdentifierNameFontSizeLineHeightFontWeightLetterSpacing(node) {
-        return BannedProperty.lint(node, {
-          context: context
+        return RestrictedProperty.lint(node, {
+          context: context,
+          config: config
         });
       },
       'CallExpression[callee.name="xcss"] ObjectExpression > Property > Literal[value=/(fontSize|lineHeight|fontWeight|letterSpacing)/]': function CallExpressionCalleeNameXcssObjectExpressionPropertyLiteralValueFontSizeLineHeightFontWeightLetterSpacing(node) {
-        return BannedProperty.lint(node, {
-          context: context
+        return RestrictedProperty.lint(node, {
+          context: context,
+          config: config
+        });
+      },
+      'CallExpression[callee.name="xcss"] ObjectExpression > Property > Identifier[name=/(font|fontFamily|fontWeight)/]': function CallExpressionCalleeNameXcssObjectExpressionPropertyIdentifierNameFontFontFamilyFontWeight(node) {
+        return WrappedTokenValue.lint(node, {
+          context: context,
+          config: config
+        });
+      },
+      'CallExpression[callee.name="xcss"] ObjectExpression > Property > Literal[value=/(font|fontFamily|fontWeight)/]': function CallExpressionCalleeNameXcssObjectExpressionPropertyLiteralValueFontFontFamilyFontWeight(node) {
+        return WrappedTokenValue.lint(node, {
+          context: context,
+          config: config
         });
       }
     }, config);

package/dist/esm/rules/use-latest-xcss-syntax-typography/linters/common.js

@@ -0,0 +1 @@
+export {};