@hero-design/eslint-plugin 8.11.2 → 8.11.4-rc.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hero-design/eslint-plugin",
-  "version": "8.11.2",
+  "version": "8.11.4-rc.1",
   "description": "Hero Design's eslint plugin",
   "keywords": [
     "eslint",
@@ -26,7 +26,7 @@
     "eslint-plugin-eslint-plugin": "^5.0.0",
     "eslint-plugin-node": "^11.1.0",
     "jest": "^27.3.1",
-    "prettier-config-hd": "8.11.2"
+    "prettier-config-hd": "8.11.4-rc.1"
   },
   "engines": {
     "node": "^14.17.0 || ^16.0.0 || >= 18.0.0"

package/lib/index.js

@@ -1,412 +0,0 @@
-/**
- * @fileoverview Hero Design's eslint plugin
- * @author Thong Quach
- */
-'use strict';
-
-//------------------------------------------------------------------------------
-// Requirements
-//------------------------------------------------------------------------------
-
-const requireIndex = require('requireindex');
-
-//------------------------------------------------------------------------------
-// Plugin Definition
-//------------------------------------------------------------------------------
-
-const themeKeysMap = [
-  {
-    old: 'colors.globalPrimary',
-    new: 'colors.onDefaultGlobalSurface',
-  },
-  {
-    old: 'colors.globalPrimaryLight',
-    new: 'colors.globalPrimaryLight',
-  },
-  {
-    old: 'colors.globalPrimaryBackground',
-    new: 'colors.defaultGlobalSurface',
-  },
-  {
-    old: 'colors.primaryLight',
-    new: 'colors.secondary',
-  },
-  {
-    old: 'colors.primaryDark',
-    new: 'colors.primary',
-  },
-  {
-    old: 'colors.primaryBackground',
-    new: 'colors.highlightedSurface',
-  },
-  {
-    old: 'colors.primaryBackgroundDark',
-    new: 'colors.mutedOnDefaultGlobalSurface',
-  },
-  {
-    old: 'colors.secondaryLight',
-    new: 'colors.secondaryLight',
-  },
-  {
-    old: 'colors.secondaryBackground',
-    new: 'colors.secondaryBackground',
-  },
-  {
-    old: 'colors.infoMediumLight',
-    new: 'colors.mutedInfo',
-  },
-  {
-    old: 'colors.infoLight',
-    new: 'colors.mutedInfo',
-  },
-  {
-    old: 'colors.infoBackground',
-    new: 'colors.infoSurface',
-  },
-  {
-    old: 'colors.successLight',
-    new: 'colors.mutedSuccess',
-  },
-  {
-    old: 'colors.successDark',
-    new: 'colors.success',
-  },
-  {
-    old: 'colors.successBackground',
-    new: 'colors.successSurface',
-  },
-  {
-    old: 'colors.danger',
-    new: 'colors.error',
-  },
-  {
-    old: 'colors.dangerMediumLight',
-    new: 'colors.mutedError',
-  },
-  {
-    old: 'colors.dangerLight',
-    new: 'colors.mutedError',
-  },
-  {
-    old: 'colors.dangerBackground',
-    new: 'colors.errorSurface',
-  },
-  {
-    old: 'colors.warningLight',
-    new: 'colors.mutedWarning',
-  },
-  {
-    old: 'colors.warningDark',
-    new: 'colors.warning',
-  },
-  {
-    old: 'colors.warningBackground',
-    new: 'colors.warningSurface',
-  },
-  {
-    old: 'colors.platformBackground',
-    new: 'colors.defaultGlobalSurface',
-  },
-  {
-    old: 'colors.backgroundLight',
-    new: 'colors.neutralGlobalSurface',
-  },
-  {
-    old: 'colors.backgroundDark',
-    new: 'colors.darkGlobalSurface',
-  },
-  {
-    old: 'colors.text',
-    new: 'colors.onDefaultGlobalSurface',
-  },
-  {
-    old: 'colors.subduedText',
-    new: 'colors.mutedOnDefaultGlobalSurface',
-  },
-  {
-    old: 'colors.disabledText',
-    new: 'colors.inactiveOnDefaultGlobalSurface',
-  },
-  {
-    old: 'colors.disabledLightText',
-    new: 'colors.disabledOnDefaultGlobalSurface',
-  },
-  {
-    old: 'colors.invertedText',
-    new: 'colors.onDarkGlobalSurface',
-  },
-  {
-    old: 'colors.outline',
-    new: 'colors.secondaryOutline',
-  },
-  {
-    old: 'colors.archivedLight',
-    new: 'colors.disabledOnDefaultGlobalSurface',
-  },
-  {
-    old: 'colors.archivedDark',
-    new: 'colors.archived',
-  },
-  {
-    old: 'colors.archivedBackground',
-    new: 'colors.archivedSurface',
-  },
-  {
-    old: 'colors.black',
-    new: 'colors.onDefaultGlobalSurface',
-  },
-  {
-    old: 'colors.inactiveBackground',
-    new: 'colors.inactiveOnDefaultGlobalSurface',
-  },
-  {
-    old: 'colors.shadow',
-    new: 'colors.secondaryOutline',
-  },
-  {
-    old: 'colors.mutedGlobalPrimary',
-    new: 'colors.mutedOnDefaultGlobalSurface',
-  },
-  {
-    old: 'colors.onGlobalPrimary',
-    new: 'colors.onDefaultGlobalSurface',
-  },
-  {
-    old: 'colors.globalSecondary',
-    new: 'colors.secondary',
-  },
-  {
-    old: 'colors.globalPrimaryOutline',
-    new: 'colors.primaryOutline',
-  },
-  {
-    old: 'colors.globalSecondaryOutline',
-    new: 'colors.secondaryOutline',
-  },
-  {
-    old: 'colors.mutedPrimary',
-    new: 'colors.mutedPrimary',
-  },
-  {
-    old: 'colors.highlightedSecondarySurface',
-    new: 'colors.highlightedSecondarySurface',
-  },
-  {
-    old: 'colors.mutedSecondary',
-    new: 'colors.mutedSecondary',
-  },
-  {
-    old: 'colors.disabledSecondary',
-    new: 'colors.disabledSecondary',
-  },
-  {
-    old: 'colors.lightHighlightedSurface',
-    new: 'colors.highlightedSurface',
-  },
-];
-const deprecatedThemeColors = themeKeysMap.map((c) => c.old.split('.')[1]);
-const boxColorProps = [
-  'backgroundColor',
-  'bgColor',
-  'borderColor',
-  'borderTopColor',
-  'borderBottomColor',
-  'borderStartColor',
-  'borderEndColor',
-  'borderLeftColor',
-  'borderRightColor',
-];
-const deprecatedBoxPropValues = boxColorProps.map((prop) => ({
-  name: prop,
-  values: deprecatedThemeColors,
-}));
-
-// import all rules in lib/rules
-module.exports = {
-  rules: requireIndex(__dirname + '/rules'),
-  configs: {
-    internalRn: {
-      plugins: ['@hero-design'],
-      rules: {
-        '@hero-design/no-deprecated-theme-key': [
-          'error',
-          {
-            keys: themeKeysMap,
-          },
-        ],
-        '@hero-design/no-deprecated-component-prop': [
-          'error',
-          {
-            package: '@hero-design/rn',
-            components: [
-              { name: 'Card', props: ['variant'] },
-              { name: 'Switch', props: ['size'] },
-              {
-                name: 'Select',
-                props: ['onDimiss', 'numberOfLines', 'inputProps.required'],
-              },
-              {
-                name: 'Select.Multi',
-                props: ['onDimiss', 'numberOfLines', 'inputProps.required'],
-              },
-              { name: 'Toast.Provider', props: ['position'] },
-            ],
-          },
-        ],
-        '@hero-design/no-deprecated-component-prop-value': [
-          'error',
-          {
-            package: '@hero-design/rn',
-            components: [
-              {
-                name: 'Tag',
-                props: [{ name: 'intent', values: ['default'] }],
-              },
-              {
-                name: 'Button',
-                props: [{ name: 'variant', values: ['basic-transparent'] }],
-              },
-              {
-                name: 'Button.Icon',
-                props: [
-                  {
-                    name: 'icon',
-                    values: [
-                      'carat-down-small',
-                      'carat-down',
-                      'carat-left-small',
-                      'carat-left',
-                      'carat-right-small',
-                      'carat-right',
-                      'carat-up-small',
-                      'carat-up',
-                    ],
-                  },
-                ],
-              },
-              {
-                name: 'Button.Utility',
-                props: [
-                  {
-                    name: 'icon',
-                    values: [
-                      'carat-down-small',
-                      'carat-down',
-                      'carat-left-small',
-                      'carat-left',
-                      'carat-right-small',
-                      'carat-right',
-                      'carat-up-small',
-                      'carat-up',
-                    ],
-                  },
-                ],
-              },
-              {
-                name: 'Icon',
-                props: [
-                  {
-                    name: 'icon',
-                    values: [
-                      'carat-down-small',
-                      'carat-down',
-                      'carat-left-small',
-                      'carat-left',
-                      'carat-right-small',
-                      'carat-right',
-                      'carat-up-small',
-                      'carat-up',
-                    ],
-                  },
-                ],
-              },
-              {
-                name: 'Box',
-                props: deprecatedBoxPropValues,
-              },
-            ],
-          },
-        ],
-      },
-    },
-    recommendedRn: {
-      plugins: ['@hero-design'],
-      extends: ['plugin:@hero-design/internalRn'],
-      rules: {
-        '@hero-design/not-recommended-import': [
-          'warn',
-          {
-            package: '@hero-design/rn',
-            imports: [
-              {
-                name: 'swagSystemPalette',
-                message: 'Please use colors from useTheme hook instead.',
-              },
-              {
-                name: 'workSystemPalette',
-                message: 'Please use colors from useTheme hook instead.',
-              },
-              {
-                name: 'jobsSystemPalette',
-                message: 'Please use colors from useTheme hook instead.',
-              },
-              {
-                name: 'walletSystemPalette',
-                message: 'Please use colors from useTheme hook instead.',
-              },
-              {
-                name: 'eBensSystemPalette',
-                message: 'Please use colors from useTheme hook instead.',
-              },
-            ],
-          },
-          {
-            package: '@hero-design/colors',
-            imports: [
-              {
-                name: 'default',
-                message: 'Please use colors from useTheme hook instead.',
-              },
-              {
-                name: 'defaultWebPalette',
-                message: 'Please use colors from useTheme hook instead.',
-              },
-              {
-                name: 'defaultMobilePalette',
-                message: 'Please use colors from useTheme hook instead.',
-              },
-              {
-                name: 'mixColor',
-                message: 'Please use colors from useTheme hook instead.',
-              },
-              {
-                name: 'colorScales',
-                message: 'Please use colors from useTheme hook instead.',
-              },
-              {
-                name: 'eBensPalette',
-                message: 'Please use colors from useTheme hook instead.',
-              },
-              {
-                name: 'jobsPalette',
-                message: 'Please use colors from useTheme hook instead.',
-              },
-              {
-                name: 'swagPalette',
-                message: 'Please use colors from useTheme hook instead.',
-              },
-              {
-                name: 'walletPalette',
-                message: 'Please use colors from useTheme hook instead.',
-              },
-              {
-                name: 'workPalette',
-                message: 'Please use colors from useTheme hook instead.',
-              },
-            ],
-          },
-        ],
-      },
-    },
-  },
-};

package/lib/rules/no-deprecated-component-prop-value.js

@@ -1,189 +0,0 @@
-/**
- * @fileoverview Disallow deprecated component prop's values
- * @author Thong Quach
- */
-'use strict';
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-/** @type {import('eslint').Rule.RuleModule} */
-module.exports = {
-  meta: {
-    type: 'problem',
-    docs: {
-      description: "Disallow deprecated component prop's values",
-      recommended: false,
-      url: null, // URL to the documentation page for this rule
-    },
-    fixable: null, // Or `code` or `whitespace`
-    schema: [
-      {
-        type: 'object',
-        properties: {
-          package: { type: 'string' },
-          components: {
-            type: 'array',
-            items: {
-              type: 'object',
-              properties: {
-                name: { type: 'string' },
-                props: {
-                  type: 'array',
-                  items: {
-                    type: 'object',
-                    properties: {
-                      name: { type: 'string' },
-                      values: {
-                        type: 'array',
-                      },
-                    },
-                  },
-                },
-              },
-            },
-          },
-        },
-        additionalProperties: false,
-        required: ['package', 'components'],
-      },
-    ],
-    messages: {
-      deprecatedValue:
-        'The value "{{ value }}" of "{{ prop }}" prop has been deprecated.',
-    },
-  },
-
-  create(context) {
-    const components = context.options[0].components.map((c) => ({
-      props: c.props.map((p) => p.name),
-      values: c.props.map((p) => p.values),
-      identifiers: c.name.split('.'),
-    }));
-    let importedComponents = [];
-
-    const getDeprecatedComponent = (node) => {
-      return importedComponents.find((c) => {
-        const { identifiers } = c;
-        const elementName = node.name;
-
-        // <Radio />
-        if (elementName.type === 'JSXIdentifier' && identifiers.length === 1) {
-          return elementName.name === identifiers[0];
-        }
-
-        if (elementName.type === 'JSXMemberExpression') {
-          // <Radio.Group />
-          if (identifiers.length === 2) {
-            return (
-              elementName.object.name === identifiers[0] &&
-              elementName.property.name === identifiers[1]
-            );
-          }
-
-          // <HD.Radio.Group />
-          if (identifiers.length === 3) {
-            return (
-              elementName.object.object.name === identifiers[0] &&
-              elementName.object.property.name === identifiers[1] &&
-              elementName.property.name === identifiers[2]
-            );
-          }
-        }
-
-        return false;
-      });
-    };
-
-    return {
-      ImportDeclaration(node) {
-        if (node.source.value !== context.options[0].package) return;
-
-        // import * as HD from "@hero-design/rn";
-        if (node.specifiers[0].type === 'ImportNamespaceSpecifier') {
-          const localPackageName = node.specifiers[0].local.name;
-
-          importedComponents = components.map((c) => ({
-            ...c,
-            identifiers: [localPackageName].concat(c.identifiers),
-          }));
-
-          return;
-        }
-
-        // import { Card, Box } from "@hero-design/rn";
-        // import { Card as HDCard, Box } from "hero-design/rn";
-        node.specifiers.forEach((spec) => {
-          if (spec.type !== 'ImportSpecifier') return;
-
-          const importingComponents = components
-            .filter((c) => spec.imported.name === c.identifiers[0])
-            .map((c) => ({
-              ...c,
-              identifiers: [spec.local.name].concat(c.identifiers.slice(1)),
-            }));
-
-          importedComponents.push(...importingComponents);
-        });
-      },
-
-      JSXOpeningElement(node) {
-        if (importedComponents.length === 0) return;
-
-        const deprecatedComponent = getDeprecatedComponent(node);
-        if (deprecatedComponent === undefined) return;
-
-        node.attributes.forEach((atb) => {
-          if (atb.type !== 'JSXAttribute') return;
-
-          const deprecatedPropIndex = deprecatedComponent.props.findIndex(
-            (p) => p === atb.name.name
-          );
-          if (deprecatedPropIndex < 0) return;
-
-          const deprecatedValues =
-            deprecatedComponent.values[deprecatedPropIndex];
-          const currValue = atb.value;
-
-          if (currValue.type === 'Literal') {
-            const deprecatedValue = deprecatedValues.find(
-              (v) => v === currValue.value
-            );
-
-            if (deprecatedValue !== undefined) {
-              context.report({
-                node: atb.value,
-                messageId: 'deprecatedValue',
-                data: {
-                  prop: deprecatedComponent.props[deprecatedPropIndex],
-                  value: deprecatedValue,
-                },
-              });
-            }
-          }
-
-          if (
-            currValue.type === 'JSXExpressionContainer' &&
-            currValue.expression.type === 'Literal'
-          ) {
-            const deprecatedValue = deprecatedValues.find(
-              (v) => v === currValue.expression.value
-            );
-
-            if (deprecatedValue !== undefined) {
-              context.report({
-                node: atb.value,
-                messageId: 'deprecatedValue',
-                data: {
-                  prop: deprecatedComponent.props[deprecatedPropIndex],
-                  value: deprecatedValue,
-                },
-              });
-            }
-          }
-        });
-      },
-    };
-  },
-};

package/lib/rules/no-deprecated-component-prop.js

@@ -1,165 +0,0 @@
-/**
- * @fileoverview Disallow deprecated component props
- * @author Thong Quach
- */
-'use strict';
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-/** @type {import('eslint').Rule.RuleModule} */
-module.exports = {
-  meta: {
-    type: 'problem',
-    docs: {
-      description: 'Disallow deprecated component props',
-      recommended: false,
-      url: null, // URL to the documentation page for this rule
-    },
-    fixable: null, // Or `code` or `whitespace`
-    schema: [
-      {
-        type: 'object',
-        properties: {
-          package: { type: 'string' },
-          components: {
-            type: 'array',
-            items: {
-              type: 'object',
-              properties: {
-                name: { type: 'string' },
-                props: {
-                  type: 'array',
-                  items: {
-                    type: 'string',
-                  },
-                },
-              },
-            },
-          },
-        },
-        additionalProperties: false,
-        required: ['package', 'components'],
-      },
-    ],
-    messages: {
-      deprecatedProp: 'The prop "{{ prop }}" has been deprecated.',
-    },
-  },
-
-  create(context) {
-    const components = context.options[0].components.map((c) => ({
-      props: c.props.map((p) => p.split('.')),
-      identifiers: c.name.split('.'),
-    }));
-    let importedComponents = [];
-
-    const getDeprecatedComponent = (node) => {
-      return importedComponents.find((c) => {
-        const { identifiers } = c;
-        const elementName = node.name;
-
-        // <Radio />
-        if (elementName.type === 'JSXIdentifier' && identifiers.length === 1) {
-          return elementName.name === identifiers[0];
-        }
-
-        if (elementName.type === 'JSXMemberExpression') {
-          // <Radio.Group />
-          if (identifiers.length === 2) {
-            return (
-              elementName.object.name === identifiers[0] &&
-              elementName.property.name === identifiers[1]
-            );
-          }
-
-          // <HD.Radio.Group />
-          if (identifiers.length === 3) {
-            return (
-              elementName.object.object.name === identifiers[0] &&
-              elementName.object.property.name === identifiers[1] &&
-              elementName.property.name === identifiers[2]
-            );
-          }
-        }
-
-        return false;
-      });
-    };
-
-    return {
-      ImportDeclaration(node) {
-        if (node.source.value !== context.options[0].package) return;
-
-        // import * as HD from "@hero-design/rn";
-        if (node.specifiers[0].type === 'ImportNamespaceSpecifier') {
-          const localPackageName = node.specifiers[0].local.name;
-
-          importedComponents = components.map((c) => ({
-            ...c,
-            identifiers: [localPackageName].concat(c.identifiers),
-          }));
-
-          return;
-        }
-
-        // import { Card, Box } from "@hero-design/rn";
-        // import { Card as HDCard, Box } from "hero-design/rn";
-        node.specifiers.forEach((spec) => {
-          if (spec.type !== 'ImportSpecifier') return;
-
-          const importingComponents = components
-            .filter((c) => spec.imported.name === c.identifiers[0])
-            .map((c) => ({
-              ...c,
-              identifiers: [spec.local.name].concat(c.identifiers.slice(1)),
-            }));
-
-          importedComponents.push(...importingComponents);
-        });
-      },
-
-      JSXOpeningElement(node) {
-        if (importedComponents.length === 0) return;
-
-        const deprecatedComponent = getDeprecatedComponent(node);
-        if (deprecatedComponent === undefined) return;
-
-        node.attributes.forEach((atb) => {
-          if (atb.type !== 'JSXAttribute') return;
-
-          const deprecatedProp = deprecatedComponent.props.find(
-            (p) => p[0] === atb.name.name
-          );
-
-          if (deprecatedProp === undefined) return;
-          if (deprecatedProp.length === 1) {
-            context.report({
-              node: atb,
-              messageId: 'deprecatedProp',
-              data: { prop: deprecatedProp.join('.') },
-            });
-          }
-
-          if (deprecatedProp.length === 2) {
-            if (atb.value.type !== 'JSXExpressionContainer') return;
-            if (atb.value.expression.type !== 'ObjectExpression') return;
-
-            let nestedDeprecatedProp = atb.value.expression.properties.find(
-              (p) => p.key.name === deprecatedProp[1]
-            );
-
-            if (nestedDeprecatedProp !== undefined) {
-              context.report({
-                node: nestedDeprecatedProp,
-                messageId: 'deprecatedProp',
-                data: { prop: deprecatedProp.join('.') },
-              });
-            }
-          }
-        });
-      },
-    };
-  },
-};

package/lib/rules/no-deprecated-theme-key.js

@@ -1,92 +0,0 @@
-/**
- * @fileoverview Disallow deprecated theme keys
- * @author Thong Quach
- */
-'use strict';
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-/** @type {import('eslint').Rule.RuleModule} */
-module.exports = {
-  meta: {
-    type: 'problem', // `problem`, `suggestion`, or `layout`
-    docs: {
-      description: 'Disallow deprecated theme keys',
-      recommended: false,
-      url: null, // URL to the documentation page for this rule
-    },
-    fixable: 'code', // Or `code` or `whitespace`
-    schema: [
-      {
-        type: 'object',
-        properties: {
-          keys: {
-            type: 'array',
-            items: {
-              type: 'object',
-              properties: {
-                old: { type: 'string' },
-                new: { type: 'string' },
-              },
-            },
-          },
-        },
-        additionalProperties: false,
-        required: ['keys'],
-      },
-    ],
-    messages: {
-      deprecatedThemeKey: 'The key "{{ key }}" in theme has been deprecated.',
-    },
-  },
-
-  create(context) {
-    const oldKeys = context.options[0].keys.map((k) => k.old);
-    const newKeys = context.options[0].keys.map((k) => k.new);
-
-    const findPath = (node, identifiers) => {
-      const property = node.property;
-
-      if (
-        property != null &&
-        property.type === 'Identifier' &&
-        property.name != null
-      ) {
-        return findPath(node.parent, [...identifiers, property.name]);
-      }
-
-      return identifiers.join('.');
-    };
-
-    return {
-      MemberExpression(node) {
-        const object = node.object;
-        if (object == null) return;
-
-        if (object.type === 'Identifier' && object.name === 'theme') {
-          const path = findPath(node, []);
-          const deprecatedKeyIndex = oldKeys.findIndex((k) => k === path);
-
-          if (deprecatedKeyIndex >= 0) {
-            const reportingNode =
-              node.parent.type === 'MemberExpression' ? node.parent : node;
-
-            context.report({
-              node: reportingNode,
-              messageId: 'deprecatedThemeKey',
-              data: { key: oldKeys[deprecatedKeyIndex] },
-              fix: function (fixer) {
-                return fixer.replaceText(
-                  reportingNode,
-                  `theme.${newKeys[deprecatedKeyIndex]}`
-                );
-              },
-            });
-          }
-        }
-      },
-    };
-  },
-};

package/lib/rules/not-recommended-import.js

@@ -1,97 +0,0 @@
-/**
- * @fileoverview Disallow not recommended imports
- * @author Thong Quach
- */
-'use strict';
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-/** @type {import('eslint').Rule.RuleModule} */
-module.exports = {
-  meta: {
-    type: 'problem',
-    docs: {
-      description: 'Disallow not recommended imports   ',
-      recommended: false,
-      url: null, // URL to the documentation page for this rule
-    },
-    fixable: null, // Or `code` or `whitespace`
-    schema: {
-      type: 'array',
-      items: {
-        type: 'object',
-        properties: {
-          package: { type: 'string' },
-          imports: {
-            type: 'array',
-            items: {
-              type: 'object',
-              properties: {
-                name: { type: 'string' },
-                message: { type: 'string' },
-              },
-            },
-          },
-        },
-        additionalProperties: false,
-        required: ['package', 'imports'],
-      },
-    },
-    messages: {
-      notRecommendedImport:
-        'Importing "{{ import }}" from "{{ package }}" is not recommended. {{ message }}',
-    },
-  },
-
-  create(context) {
-    const packages = context.options.map((opt) => opt.package);
-    const imports = context.options.map((opt) => opt.imports);
-
-    return {
-      ImportDeclaration(node) {
-        const packageIndex = packages.findIndex((p) => p === node.source.value);
-        if (packageIndex < 0) return;
-
-        node.specifiers.forEach((spec) => {
-          if (spec.type === 'ImportDefaultSpecifier') {
-            const defaultImport = imports[packageIndex].find(
-              (imp) => imp.name === 'default'
-            );
-
-            if (defaultImport != null) {
-              context.report({
-                node: spec,
-                messageId: 'notRecommendedImport',
-                data: {
-                  import: defaultImport.name,
-                  package: packages[packageIndex],
-                  message: defaultImport.message,
-                },
-              });
-            }
-          }
-
-          if (spec.type !== 'ImportSpecifier') return;
-
-          const foundImport = imports[packageIndex].find(
-            (imp) => imp.name === spec.imported.name
-          );
-
-          if (foundImport != null) {
-            context.report({
-              node: spec,
-              messageId: 'notRecommendedImport',
-              data: {
-                import: foundImport.name,
-                package: packages[packageIndex],
-                message: foundImport.message,
-              },
-            });
-          }
-        });
-      },
-    };
-  },
-};