@hero-design/eslint-plugin 8.12.0-rc.0 → 8.12.0

package/lib/index.js

@@ -0,0 +1,412 @@
+/**
+ * @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

@@ -0,0 +1,189 @@
+/**
+ * @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

@@ -0,0 +1,165 @@
+/**
+ * @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

@@ -0,0 +1,92 @@
+/**
+ * @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

@@ -0,0 +1,97 @@
+/**
+ * @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,
+              },
+            });
+          }
+        });
+      },
+    };
+  },
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hero-design/eslint-plugin",
-  "version": "8.12.0-rc.0",
+  "version": "8.12.0",
   "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.12.0-rc.0"
+    "prettier-config-hd": "8.12.0"
   },
   "engines": {
     "node": "^14.17.0 || ^16.0.0 || >= 18.0.0"