@atlaskit/eslint-plugin-design-system 10.12.4 → 10.13.0

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

@@ -1,5 +1,5 @@
 import { isNodeOfType } from 'eslint-codemod-utils';
-import { canAutoMigrateNewIconBasedOnSize, canMigrateColor, createAutoMigrationError, createCantFindSuitableReplacementError, createCantMigrateColorError, createCantMigrateFunctionUnknownError, createCantMigrateIdentifierError, createCantMigrateReExportError, createCantMigrateSizeUnknown, createCantMigrateSpreadPropsError, createGuidance, createHelpers, getMigrationMapObject, getUpcomingIcons, 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 const createChecks = context => {
   //create global variables to be shared by the checks
   const {
@@ -17,6 +17,9 @@ export const createChecks = context => {
   const shouldErrorForAutoMigration = getConfigFlag('shouldErrorForAutoMigration', true);
   const isQuietMode = getConfigFlag('quiet', false);
 
+  // Sorted list of ranges
+  let 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
@@ -56,8 +59,8 @@ export const createChecks = context => {
     if (isNodeOfType(node, 'VariableDeclaration')) {
       const isExported = node.parent && isNodeOfType(node.parent, 'ExportNamedDeclaration');
       for (const decl of node.declarations) {
-        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
@@ -77,16 +80,17 @@ export const createChecks = context => {
   const checkExportDefaultDeclaration = node => {
     let exportName = '';
     let 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);
   };
 
@@ -96,19 +100,21 @@ export const createChecks = context => {
    */
   const 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')) {
       const moduleSource = node.source.value;
       if (typeof moduleSource === 'string' && ['@atlaskit/icon/glyph/', '@atlaskit/icon-object/glyph/'].find(val => moduleSource.startsWith(val)) && node.specifiers.length) {
         for (const spec of node.specifiers) {
           createCantMigrateReExportError(spec, moduleSource, spec.exported.name, errorsManual);
+          addToListOfRanges(spec, errorRanges);
           guidance[locToString(spec)] = createGuidance(moduleSource);
         }
       }
     } else if (node.declaration && isNodeOfType(node.declaration, 'VariableDeclaration')) {
       // export const Icon = AddIcon;
       for (const decl of node.declaration.declarations) {
-        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);
         }
       }
@@ -120,13 +126,14 @@ export const createChecks = context => {
        * export { AddIcon, CrossIcon as default }
        */
       for (const spec of node.specifiers) {
-        if (spec.local.name in legacyIconImports) {
+        if (Object.keys(legacyIconImports).includes(spec.local.name)) {
           //update legacy imports to be exported
           legacyIconImports[spec.local.name] = {
             packageName: legacyIconImports[spec.local.name].packageName,
             exported: true
           };
           createCantMigrateReExportError(spec, legacyIconImports[spec.local.name].packageName, spec.exported.name, errorsManual);
+          addToListOfRanges(spec, errorRanges);
           guidance[locToString(spec)] = createGuidance(legacyIconImports[spec.local.name].packageName);
         }
       }
@@ -141,8 +148,9 @@ export const 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);
     }
   };
@@ -161,7 +169,7 @@ export const 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;
       const migrationMapObject = getMigrationMapObject(legacyIconImports[node.name].packageName);
       const upcomingIcon = getUpcomingIcons(legacyIconImports[node.name].packageName);
@@ -170,16 +178,35 @@ export const createChecks = context => {
       const isInNewButton = isNodeOfType(node.parent.parent.parent.name, 'JSXIdentifier') && newButtonImports.has(node.parent.parent.parent.name.name);
       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 && !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);
       }
     }
   };
+  const 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
@@ -197,7 +224,7 @@ export const createChecks = context => {
     }
     const name = node.openingElement.name.name;
     // Legacy icons rendered as JSX elements
-    if (name in legacyIconImports) {
+    if (Object.keys(legacyIconImports).includes(name)) {
       var _node$parent2, _node$parent2$parent, _node$parent3, _node$parent3$parent, _node$parent3$parent$, _size, _size2;
       // Determine if inside a new button - if so:
       // - Assume spread props are safe - still error if props explicitly set to unmigratable values
@@ -277,6 +304,7 @@ export const createChecks = context => {
       } 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);
     }
   };
@@ -286,10 +314,11 @@ export const createChecks = context => {
    * @param node The function call node found by ESLint
    */
   const checkCallExpression = node => {
-    if ('arguments' in node && node.arguments.length) {
+    if (Object.keys(node).includes('arguments') && node.arguments.length) {
       for (const arg of node.arguments) {
-        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);
         }
       }
@@ -303,20 +332,29 @@ export const createChecks = context => {
     if (shouldErrorForManualMigration) {
       for (const [key, errorList] of Object.entries(errorsManual)) {
         const node = 'node' in errorList.errors[0] ? errorList.errors[0].node : null;
+        const cantMigrateIdentifierError = errorList.errors.find(x => 'messageId' in x && x.messageId === 'cantMigrateIdentifier');
         if (node) {
-          const guidanceMessage = key in guidance ? guidance[key] : '';
-          context.report({
-            node,
-            messageId: 'noLegacyIconsManualMigration',
-            data: {
-              iconName: errorList.iconName,
-              importSource: errorList.importSource,
-              guidance: isQuietMode ? guidanceMessage : `${guidanceMessage}For more information see the below errors.\n`
-            }
-          });
-          if (!isQuietMode) {
-            for (const error of errorList.errors) {
-              context.report(error);
+          let isInRange = false;
+          if (cantMigrateIdentifierError && isInRangeList(node, errorRanges)) {
+            isInRange = true;
+          }
+          if (isInRange && errorList.errors.length - 1 > 0 || !isInRange && errorList.errors.length > 0) {
+            const guidanceMessage = Object.keys(guidance).includes(key) ? guidance[key] : '';
+            context.report({
+              node,
+              messageId: 'noLegacyIconsManualMigration',
+              data: {
+                iconName: errorList.iconName,
+                importSource: errorList.importSource,
+                guidance: isQuietMode ? guidanceMessage : `${guidanceMessage}For more information see the below errors.\n`
+              }
+            });
+            if (!isQuietMode) {
+              for (const error of errorList.errors) {
+                if ('messageId' in error && (error.messageId !== 'cantMigrateIdentifier' || error.messageId === 'cantMigrateIdentifier' && !isInRange)) {
+                  context.report(error);
+                }
+              }
             }
           }
         }
@@ -326,14 +364,17 @@ export const createChecks = context => {
       for (const [key, error] of Object.entries(errorsAuto)) {
         // If there's a manual error that exists for this same component,
         // don't throw the auto error
-        if (key in errorsManual) {
-          delete errorsAuto[key];
-          continue;
+        if (Object.keys(errorsManual).includes(key)) {
+          const cantMigrateIdentifierError = errorsManual[key].errors.find(x => 'messageId' in x && x.messageId === 'cantMigrateIdentifier');
+          if (!cantMigrateIdentifierError || cantMigrateIdentifierError && errorsManual[key].errors.length > 1) {
+            delete errorsAuto[key];
+            continue;
+          }
         }
         const node = 'node' in error ? error.node : null;
         if (node) {
-          const guidanceMessage = key in guidance ? guidance[key] : '';
-          if ('data' in error && error.data) {
+          const guidanceMessage = Object.keys(guidance).includes(key) ? guidance[key] : '';
+          if (Object.keys(error).includes('data') && error.data) {
             error.data.guidance = guidanceMessage;
           }
           context.report(error);
@@ -350,6 +391,7 @@ export const createChecks = context => {
     checkIconAsProp,
     checkJSXElement,
     checkCallExpression,
-    throwErrors
+    throwErrors,
+    checkIconReference
   };
 };

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

@@ -90,12 +90,12 @@ export const createGuidance = (iconPackage, insideNewButton = false, size) => {
       } else {
         guidance += `No equivalent icon for this size, ${size}, in new set.`;
       }
-      guidance += `${migrationMapObject.sizeGuidance[size] in migrationOutcomeDescriptionMap ? ` Please: ${migrationOutcomeDescriptionMap[migrationMapObject.sizeGuidance[size]]}` : ' No migration size advice given.'}\n`;
+      guidance += `${Object.keys(migrationOutcomeDescriptionMap).includes(migrationMapObject.sizeGuidance[size]) ? ` Please: ${migrationOutcomeDescriptionMap[migrationMapObject.sizeGuidance[size]]}` : ' No migration size advice given.'}\n`;
     } else {
       guidance = `Use ${newIcon.name} from ${newIcon.package}/${newIcon.type}/${newIcon.name} instead.\nMigration suggestions, depending on the legacy icon size:\n`;
       Object.entries(migrationMapObject.sizeGuidance).forEach(([size, value]) => {
         guidance += `\t- ${size}: `;
-        if (!(value in migrationOutcomeDescriptionMap)) {
+        if (!Object.keys(migrationOutcomeDescriptionMap).includes(value)) {
           guidance += 'No migration advice given.\n';
         } else {
           guidance += `${migrationOutcomeDescriptionMap[value]}.\n`;
@@ -121,12 +121,12 @@ export const createGuidance = (iconPackage, insideNewButton = false, size) => {
  * @returns True if the color can be migrated, false otherwise
  */
 export const canMigrateColor = color => {
-  if (color.match(/^color\.text$/)) {
-    return true;
-  } else if (color.match(/^color\.icon/)) {
+  if (color.match(/^color\.icon/)) {
     return true;
   } else if (color.match(/^color\.link/)) {
     return true;
+  } else if (color.match(/^color\.text/)) {
+    return true;
   } else if (color === 'currentColor') {
     return true;
   } else {
@@ -134,8 +134,11 @@ export const canMigrateColor = color => {
   }
 };
 export const locToString = node => {
-  var _node$loc, _node$loc2, _node$loc3, _node$loc4;
-  return `${(_node$loc = node.loc) === null || _node$loc === void 0 ? void 0 : _node$loc.start.line}:${(_node$loc2 = node.loc) === null || _node$loc2 === void 0 ? void 0 : _node$loc2.start.column}:${(_node$loc3 = node.loc) === null || _node$loc3 === void 0 ? void 0 : _node$loc3.end.line}:${(_node$loc4 = node.loc) === null || _node$loc4 === void 0 ? void 0 : _node$loc4.end.column}`;
+  if (node.range && node.range.length >= 2) {
+    return `${node.range[0]}:${node.range[1]}`;
+  } else {
+    return '';
+  }
 };
 export const createCantMigrateReExportError = (node, packageName, exportName, errors) => {
   const myError = {
@@ -148,10 +151,10 @@ export const createCantMigrateReExportError = (node, packageName, exportName, er
   };
   pushManualError(locToString(node), errors, myError, packageName, exportName);
 };
-export const createCantMigrateIdentifierError = (node, packageName, exportName, errors) => {
+export const createCantMigrateIdentifierMapOrArrayError = (node, packageName, exportName, errors) => {
   const myError = {
     node,
-    messageId: 'cantMigrateIdentifier',
+    messageId: 'cantMigrateIdentifierMapOrArray',
     data: {
       packageName,
       exportName
@@ -159,6 +162,17 @@ export const createCantMigrateIdentifierError = (node, packageName, exportName,
   };
   pushManualError(locToString(node), errors, myError, packageName, exportName);
 };
+export const createCantMigrateIdentifierError = (node, packageName, exportName, errors) => {
+  const myError = {
+    node,
+    messageId: 'cantMigrateIdentifier',
+    data: {
+      iconSource: packageName,
+      iconName: exportName
+    }
+  };
+  pushManualError(locToString(node), errors, myError, packageName, exportName);
+};
 export const createCantFindSuitableReplacementError = (node, importSource, iconName, errors, sizeIssue) => {
   const myError = {
     node,
@@ -221,7 +235,7 @@ export const createAutoMigrationError = (node, importSource, iconName, errors) =
   errors[locToString(node)] = myError;
 };
 const pushManualError = (key, errors, myError, importSource, iconName) => {
-  if (key in errors) {
+  if (Object.keys(errors).includes(key)) {
     errors[key].errors.push(myError);
   } else {
     errors[key] = {
@@ -269,7 +283,7 @@ export const createHelpers = context => {
    * @returns defaultValue if the configuration flag is not set, the defaultValue of the configuration flag otherwise
    */
   const 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;
@@ -288,4 +302,22 @@ export const createHelpers = context => {
     getTokenCallValue,
     getConfigFlag
   };
+};
+export const addToListOfRanges = (node, sortedListOfRangesForErrors) => {
+  if (node.range && node.range.length >= 2) {
+    sortedListOfRangesForErrors.push({
+      start: node.range[0],
+      end: node.range[1]
+    });
+  }
+};
+export const isInRangeList = (node, sortedListOfRangesForErrors) => {
+  const {
+    range
+  } = node;
+  if (!range || range.length < 2) {
+    return false;
+  }
+  const found = sortedListOfRangesForErrors.find(currRange => range[0] >= currRange.start && range[1] <= currRange.end);
+  return !!found;
 };

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

@@ -35,8 +35,8 @@ const 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(context) {
@@ -53,7 +53,8 @@ const rule = createLintRule({
       checkIconAsProp,
       checkJSXElement,
       checkCallExpression,
-      throwErrors
+      throwErrors,
+      checkIconReference
     } = createChecks(context);
     return errorBoundary({
       // Track imports of relevant components
@@ -70,6 +71,7 @@ const 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/es2019/rules/use-heading/config/index.js

@@ -1,7 +1,8 @@
 const defaults = {
   failSilently: false,
   patterns: ['native-elements'],
-  enableUnsafeAutofix: false
+  enableUnsafeAutofix: false,
+  enableUnsafeReport: false
 };
 export const getConfig = overrides => {
   return Object.assign({}, defaults, overrides);

package/dist/es2019/rules/use-heading/transformers/native-elements.js

@@ -17,65 +17,96 @@ export const NativeElements = {
     config
   }) {
     // Check whether all criteria needed to make a transformation are met
-    if (!NativeElements._check(node, {
-      context,
-      config
-    })) {
-      return;
-    }
-    const fix = NativeElements._fix(node, {
+    const {
+      success,
+      autoFixable
+    } = NativeElements._check(node, {
       context,
       config
     });
-    context.report({
-      node,
-      messageId: 'preferHeading',
-      ...(config.enableUnsafeAutofix ? {
-        fix
-      } : {
-        suggest: [{
-          desc: `Convert to Heading`,
+    if (success && autoFixable) {
+      const fix = NativeElements._fix(node, {
+        context,
+        config
+      });
+      context.report({
+        node,
+        messageId: 'preferHeading',
+        ...(config.enableUnsafeAutofix ? {
           fix
-        }]
-      })
-    });
+        } : {
+          suggest: [{
+            desc: `Convert to Heading`,
+            fix
+          }]
+        })
+      });
+    } else if (success && config.enableUnsafeReport) {
+      context.report({
+        node,
+        messageId: 'preferHeading'
+      });
+    }
   },
   _check(node, {
     config
   }) {
     if (!config.patterns.includes('native-elements')) {
-      return false;
+      return {
+        success: false
+      };
     }
     if (!isNodeOfType(node, 'JSXElement')) {
-      return false;
+      return {
+        success: false
+      };
     }
     if (!node.children.length) {
-      return false;
-    }
-    if (!node.parent) {
-      return false;
+      return {
+        success: false
+      };
     }
     const elementName = ast.JSXElement.getName(node);
     if (!Object.keys(tagSizeMap).includes(elementName)) {
-      return false;
+      return {
+        success: false
+      };
+    }
+    if (!node.parent) {
+      return {
+        success: true,
+        autoFixable: false
+      };
     }
 
     // Element has to be first element of its siblings
     if (!(isNodeOfType(node.parent, 'JSXElement') || isNodeOfType(node.parent, 'JSXFragment'))) {
-      return false;
+      return {
+        success: true,
+        autoFixable: false
+      };
     }
     const siblings = ast.JSXElement.getChildren(node.parent);
     if (siblings.length > 1) {
       var _siblings$0$range, _node$range, _siblings$0$range2, _node$range2;
       // Only report if element is first child element
       if (((_siblings$0$range = siblings[0].range) === null || _siblings$0$range === void 0 ? void 0 : _siblings$0$range[0]) !== ((_node$range = node.range) === null || _node$range === void 0 ? void 0 : _node$range[0]) || ((_siblings$0$range2 = siblings[0].range) === null || _siblings$0$range2 === void 0 ? void 0 : _siblings$0$range2[1]) !== ((_node$range2 = node.range) === null || _node$range2 === void 0 ? void 0 : _node$range2[1])) {
-        return false;
+        return {
+          success: true,
+          autoFixable: false
+        };
       }
     }
     if (!ast.JSXElement.hasAllowedAttrsOnly(node, allowedAttrs)) {
-      return false;
+      return {
+        success: true,
+        autoFixable: false
+      };
     }
-    return true;
+    return {
+      success: true,
+      autoFixable: true
+    };
   },
   _fix(node, {
     context

package/dist/es2019/rules/use-primitives-text/config/index.js

@@ -2,7 +2,8 @@ const defaults = {
   failSilently: false,
   patterns: ['paragraph-elements', 'span-elements', 'strong-elements', 'emphasis-elements'],
   inheritColor: false,
-  enableUnsafeAutofix: false
+  enableUnsafeAutofix: false,
+  enableUnsafeReport: false
 };
 export const getConfig = overrides => {
   return Object.assign({}, defaults, overrides);

package/dist/es2019/rules/use-primitives-text/transformers/emphasis-elements.js

@@ -13,55 +13,78 @@ export const EmphasisElements = {
     }
 
     // Check whether all criteria needed to make a transformation are met
-    if (!EmphasisElements._check(node, {
-      context,
-      config
-    })) {
-      return;
-    }
-    const fix = EmphasisElements._fix(node, {
+    const {
+      success,
+      autoFixable
+    } = EmphasisElements._check(node, {
       context,
       config
     });
-    context.report({
-      node: node.openingElement,
-      messageId: 'preferPrimitivesText',
-      ...(config.enableUnsafeAutofix ? {
-        fix
-      } : {
-        suggest: [{
-          desc: `Convert to Text`,
+    if (success && autoFixable) {
+      const fix = EmphasisElements._fix(node, {
+        context,
+        config
+      });
+      context.report({
+        node: node.openingElement,
+        messageId: 'preferPrimitivesText',
+        ...(config.enableUnsafeAutofix ? {
           fix
-        }]
-      })
-    });
+        } : {
+          suggest: [{
+            desc: `Convert to Text`,
+            fix
+          }]
+        })
+      });
+    } else if (success && config.enableUnsafeReport) {
+      context.report({
+        node: node.openingElement,
+        messageId: 'preferPrimitivesText'
+      });
+    }
   },
   _check(node, {
     context,
     config
   }) {
     if (!config.patterns.includes('emphasis-elements')) {
-      return false;
+      return {
+        success: false
+      };
     }
     const elementName = ast.JSXElement.getName(node);
     if (elementName !== 'em') {
-      return false;
+      return {
+        success: false
+      };
     }
     if (!node.children.length) {
-      return false;
+      return {
+        success: false
+      };
     }
 
     // Element has no unallowed props
     if (!ast.JSXElement.hasAllowedAttrsOnly(node, allowedAttrs)) {
-      return false;
+      return {
+        success: true,
+        autoFixable: false
+      };
     }
 
     // If there is more than one `@atlaskit/primitives` import, then it becomes difficult to determine which import to transform
     const importDeclaration = ast.Root.findImportsByModule(context.getSourceCode().ast.body, '@atlaskit/primitives');
     if (importDeclaration.length > 1) {
-      return false;
+      return {
+        success: true,
+        autoFixable: false
+      };
     }
-    return true;
+    return {
+      success: true,
+      autoFixable: true
+    };
   },
   _fix(node, {
     context,