@atlaskit/eslint-plugin-design-system 10.12.3 → 10.12.5

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

@@ -3,7 +3,7 @@ function _createForOfIteratorHelper(o, allowArrayLike) { var it = typeof Symbol
 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 { canAutoMigrateNewIconBasedOnSize, canMigrateColor, createAutoMigrationError, createCantFindSuitableReplacementError, createCantMigrateColorError, createCantMigrateFunctionUnknownError, createCantMigrateIdentifierError, createCantMigrateReExportError, createCantMigrateSizeUnknown, createCantMigrateSpreadPropsError, createGuidance, createHelpers, getMigrationMapObject, isSize, locToString } from './helpers';
+import { addToListOfRanges, canAutoMigrateNewIconBasedOnSize, canMigrateColor, createAutoMigrationError, createCantFindSuitableReplacementError, createCantMigrateColorError, createCantMigrateFunctionUnknownError, createCantMigrateIdentifierError, createCantMigrateIdentifierMapOrArrayError, createCantMigrateReExportError, createCantMigrateSizeUnknown, createCantMigrateSpreadPropsError, createGuidance, createHelpers, getMigrationMapObject, getUpcomingIcons, isInRangeList, isSize, locToString } from './helpers';
 export var createChecks = function createChecks(context) {
   //create global variables to be shared by the checks
   var _createHelpers = createHelpers(context),
@@ -20,6 +20,9 @@ export var createChecks = function createChecks(context) {
   var shouldErrorForAutoMigration = getConfigFlag('shouldErrorForAutoMigration', true);
   var isQuietMode = getConfigFlag('quiet', false);
 
+  // Sorted list of ranges
+  var errorRanges = [];
+
   /**
    * Adds the legacy Icon and new button imports to the correct global arrays to be used by the other checks
    * @param node The import node found by ESLint
@@ -83,8 +86,8 @@ export var createChecks = function createChecks(context) {
       try {
         for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
           var decl = _step3.value;
-          if (isNodeOfType(decl, 'VariableDeclarator') && 'init' in decl && 'id' in decl && decl.init && decl.id && 'name' in decl.id && decl.id.name && isNodeOfType(decl.init, 'Identifier')) {
-            if (decl.init.name in legacyIconImports) {
+          if (isNodeOfType(decl, 'VariableDeclarator') && Object.keys(decl).includes('init') && Object.keys(decl).includes('id') && decl.init && decl.id && 'name' in decl.id && decl.id.name && isNodeOfType(decl.init, 'Identifier')) {
+            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
@@ -109,16 +112,17 @@ export var createChecks = function createChecks(context) {
   var checkExportDefaultDeclaration = function checkExportDefaultDeclaration(node) {
     var exportName = '';
     var packageName = '';
-    if ('declaration' in node && node.declaration && isNodeOfType(node.declaration, 'Identifier') && node.declaration.name in legacyIconImports) {
+    if (Object.keys(node).includes('declaration') && node.declaration && isNodeOfType(node.declaration, 'Identifier') && Object.keys(legacyIconImports).includes(node.declaration.name)) {
       packageName = legacyIconImports[node.declaration.name].packageName;
       exportName = 'Default export';
-    } else if ('declaration' in node && node.declaration && isNodeOfType(node.declaration, 'AssignmentExpression') && isNodeOfType(node.declaration.left, 'Identifier') && isNodeOfType(node.declaration.right, 'Identifier') && node.declaration.right.name in legacyIconImports) {
+    } else if (Object.keys(node).includes('declaration') && node.declaration && isNodeOfType(node.declaration, 'AssignmentExpression') && isNodeOfType(node.declaration.left, 'Identifier') && isNodeOfType(node.declaration.right, 'Identifier') && Object.keys(legacyIconImports).includes(node.declaration.right.name)) {
       packageName = legacyIconImports[node.declaration.right.name].packageName;
       exportName = node.declaration.left.name;
     } else {
       return;
     }
     createCantMigrateReExportError(node, packageName, exportName, errorsManual);
+    addToListOfRanges(node, errorRanges);
     guidance[locToString(node)] = createGuidance(packageName);
   };
 
@@ -128,7 +132,7 @@ export var createChecks = function createChecks(context) {
    */
   var checkExportNamedVariables = function checkExportNamedVariables(node) {
     // export {default as AddIcon} from '@atlaskit/icon/glyph/add';
-    if (node.source && isNodeOfType(node.source, 'Literal') && 'value' in node.source) {
+    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) {
         return moduleSource.startsWith(val);
@@ -139,6 +143,7 @@ export var createChecks = function createChecks(context) {
           for (_iterator4.s(); !(_step4 = _iterator4.n()).done;) {
             var spec = _step4.value;
             createCantMigrateReExportError(spec, moduleSource, spec.exported.name, errorsManual);
+            addToListOfRanges(spec, errorRanges);
             guidance[locToString(spec)] = createGuidance(moduleSource);
           }
         } catch (err) {
@@ -154,8 +159,9 @@ export var createChecks = function createChecks(context) {
       try {
         for (_iterator5.s(); !(_step5 = _iterator5.n()).done;) {
           var decl = _step5.value;
-          if (isNodeOfType(decl, 'VariableDeclarator') && 'init' in decl && decl.init && isNodeOfType(decl.init, 'Identifier') && decl.init.name in legacyIconImports) {
+          if (isNodeOfType(decl, 'VariableDeclarator') && Object.keys(decl).includes('init') && decl.init && isNodeOfType(decl.init, 'Identifier') && Object.keys(legacyIconImports).includes(decl.init.name)) {
             createCantMigrateReExportError(node, legacyIconImports[decl.init.name].packageName, decl.init.name, errorsManual);
+            addToListOfRanges(node, errorRanges);
             guidance[locToString(node)] = createGuidance(legacyIconImports[decl.init.name].packageName);
           }
         }
@@ -176,13 +182,14 @@ export var createChecks = function createChecks(context) {
       try {
         for (_iterator6.s(); !(_step6 = _iterator6.n()).done;) {
           var _spec2 = _step6.value;
-          if (_spec2.local.name in legacyIconImports) {
+          if (Object.keys(legacyIconImports).includes(_spec2.local.name)) {
             //update legacy imports to be exported
             legacyIconImports[_spec2.local.name] = {
               packageName: legacyIconImports[_spec2.local.name].packageName,
               exported: true
             };
             createCantMigrateReExportError(_spec2, legacyIconImports[_spec2.local.name].packageName, _spec2.exported.name, errorsManual);
+            addToListOfRanges(_spec2, errorRanges);
             guidance[locToString(_spec2)] = createGuidance(legacyIconImports[_spec2.local.name].packageName);
           }
         }
@@ -202,8 +209,9 @@ export var createChecks = function createChecks(context) {
     if (!isNodeOfType(node, 'Identifier')) {
       return;
     }
-    if (node.name && node.name in legacyIconImports && legacyIconImports[node.name].packageName) {
-      createCantMigrateIdentifierError(node, legacyIconImports[node.name].packageName, node.name, errorsManual);
+    if (node.name && Object.keys(legacyIconImports).includes(node.name) && legacyIconImports[node.name].packageName) {
+      createCantMigrateIdentifierMapOrArrayError(node, legacyIconImports[node.name].packageName, node.name, errorsManual);
+      addToListOfRanges(node, errorRanges);
       guidance[locToString(node)] = createGuidance(legacyIconImports[node.name].packageName);
     }
   };
@@ -222,24 +230,44 @@ export var createChecks = function createChecks(context) {
     if (!isNodeOfType(node.parent, 'JSXExpressionContainer') || !isNodeOfType(node.parent.parent, 'JSXAttribute') || !isNodeOfType(node.parent.parent.parent, 'JSXOpeningElement')) {
       return;
     }
-    if (node.name in legacyIconImports && isNodeOfType(node.parent.parent.name, 'JSXIdentifier') && node.parent.parent.name.name !== 'LEGACY_fallbackIcon') {
+    if (Object.keys(legacyIconImports).includes(node.name) && isNodeOfType(node.parent.parent.name, 'JSXIdentifier') && node.parent.parent.name.name !== 'LEGACY_fallbackIcon') {
       var _migrationMapObject$s;
       var migrationMapObject = getMigrationMapObject(legacyIconImports[node.name].packageName);
+      var upcomingIcon = getUpcomingIcons(legacyIconImports[node.name].packageName);
       var newIcon = migrationMapObject === null || migrationMapObject === void 0 ? void 0 : migrationMapObject.newIcon;
-      var isNewIconMigratable = canAutoMigrateNewIconBasedOnSize(migrationMapObject === null || migrationMapObject === void 0 || (_migrationMapObject$s = migrationMapObject.sizeGuidance) === null || _migrationMapObject$s === void 0 ? void 0 : _migrationMapObject$s.medium);
+      var isNewIconMigratable = canAutoMigrateNewIconBasedOnSize(upcomingIcon ? upcomingIcon.sizeGuidance.medium : migrationMapObject === null || migrationMapObject === void 0 || (_migrationMapObject$s = migrationMapObject.sizeGuidance) === null || _migrationMapObject$s === void 0 ? void 0 : _migrationMapObject$s.medium);
       var isInNewButton = isNodeOfType(node.parent.parent.parent.name, 'JSXIdentifier') && newButtonImports.has(node.parent.parent.parent.name.name);
-      if (newIcon && isInNewButton && isNewIconMigratable) {
+      if (newIcon && isInNewButton && isNewIconMigratable || upcomingIcon && isInNewButton && isNewIconMigratable) {
         createAutoMigrationError(node, legacyIconImports[node.name].packageName, node.name, errorsAuto);
+        addToListOfRanges(node, errorRanges);
         guidance[locToString(node)] = createGuidance(legacyIconImports[node.name].packageName, isInNewButton, 'medium');
-      } else if (!newIcon || !isNewIconMigratable) {
+      } else if (!newIcon && !upcomingIcon || !isNewIconMigratable) {
         createCantFindSuitableReplacementError(node, legacyIconImports[node.name].packageName, node.name, errorsManual);
+        addToListOfRanges(node, errorRanges);
         guidance[locToString(node)] = createGuidance(legacyIconImports[node.name].packageName, isInNewButton);
       } else if (!isInNewButton) {
         createCantMigrateFunctionUnknownError(node, legacyIconImports[node.name].packageName, node.name, errorsManual);
+        addToListOfRanges(node, errorRanges);
         guidance[locToString(node)] = createGuidance(legacyIconImports[node.name].packageName, isInNewButton);
       }
     }
   };
+  var checkIconReference = function checkIconReference(node) {
+    //check the reference to see if it's a legacy icon, if not exit early
+    if (!Object.keys(legacyIconImports).includes(node.name)) {
+      return;
+    }
+    //if this is an import statement then exit early
+    if (node.parent && (isNodeOfType(node.parent, 'ImportSpecifier') || isNodeOfType(node.parent, 'ImportDefaultSpecifier'))) {
+      return;
+    }
+    //if in Fallback prop, do not error
+    if (node.parent && node.parent.parent && isNodeOfType(node.parent.parent, 'JSXAttribute') && isNodeOfType(node.parent.parent.name, 'JSXIdentifier') && node.parent.parent.name.name === 'LEGACY_fallbackIcon') {
+      return;
+    }
+    // manually error
+    createCantMigrateIdentifierError(node, legacyIconImports[node.name].packageName, node.name, errorsManual);
+  };
 
   /**
    * Checks if a legacy icon is being rendered and stores the errors in the global array
@@ -257,8 +285,8 @@ export var createChecks = function createChecks(context) {
     }
     var name = node.openingElement.name.name;
     // Legacy icons rendered as JSX elements
-    if (name in legacyIconImports) {
-      var _node$parent2, _node$parent3, _size;
+    if (Object.keys(legacyIconImports).includes(name)) {
+      var _node$parent2, _node$parent3, _size, _size2;
       // Determine if inside a new button - if so:
       // - Assume spread props are safe - still error if props explicitly set to unmigratable values
       var insideNewButton = false;
@@ -342,13 +370,15 @@ export var createChecks = function createChecks(context) {
         hasManualMigration = true;
       }
       var migrationMapObject = getMigrationMapObject(legacyIconImports[name].packageName);
+      var upcomingIcon = getUpcomingIcons(legacyIconImports[name].packageName);
       var newIcon = migrationMapObject === null || migrationMapObject === void 0 ? void 0 : migrationMapObject.newIcon;
-      var isNewIconMigratable = canAutoMigrateNewIconBasedOnSize(migrationMapObject === null || migrationMapObject === void 0 ? void 0 : migrationMapObject.sizeGuidance[(_size = size) !== null && _size !== void 0 ? _size : 'medium']);
-      if (!hasManualMigration && newIcon && isNewIconMigratable) {
+      var isNewIconMigratable = canAutoMigrateNewIconBasedOnSize(upcomingIcon ? upcomingIcon.sizeGuidance[(_size = size) !== null && _size !== void 0 ? _size : 'medium'] : migrationMapObject === null || migrationMapObject === void 0 ? void 0 : migrationMapObject.sizeGuidance[(_size2 = size) !== null && _size2 !== void 0 ? _size2 : 'medium']);
+      if (!hasManualMigration && (newIcon || upcomingIcon) && isNewIconMigratable) {
         createAutoMigrationError(node, legacyIconImports[name].packageName, name, errorsAuto);
-      } else if ((!newIcon || !isNewIconMigratable) && size) {
-        createCantFindSuitableReplacementError(node, legacyIconImports[name].packageName, name, errorsManual, migrationMapObject ? true : false);
+      } else if ((!newIcon && !upcomingIcon || !isNewIconMigratable) && size) {
+        createCantFindSuitableReplacementError(node, legacyIconImports[name].packageName, name, errorsManual, upcomingIcon ? true : migrationMapObject ? true : false);
       }
+      addToListOfRanges(node, errorRanges);
       guidance[locToString(node)] = createGuidance(legacyIconImports[name].packageName, insideNewButton, size && isSize(size) ? size : undefined);
     }
   };
@@ -358,14 +388,15 @@ export var createChecks = function createChecks(context) {
    * @param node The function call node found by ESLint
    */
   var checkCallExpression = function checkCallExpression(node) {
-    if ('arguments' in node && node.arguments.length) {
+    if (Object.keys(node).includes('arguments') && node.arguments.length) {
       var _iterator8 = _createForOfIteratorHelper(node.arguments),
         _step8;
       try {
         for (_iterator8.s(); !(_step8 = _iterator8.n()).done;) {
           var arg = _step8.value;
-          if (isNodeOfType(arg, 'Identifier') && arg.name in legacyIconImports && legacyIconImports[arg.name].packageName) {
+          if (isNodeOfType(arg, 'Identifier') && Object.keys(legacyIconImports).includes(arg.name) && legacyIconImports[arg.name].packageName) {
             createCantMigrateFunctionUnknownError(node, legacyIconImports[arg.name].packageName, arg.name, errorsManual);
+            addToListOfRanges(node, errorRanges);
             guidance[locToString(node)] = createGuidance(legacyIconImports[arg.name].packageName);
           }
         }
@@ -386,30 +417,41 @@ export var createChecks = function createChecks(context) {
         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;
-        if (node) {
-          var guidanceMessage = _key in guidance ? 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 _iterator9 = _createForOfIteratorHelper(errorList.errors),
-              _step9;
-            try {
-              for (_iterator9.s(); !(_step9 = _iterator9.n()).done;) {
-                var error = _step9.value;
-                context.report(error);
+        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 _iterator9 = _createForOfIteratorHelper(errorList.errors),
+                _step9;
+              try {
+                for (_iterator9.s(); !(_step9 = _iterator9.n()).done;) {
+                  var error = _step9.value;
+                  if ('messageId' in error && (error.messageId !== 'cantMigrateIdentifier' || error.messageId === 'cantMigrateIdentifier' && !isInRange)) {
+                    context.report(error);
+                  }
+                }
+              } catch (err) {
+                _iterator9.e(err);
+              } finally {
+                _iterator9.f();
               }
-            } catch (err) {
-              _iterator9.e(err);
-            } finally {
-              _iterator9.f();
             }
           }
         }
@@ -422,14 +464,19 @@ export var createChecks = function createChecks(context) {
           _error = _Object$entries2$_i[1];
         // If there's a manual error that exists for this same component,
         // don't throw the auto error
-        if (_key2 in errorsManual) {
-          delete errorsAuto[_key2];
-          continue;
+        if (Object.keys(errorsManual).includes(_key2)) {
+          var _cantMigrateIdentifierError = errorsManual[_key2].errors.find(function (x) {
+            return 'messageId' in x && x.messageId === 'cantMigrateIdentifier';
+          });
+          if (!_cantMigrateIdentifierError || _cantMigrateIdentifierError && errorsManual[_key2].errors.length > 1) {
+            delete errorsAuto[_key2];
+            continue;
+          }
         }
-        var _node = 'node' in _error ? _error.node : null;
-        if (_node) {
-          var _guidanceMessage = _key2 in guidance ? guidance[_key2] : '';
-          if ('data' in _error && _error.data) {
+        var _node2 = 'node' in _error ? _error.node : null;
+        if (_node2) {
+          var _guidanceMessage = Object.keys(guidance).includes(_key2) ? guidance[_key2] : '';
+          if (Object.keys(_error).includes('data') && _error.data) {
             _error.data.guidance = _guidanceMessage;
           }
           context.report(_error);
@@ -446,6 +493,7 @@ export var createChecks = function createChecks(context) {
     checkIconAsProp: checkIconAsProp,
     checkJSXElement: checkJSXElement,
     checkCallExpression: checkCallExpression,
-    throwErrors: throwErrors
+    throwErrors: throwErrors,
+    checkIconReference: checkIconReference
   };
 };

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

@@ -2,6 +2,7 @@ import _slicedToArray from "@babel/runtime/helpers/slicedToArray";
 import { isNodeOfType } 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';
 var sizes = ['small', 'medium', 'large', 'xlarge'];
 export var isSize = function isSize(size) {
   return sizes.includes(size);
@@ -14,11 +15,26 @@ export var isSize = function isSize(size) {
  */
 export var getMigrationMapObject = function getMigrationMapObject(iconPackage) {
   var key = getIconKey(iconPackage);
-  if (key in baseMigrationMap) {
+  if (Object.keys(baseMigrationMap).includes(key)) {
     return baseMigrationMap[key];
   }
   return null;
 };
+export var getUpcomingIcons = function getUpcomingIcons(iconPackage) {
+  var key = getIconKey(iconPackage);
+  if (upcomingIcons.includes(key)) {
+    var retval = {
+      sizeGuidance: {
+        small: 'swap',
+        medium: 'swap',
+        large: 'icon-tile',
+        xlarge: 'icon-tile'
+      }
+    };
+    return retval;
+  }
+  return null;
+};
 
 /**
  * Returns the key of a legacy icon
@@ -44,42 +60,67 @@ 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;
   var migrationMapObject = getMigrationMapObject(iconPackage);
-  if (migrationMapObject) {
+  var upcomingIcon = getUpcomingIcons(iconPackage);
+  if (upcomingIcon) {
+    var guidance = '';
+    if (size) {
+      if (upcomingIcon.sizeGuidance[size] && canAutoMigrateNewIconBasedOnSize(upcomingIcon.sizeGuidance[size])) {
+        guidance += "Fix: An upcoming icon release is planned to migrate this legacy icon.";
+      } else {
+        guidance += "No equivalent icon for this size, ".concat(size, ", in the current or upcoming set of icons.");
+      }
+      guidance += "".concat(Object.keys(migrationOutcomeDescriptionMap).includes(upcomingIcon.sizeGuidance[size]) ? " Once the upcoming icons are released, please: ".concat(migrationOutcomeDescriptionMap[upcomingIcon.sizeGuidance[size]]) : ' No migration size advice given.', "\n");
+    } else {
+      guidance = "Please wait for the upcoming icons released, as it will contain an alternative for this legacy icon.\nMigration suggestions, depending on the legacy icon size:\n";
+      for (var _i = 0, _Object$entries = Object.entries(upcomingIcon.sizeGuidance); _i < _Object$entries.length; _i++) {
+        var _Object$entries$_i = _slicedToArray(_Object$entries[_i], 2),
+          _size = _Object$entries$_i[0],
+          value = _Object$entries$_i[1];
+        guidance += "\t- ".concat(_size, ": ");
+        if (!Object.keys(migrationOutcomeDescriptionMap).includes(value)) {
+          guidance += 'No migration advice given.\n';
+        } else {
+          guidance += "".concat(migrationOutcomeDescriptionMap[value], ".\n");
+        }
+      }
+    }
+    return guidance;
+  } else if (migrationMapObject) {
     var newIcon = migrationMapObject.newIcon;
     if (!newIcon) {
       return 'No equivalent icon in new set. An option is to contribute a custom icon into icon-labs package instead.\n';
     }
     var buttonGuidanceStr = "Please set 'spacing' property of the new icon to 'none', to ensure appropriate spacing inside `@atlaskit/button`.\n";
-    var guidance = '';
+    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(newIcon.name, " from ").concat(newIcon.package, "/").concat(newIcon.type, "/").concat(newIcon.name, " instead.");
       } else {
-        guidance += "No equivalent icon for this size, ".concat(size, ", in new set.");
+        _guidance += "No equivalent icon for this size, ".concat(size, ", in new set.");
       }
-      guidance += "".concat(migrationMapObject.sizeGuidance[size] in migrationOutcomeDescriptionMap ? " Please: ".concat(migrationOutcomeDescriptionMap[migrationMapObject.sizeGuidance[size]]) : ' No migration size advice given.', "\n");
+      _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");
+      _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 += "\t- ".concat(size, ": ");
-        if (!(value in migrationOutcomeDescriptionMap)) {
-          guidance += 'No migration advice given.\n';
+        _guidance += "\t- ".concat(size, ": ");
+        if (!Object.keys(migrationOutcomeDescriptionMap).includes(value)) {
+          _guidance += 'No migration advice given.\n';
         } else {
-          guidance += "".concat(migrationOutcomeDescriptionMap[value], ".\n");
+          _guidance += "".concat(migrationOutcomeDescriptionMap[value], ".\n");
         }
       });
     }
     if (insideNewButton) {
-      guidance += buttonGuidanceStr;
+      _guidance += buttonGuidanceStr;
     } else if (size && size === 'medium') {
-      guidance += "Setting the spacing property to 'spacious' will maintain the icon's box dimensions - but consider setting spacing='none' as it allows for easier control of spacing by parent elements.\n";
+      _guidance += "Setting the spacing property to 'spacious' will maintain the icon's box dimensions - but consider setting spacing='none' as it allows for easier control of spacing by parent elements.\n";
     } else if (size) {
-      guidance += "In the new icon, please use spacing='none'.\n";
+      _guidance += "In the new icon, please use spacing='none'.\n";
     }
-    return guidance;
+    return _guidance;
   } else {
     return "Migration suggestions not found for \"".concat(iconPackage, "\".\n");
   }
@@ -104,8 +145,11 @@ export var canMigrateColor = function canMigrateColor(color) {
   }
 };
 export var locToString = function locToString(node) {
-  var _node$loc, _node$loc2, _node$loc3, _node$loc4;
-  return "".concat((_node$loc = node.loc) === null || _node$loc === void 0 ? void 0 : _node$loc.start.line, ":").concat((_node$loc2 = node.loc) === null || _node$loc2 === void 0 ? void 0 : _node$loc2.start.column, ":").concat((_node$loc3 = node.loc) === null || _node$loc3 === void 0 ? void 0 : _node$loc3.end.line, ":").concat((_node$loc4 = node.loc) === null || _node$loc4 === void 0 ? void 0 : _node$loc4.end.column);
+  if (node.range && node.range.length >= 2) {
+    return "".concat(node.range[0], ":").concat(node.range[1]);
+  } else {
+    return '';
+  }
 };
 export var createCantMigrateReExportError = function createCantMigrateReExportError(node, packageName, exportName, errors) {
   var myError = {
@@ -118,10 +162,10 @@ export var createCantMigrateReExportError = function createCantMigrateReExportEr
   };
   pushManualError(locToString(node), errors, myError, packageName, exportName);
 };
-export var createCantMigrateIdentifierError = function createCantMigrateIdentifierError(node, packageName, exportName, errors) {
+export var createCantMigrateIdentifierMapOrArrayError = function createCantMigrateIdentifierMapOrArrayError(node, packageName, exportName, errors) {
   var myError = {
     node: node,
-    messageId: 'cantMigrateIdentifier',
+    messageId: 'cantMigrateIdentifierMapOrArray',
     data: {
       packageName: packageName,
       exportName: exportName
@@ -129,6 +173,17 @@ export var createCantMigrateIdentifierError = function createCantMigrateIdentifi
   };
   pushManualError(locToString(node), errors, myError, packageName, exportName);
 };
+export var createCantMigrateIdentifierError = function createCantMigrateIdentifierError(node, packageName, exportName, errors) {
+  var myError = {
+    node: node,
+    messageId: 'cantMigrateIdentifier',
+    data: {
+      iconSource: packageName,
+      iconName: exportName
+    }
+  };
+  pushManualError(locToString(node), errors, myError, packageName, exportName);
+};
 export var createCantFindSuitableReplacementError = function createCantFindSuitableReplacementError(node, importSource, iconName, errors, sizeIssue) {
   var myError = {
     node: node,
@@ -191,7 +246,7 @@ export var createAutoMigrationError = function createAutoMigrationError(node, im
   errors[locToString(node)] = myError;
 };
 var pushManualError = function pushManualError(key, errors, myError, importSource, iconName) {
-  if (key in errors) {
+  if (Object.keys(errors).includes(key)) {
     errors[key].errors.push(myError);
   } else {
     errors[key] = {
@@ -239,7 +294,7 @@ export var createHelpers = function createHelpers(context) {
    * @returns defaultValue if the configuration flag is not set, the defaultValue of the configuration flag otherwise
    */
   var getConfigFlag = function getConfigFlag(key, defaultValue) {
-    if (context.options.length > 0 && context.options[0] && key in context.options[0]) {
+    if (context.options.length > 0 && context.options[0] && Object.keys(context.options[0]).includes(key)) {
       return context.options[0][key] === !defaultValue ? !defaultValue : defaultValue;
     }
     return defaultValue;
@@ -256,4 +311,22 @@ export var createHelpers = function createHelpers(context) {
     getTokenCallValue: getTokenCallValue,
     getConfigFlag: getConfigFlag
   };
+};
+export var addToListOfRanges = function addToListOfRanges(node, sortedListOfRangesForErrors) {
+  if (node.range && node.range.length >= 2) {
+    sortedListOfRangesForErrors.push({
+      start: node.range[0],
+      end: node.range[1]
+    });
+  }
+};
+export var isInRangeList = function isInRangeList(node, sortedListOfRangesForErrors) {
+  var range = node.range;
+  if (!range || range.length < 2) {
+    return false;
+  }
+  var found = sortedListOfRangesForErrors.find(function (currRange) {
+    return range[0] >= currRange.start && range[1] <= currRange.end;
+  });
+  return !!found;
 };

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

@@ -35,8 +35,8 @@ var rule = createLintRule({
       cantMigrateSpreadProps: "This usage of Icon uses spread props in a way that can't be automatically migrated. Please explicitly define the following props after spread: '{{missingProps}}' ",
       cantMigrateSizeUnknown: "This usage of Icon sets the size via a variable or function that can't be determined.",
       cantMigrateFunctionUnknown: "'{{iconName}}' from legacy '{{importSource}}' is used in unknown function/component. Please manually migrate this icon.",
-      cantMigrateIdentifier: "This icon is passed to other components via a map or array, in a way that can't be automatically migrated. Please manually migrate wherever this expression is used and use the icon components directly.",
-      cantMigrateUnsafeProp: "Property '{{propName}}' with value of '{{value}}' is unable to be auto-migrated to the new button. Please manually migrate this icon."
+      cantMigrateIdentifierMapOrArray: "This icon is passed to other components via a map or array, in a way that can't be automatically migrated. Please manually migrate wherever this expression is used and use the icon components directly.",
+      cantMigrateIdentifier: "This is a legacy icon, {{iconName}} from {{iconSource}}, being referenced. Please manually migrate."
     }
   },
   create: function create(context) {
@@ -52,7 +52,8 @@ var rule = createLintRule({
       checkIconAsProp = _createChecks.checkIconAsProp,
       checkJSXElement = _createChecks.checkJSXElement,
       checkCallExpression = _createChecks.checkCallExpression,
-      throwErrors = _createChecks.throwErrors;
+      throwErrors = _createChecks.throwErrors,
+      checkIconReference = _createChecks.checkIconReference;
     return errorBoundary({
       // Track imports of relevant components
       ImportDeclaration: checkImportDeclarations,
@@ -68,6 +69,7 @@ var rule = createLintRule({
       JSXElement: checkJSXElement,
       // Icons called as an argument of a function (i.e. icon={DefaultIcon(AddIcon)})
       CallExpression: checkCallExpression,
+      Identifier: checkIconReference,
       'Program:exit': throwErrors
     }, failSilently);
   }

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

@@ -0,0 +1 @@
+export var upcomingIcons = ['app-switcher', 'check-circle-outline', 'export', 'file', 'flag-filled', 'lightbulb-filled', 'lock-filled', 'menu-expand', 'menu', 'notification-direct', 'notification', 'people-group', 'people', 'refresh', 'switcher', 'editor/align-image-center', 'editor/align-image-left', 'editor/align-image-right', 'editor/background-color', 'editor/bold', 'editor/indent', 'editor/italic', 'editor/horizontal-rule', 'editor-layout-three-equal', 'editor-layout-three-with-sidebars', 'editor/layout-two-equal', 'editor/layout-two-left-sidebars', 'editor/layout-two-right-sidebar', 'editor/media-center', 'editor/media-full-width', 'editor/media-wide', 'editor/number-list', 'emoji/activity', 'editor/file', 'emoji/flags', 'emoji/food', 'emoji/nature', 'emoji/people', 'emoji/productivity', 'emoji/travel', 'bitbucket/repos'];

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

@@ -1,13 +1,16 @@
 import type { Rule } from 'eslint';
 import { type CallExpression, type ExportDefaultDeclaration, type ExportNamedDeclaration, type Identifier, type ImportDeclaration, type VariableDeclaration } from 'eslint-codemod-utils';
-export declare const createChecks: (context: Rule.RuleContext) => {
+type ReturnObject = {
     checkImportDeclarations: (node: ImportDeclaration & Rule.NodeParentExtension) => void;
     checkVariableDeclarations: (node: VariableDeclaration & Rule.NodeParentExtension) => void;
     checkExportDefaultDeclaration: (node: ExportDefaultDeclaration & Rule.NodeParentExtension) => void;
     checkExportNamedVariables: (node: ExportNamedDeclaration & Rule.NodeParentExtension) => void;
     checkArrayOrMap: (node: Identifier) => void;
     checkIconAsProp: (node: Identifier) => void;
+    checkIconReference: (node: Identifier & Rule.NodeParentExtension) => void;
     checkJSXElement: (node: Rule.Node) => void;
     checkCallExpression: (node: CallExpression & Rule.NodeParentExtension) => void;
     throwErrors: () => void;
 };
+export declare const createChecks: (context: Rule.RuleContext) => ReturnObject;
+export {};

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

@@ -1,17 +1,22 @@
 import type { Rule } from 'eslint';
 import { type JSXAttribute, type Node } from 'eslint-codemod-utils';
-export type iconMigrationError = Rule.ReportDescriptor;
-export type errorsListManual = {
+import { type IconMigrationSizeGuidance } from '@atlaskit/icon/UNSAFE_migration-map';
+export type IconMigrationError = Rule.ReportDescriptor;
+export type RangeList = {
+    start: number;
+    end: number;
+}[];
+export type ErrorListManual = {
     [loc: string]: {
-        errors: iconMigrationError[];
+        errors: IconMigrationError[];
         iconName: string;
         importSource: string;
     };
 };
-export type errorsListAuto = {
-    [loc: string]: iconMigrationError;
+export type ErrorListAuto = {
+    [loc: string]: IconMigrationError;
 };
-export type guidanceList = {
+export type GuidanceList = {
     [loc: string]: string;
 };
 declare const sizes: readonly ["small", "medium", "large", "xlarge"];
@@ -23,6 +28,9 @@ export declare const isSize: (size: any) => size is "small" | "medium" | "large"
  * @returns The migration map object for the legacy icon or null if not found
  */
 export declare const getMigrationMapObject: (iconPackage: string) => any;
+export declare const getUpcomingIcons: (iconPackage: string) => {
+    sizeGuidance: Record<Size, IconMigrationSizeGuidance>;
+} | null;
 /**
  * Checks if a new icon can be auto-migrated based on guidance from the migration map
  */
@@ -38,14 +46,15 @@ export declare const createGuidance: (iconPackage: string, insideNewButton?: boo
  */
 export declare const canMigrateColor: (color: string) => boolean;
 export declare const locToString: (node: Node) => string;
-export declare const createCantMigrateReExportError: (node: Node, packageName: string, exportName: string, errors: errorsListManual) => void;
-export declare const createCantMigrateIdentifierError: (node: Node, packageName: string, exportName: string, errors: errorsListManual) => void;
-export declare const createCantFindSuitableReplacementError: (node: Node, importSource: string, iconName: string, errors: errorsListManual, sizeIssue?: boolean) => void;
-export declare const createCantMigrateFunctionUnknownError: (node: Node, importSource: string, iconName: string, errors: errorsListManual) => void;
-export declare const createCantMigrateColorError: (node: Node, colorValue: string, errors: errorsListManual, importSource: string, iconName: string) => void;
-export declare const createCantMigrateSpreadPropsError: (node: Node, missingProps: string[], errors: errorsListManual, importSource: string, iconName: string) => void;
-export declare const createCantMigrateSizeUnknown: (node: Node, errors: errorsListManual, importSource: string, iconName: string) => void;
-export declare const createAutoMigrationError: (node: Node, importSource: string, iconName: string, errors: errorsListAuto) => void;
+export declare const createCantMigrateReExportError: (node: Node, packageName: string, exportName: string, errors: ErrorListManual) => void;
+export declare const createCantMigrateIdentifierMapOrArrayError: (node: Node, packageName: string, exportName: string, errors: ErrorListManual) => void;
+export declare const createCantMigrateIdentifierError: (node: Node, packageName: string, exportName: string, errors: ErrorListManual) => void;
+export declare const createCantFindSuitableReplacementError: (node: Node, importSource: string, iconName: string, errors: ErrorListManual, sizeIssue?: boolean) => void;
+export declare const createCantMigrateFunctionUnknownError: (node: Node, importSource: string, iconName: string, errors: ErrorListManual) => void;
+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 getLiteralStringValue: (value: any) => string | undefined;
 export declare const createHelpers: (context: Rule.RuleContext) => {
     /**
@@ -55,4 +64,6 @@ export declare const createHelpers: (context: Rule.RuleContext) => {
     getTokenCallValue: (value: any) => string | undefined;
     getConfigFlag: (key: string, defaultValue: boolean) => boolean;
 };
+export declare const addToListOfRanges: (node: Node, sortedListOfRangesForErrors: RangeList) => void;
+export declare const isInRangeList: (node: Node, sortedListOfRangesForErrors: RangeList) => boolean;
 export {};

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

@@ -0,0 +1 @@
+export declare const upcomingIcons: string[];