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

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

@@ -16,53 +16,75 @@ export var EmphasisElements = {
     }
 
     // Check whether all criteria needed to make a transformation are met
-    if (!EmphasisElements._check(node, {
-      context: context,
-      config: config
-    })) {
-      return;
-    }
-    var fix = EmphasisElements._fix(node, {
-      context: context,
-      config: config
-    });
-    context.report(_objectSpread({
-      node: node.openingElement,
-      messageId: 'preferPrimitivesText'
-    }, config.enableUnsafeAutofix ? {
-      fix: fix
-    } : {
-      suggest: [{
-        desc: "Convert to Text",
+    var _EmphasisElements$_ch = EmphasisElements._check(node, {
+        context: context,
+        config: config
+      }),
+      success = _EmphasisElements$_ch.success,
+      autoFixable = _EmphasisElements$_ch.autoFixable;
+    if (success && autoFixable) {
+      var fix = EmphasisElements._fix(node, {
+        context: context,
+        config: config
+      });
+      context.report(_objectSpread({
+        node: node.openingElement,
+        messageId: 'preferPrimitivesText'
+      }, config.enableUnsafeAutofix ? {
         fix: fix
-      }]
-    }));
+      } : {
+        suggest: [{
+          desc: "Convert to Text",
+          fix: fix
+        }]
+      }));
+    } else if (success && config.enableUnsafeReport) {
+      context.report({
+        node: node.openingElement,
+        messageId: 'preferPrimitivesText'
+      });
+    }
   },
   _check: function _check(node, _ref2) {
     var context = _ref2.context,
       config = _ref2.config;
     if (!config.patterns.includes('emphasis-elements')) {
-      return false;
+      return {
+        success: false
+      };
     }
     var 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
     var 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: function _fix(node, _ref3) {
     var context = _ref3.context,

package/dist/esm/rules/use-primitives-text/transformers/paragraph-elements.js

@@ -21,55 +21,60 @@ export var ParagraphElements = {
         config: config
       }),
       success = _ParagraphElements$_c.success,
+      autoFixable = _ParagraphElements$_c.autoFixable,
       refs = _ParagraphElements$_c.refs;
-    if (!success) {
-      return;
-    }
-    if (refs.siblings.length > 1) {
-      var _refs$siblings$0$loc, _refs$siblings$loc;
-      /**
-       * Highlighting from first opening element to last closing element
-       * to indicate fix will change all p elements and wrap them in a Stack,
-       * falls back to first opening element.
-       */
-      var startLoc = (_refs$siblings$0$loc = refs.siblings[0].loc) === null || _refs$siblings$0$loc === void 0 ? void 0 : _refs$siblings$0$loc.start;
-      var endLoc = (_refs$siblings$loc = refs.siblings[refs.siblings.length - 1].loc) === null || _refs$siblings$loc === void 0 ? void 0 : _refs$siblings$loc.end;
-      var fix = ParagraphElements._fixMultiple(node, {
-        context: context,
-        config: config,
-        refs: refs
-      });
-      context.report(_objectSpread({
-        loc: startLoc && endLoc && {
-          start: startLoc,
-          end: endLoc
-        },
-        node: node.openingElement,
-        messageId: 'preferPrimitivesStackedText'
-      }, config.enableUnsafeAutofix ? {
-        fix: fix
-      } : {
-        suggest: [{
-          desc: "Convert to Text and Stack",
+    if (success && autoFixable) {
+      if (refs.siblings.length > 1) {
+        var _refs$siblings$0$loc, _refs$siblings$loc;
+        /**
+         * Highlighting from first opening element to last closing element
+         * to indicate fix will change all p elements and wrap them in a Stack,
+         * falls back to first opening element.
+         */
+        var startLoc = (_refs$siblings$0$loc = refs.siblings[0].loc) === null || _refs$siblings$0$loc === void 0 ? void 0 : _refs$siblings$0$loc.start;
+        var endLoc = (_refs$siblings$loc = refs.siblings[refs.siblings.length - 1].loc) === null || _refs$siblings$loc === void 0 ? void 0 : _refs$siblings$loc.end;
+        var fix = ParagraphElements._fixMultiple(node, {
+          context: context,
+          config: config,
+          refs: refs
+        });
+        context.report(_objectSpread({
+          loc: startLoc && endLoc && {
+            start: startLoc,
+            end: endLoc
+          },
+          node: node.openingElement,
+          messageId: 'preferPrimitivesStackedText'
+        }, config.enableUnsafeAutofix ? {
           fix: fix
-        }]
-      }));
-    } else {
-      var _fix = ParagraphElements._fixSingle(node, {
-        context: context,
-        config: config
-      });
-      context.report(_objectSpread({
-        node: node,
-        messageId: 'preferPrimitivesText'
-      }, config.enableUnsafeAutofix ? {
-        fix: _fix
-      } : {
-        suggest: [{
-          desc: "Convert to Text",
+        } : {
+          suggest: [{
+            desc: "Convert to Text and Stack",
+            fix: fix
+          }]
+        }));
+      } else {
+        var _fix = ParagraphElements._fixSingle(node, {
+          context: context,
+          config: config
+        });
+        context.report(_objectSpread({
+          node: node.openingElement,
+          messageId: 'preferPrimitivesText'
+        }, config.enableUnsafeAutofix ? {
           fix: _fix
-        }]
-      }));
+        } : {
+          suggest: [{
+            desc: "Convert to Text",
+            fix: _fix
+          }]
+        }));
+      }
+    } else if (success && config.enableUnsafeReport) {
+      context.report({
+        node: node.openingElement,
+        messageId: 'preferPrimitivesText'
+      });
     }
   },
   _check: function _check(node, _ref2) {
@@ -104,7 +109,8 @@ export var ParagraphElements = {
     // All siblings have to be paragraph elements with no unallowed props
     if (!isNodeOfType(node.parent, 'JSXElement')) {
       return {
-        success: false,
+        success: true,
+        autoFixable: false,
         refs: {
           siblings: []
         }
@@ -116,7 +122,8 @@ export var ParagraphElements = {
       // Only report for the first p element by comparing node location
       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 {
-          success: false,
+          success: true,
+          autoFixable: false,
           refs: {
             siblings: siblings
           }
@@ -134,7 +141,8 @@ export var ParagraphElements = {
       });
       if (!siblingsMatch) {
         return {
-          success: false,
+          success: true,
+          autoFixable: false,
           refs: {
             siblings: siblings
           }
@@ -142,7 +150,8 @@ export var ParagraphElements = {
       }
     } else if (!ast.JSXElement.hasAllowedAttrsOnly(node, allowedAttrs)) {
       return {
-        success: false,
+        success: true,
+        autoFixable: false,
         refs: {
           siblings: siblings
         }
@@ -153,7 +162,8 @@ export var ParagraphElements = {
     // If there is more than one `@atlaskit/primitives` import, then it becomes difficult to determine which import to transform
     if (importDeclaration.length > 1) {
       return {
-        success: false,
+        success: true,
+        autoFixable: false,
         refs: {
           siblings: siblings
         }
@@ -161,6 +171,7 @@ export var ParagraphElements = {
     }
     return {
       success: true,
+      autoFixable: true,
       refs: {
         siblings: siblings
       }

package/dist/esm/rules/use-primitives-text/transformers/span-elements.js

@@ -16,58 +16,82 @@ export var SpanElements = {
     }
 
     // Check whether all criteria needed to make a transformation are met
-    if (!SpanElements._check(node, {
-      context: context,
-      config: config
-    })) {
-      return;
-    }
-    var fix = SpanElements._fix(node, {
-      context: context,
-      config: config
-    });
-    context.report(_objectSpread({
-      node: node.openingElement,
-      messageId: 'preferPrimitivesText'
-    }, config.enableUnsafeAutofix ? {
-      fix: fix
-    } : {
-      suggest: [{
-        desc: "Convert to Text",
+    var _SpanElements$_check = SpanElements._check(node, {
+        context: context,
+        config: config
+      }),
+      success = _SpanElements$_check.success,
+      autoFixable = _SpanElements$_check.autoFixable;
+    if (success && autoFixable) {
+      var fix = SpanElements._fix(node, {
+        context: context,
+        config: config
+      });
+      context.report(_objectSpread({
+        node: node.openingElement,
+        messageId: 'preferPrimitivesText'
+      }, config.enableUnsafeAutofix ? {
         fix: fix
-      }]
-    }));
+      } : {
+        suggest: [{
+          desc: "Convert to Text",
+          fix: fix
+        }]
+      }));
+    } else if (success && config.enableUnsafeReport) {
+      context.report({
+        node: node.openingElement,
+        messageId: 'preferPrimitivesText'
+      });
+    }
   },
   _check: function _check(node, _ref2) {
     var context = _ref2.context,
       config = _ref2.config;
     if (!config.patterns.includes('span-elements')) {
-      return false;
+      return {
+        success: false
+      };
     }
     var elementName = ast.JSXElement.getName(node);
     if (elementName !== 'span') {
-      return false;
+      return {
+        success: false
+      };
     }
     if (!node.children.length) {
-      return false;
-    }
-
-    // Element has no unallowed props
-    if (!ast.JSXElement.hasAllowedAttrsOnly(node, allowedAttrs)) {
-      return false;
+      return {
+        success: false
+      };
     }
 
     // Only allow elements with strings as children
     if (!hasTextChildrenOnly(node)) {
-      return false;
+      return {
+        success: false
+      };
+    }
+
+    // Element has no unallowed props
+    if (!ast.JSXElement.hasAllowedAttrsOnly(node, allowedAttrs)) {
+      return {
+        success: true,
+        autoFixable: false
+      };
     }
-    var importDeclaration = ast.Root.findImportsByModule(context.getSourceCode().ast.body, '@atlaskit/primitives');
 
     // If there is more than one `@atlaskit/primitives` import, then it becomes difficult to determine which import to transform
+    var 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: function _fix(node, _ref3) {
     var context = _ref3.context,

package/dist/esm/rules/use-primitives-text/transformers/strong-elements.js

@@ -16,53 +16,75 @@ export var StrongElements = {
     }
 
     // Check whether all criteria needed to make a transformation are met
-    if (!StrongElements._check(node, {
-      context: context,
-      config: config
-    })) {
-      return;
-    }
-    var fix = StrongElements._fix(node, {
-      context: context,
-      config: config
-    });
-    context.report(_objectSpread({
-      node: node.openingElement,
-      messageId: 'preferPrimitivesText'
-    }, config.enableUnsafeAutofix ? {
-      fix: fix
-    } : {
-      suggest: [{
-        desc: "Convert to Text",
+    var _StrongElements$_chec = StrongElements._check(node, {
+        context: context,
+        config: config
+      }),
+      success = _StrongElements$_chec.success,
+      autoFixable = _StrongElements$_chec.autoFixable;
+    if (success && autoFixable) {
+      var fix = StrongElements._fix(node, {
+        context: context,
+        config: config
+      });
+      context.report(_objectSpread({
+        node: node.openingElement,
+        messageId: 'preferPrimitivesText'
+      }, config.enableUnsafeAutofix ? {
         fix: fix
-      }]
-    }));
+      } : {
+        suggest: [{
+          desc: "Convert to Text",
+          fix: fix
+        }]
+      }));
+    } else if (success && config.enableUnsafeReport) {
+      context.report({
+        node: node.openingElement,
+        messageId: 'preferPrimitivesText'
+      });
+    }
   },
   _check: function _check(node, _ref2) {
     var context = _ref2.context,
       config = _ref2.config;
     if (!config.patterns.includes('strong-elements')) {
-      return false;
+      return {
+        success: false
+      };
     }
     var elementName = ast.JSXElement.getName(node);
     if (elementName !== 'strong') {
-      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
     var 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: function _fix(node, _ref3) {
     var context = _ref3.context,

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,18 +1,22 @@
 import type { Rule } from 'eslint';
 import { type JSXAttribute, type Node } from 'eslint-codemod-utils';
 import { type IconMigrationSizeGuidance } from '@atlaskit/icon/UNSAFE_migration-map';
-export type iconMigrationError = Rule.ReportDescriptor;
-export type errorsListManual = {
+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"];
@@ -42,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) => {
     /**
@@ -59,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/use-heading/config/index.d.ts

@@ -2,7 +2,8 @@ type Pattern = 'native-elements';
 export interface RuleConfig {
     failSilently: boolean;
     patterns: Pattern[];
-    enableUnsafeAutofix: false;
+    enableUnsafeAutofix: boolean;
+    enableUnsafeReport: boolean;
 }
 export declare const getConfig: (overrides: Partial<RuleConfig>) => RuleConfig;
 export {};

package/dist/types/rules/use-heading/transformers/native-elements.d.ts

@@ -10,9 +10,13 @@ interface ValidHeadingElement extends JSXElement {
         };
     } & JSXOpeningElement;
 }
+type CheckResult = {
+    success: boolean;
+    autoFixable?: boolean;
+};
 export declare const NativeElements: {
     lint(node: Rule.Node, { context, config }: MetaData): void;
-    _check(node: Rule.Node, { config }: MetaData): node is ValidHeadingElement;
+    _check(node: Rule.Node, { config }: MetaData): CheckResult;
     _fix(node: ValidHeadingElement, { context }: MetaData): Rule.ReportFixer;
 };
 export {};

package/dist/types/rules/use-primitives-text/config/index.d.ts

@@ -4,6 +4,7 @@ export interface RuleConfig {
     patterns: Pattern[];
     inheritColor: boolean;
     enableUnsafeAutofix: boolean;
+    enableUnsafeReport: boolean;
 }
 export declare const getConfig: (overrides: Partial<RuleConfig>) => RuleConfig;
 export {};

package/dist/types/rules/use-primitives-text/transformers/emphasis-elements.d.ts

@@ -1,8 +1,13 @@
 import type { Rule } from 'eslint';
 import { type JSXElement } from 'eslint-codemod-utils';
 import { type MetaData } from './common';
+type CheckResult = {
+    success: boolean;
+    autoFixable?: boolean;
+};
 export declare const EmphasisElements: {
     lint(node: Rule.Node, { context, config }: MetaData): void;
-    _check(node: JSXElement, { context, config }: MetaData): boolean;
+    _check(node: JSXElement, { context, config }: MetaData): CheckResult;
     _fix(node: JSXElement, { context, config }: MetaData): Rule.ReportFixer;
 };
+export {};

package/dist/types/rules/use-primitives-text/transformers/paragraph-elements.d.ts

@@ -6,6 +6,7 @@ type CheckResult = {
     refs: {
         siblings: JSXElement['children'];
     };
+    autoFixable?: boolean;
 };
 export declare const ParagraphElements: {
     lint(node: Rule.Node, { context, config }: MetaData): void;

package/dist/types/rules/use-primitives-text/transformers/span-elements.d.ts

@@ -1,8 +1,13 @@
 import type { Rule } from 'eslint';
 import { type JSXElement } from 'eslint-codemod-utils';
 import { type MetaData } from './common';
+type CheckResult = {
+    success: boolean;
+    autoFixable?: boolean;
+};
 export declare const SpanElements: {
     lint(node: Rule.Node, { context, config }: MetaData): void;
-    _check(node: JSXElement, { context, config }: MetaData): boolean;
+    _check(node: JSXElement, { context, config }: MetaData): CheckResult;
     _fix(node: JSXElement, { context, config }: MetaData): Rule.ReportFixer;
 };
+export {};

package/dist/types/rules/use-primitives-text/transformers/strong-elements.d.ts

@@ -1,8 +1,13 @@
 import type { Rule } from 'eslint';
 import { type JSXElement } from 'eslint-codemod-utils';
 import { type MetaData } from './common';
+type CheckResult = {
+    success: boolean;
+    autoFixable?: boolean;
+};
 export declare const StrongElements: {
     lint(node: Rule.Node, { context, config }: MetaData): void;
-    _check(node: JSXElement, { context, config }: MetaData): boolean;
+    _check(node: JSXElement, { context, config }: MetaData): CheckResult;
     _fix(node: JSXElement, { context, config }: MetaData): Rule.ReportFixer;
 };
+export {};