eslint-plugin-restrict-replace-import 1.3.0 → 1.5.0

package/README.md

@@ -33,10 +33,7 @@ Then configure the rules you want to use under the rules section.
 ```json
 {
   "rules": {
-    "restrict-replace-import/restrict-import": [
-      "error",
-      ["restricted-package1", "restricted-package2"]
-    ]
+    "restrict-replace-import/restrict-import": ["error", ["restricted-package1", "restricted-package2"]]
   }
 }
 ```
@@ -95,7 +92,7 @@ Is it possible as well to perform multiple partial replacements by setting and O
           "replacement": {
             "par(regExp)?tial-": "successfully-",
             "repla(regExp)?cements": "replaced",
-            "with-": "",
+            "with-": ""
           }
         }
       ]
@@ -103,18 +100,68 @@ Is it possible as well to perform multiple partial replacements by setting and O
   }
 }
 ```
+
 Given that rule configuration it will perform the following replacement:
 
 Input:
+
 ```js
 import { useState } from 'with-partial-replacements'
 ```
 
 Output:
+
 ```js
 import { useState } from 'successfully-replaced'
 ```
 
+You can also restrict specific named imports from a package while allowing others:
+
+```json
+{
+  "rules": {
+    "restrict-replace-import/restrict-import": [
+      "error",
+      [
+        {
+          "target": "restricted-module",
+          "namedImports": ["restrictedImport", "alsoRestricted"],
+          "replacement": "replacement-module" // Object is not supported yet
+        }
+      ]
+    ]
+  }
+}
+```
+
+This configuration will:
+- Allow: `import { allowedImport } from 'restricted-module'`
+- Replace: `import { restrictedImport } from 'restricted-module'` → `import { restrictedImport } from 'replacement-module'`
+
+The rule handles various import scenarios:
+- Named imports with aliases: `import { restrictedImport as aliasName }`
+- Mixed allowed/restricted imports: Will split into separate import statements
+- Default exports with named imports
+- Multiple restricted named imports
+- Merging with existing imports from replacement module
+
+Examples of complex scenarios:
+
+```js
+// Before
+import { existingImport } from 'replacement-module';
+import { restrictedImport } from 'restricted-module';
+
+// After
+import { existingImport, restrictedImport } from 'replacement-module';
+
+// Before
+import defaultExport, { restrictedImport, allowed } from 'restricted-module';
+
+// After
+import { restrictedImport } from 'replacement-module'
+import defaultExport, { allowed } from 'restricted-module'
+```
 
 ## Rules
 
@@ -122,8 +169,8 @@ import { useState } from 'successfully-replaced'
 
 🔧 Automatically fixable by the [`--fix` CLI option](https://eslint.org/docs/user-guide/command-line-interface#--fix).
 
-| Name                                             | Description                              | 🔧  |
-| :----------------------------------------------- | :--------------------------------------- | :-- |
-| [restrict-import](docs/rules/restrict-import.md) | Prevent the Import of a Specific Package | 🔧  |
+| Name                                             | Description                              | 🔧 |
+| :----------------------------------------------- | :--------------------------------------- | :- |
+| [restrict-import](docs/rules/restrict-import.md) | Prevent the Import of a Specific Package | 🔧 |
 
 <!-- end auto-generated rules list -->

package/docs/rules/restrict-import.md

@@ -4,74 +4,163 @@
 
 <!-- end auto-generated rule header -->
 
-This rule aims to prevent the import of a specific package.
+This rule aims to prevent the import of a specific package and optionally replace it with an alternative package.
 
-With additional configuration, this rule can also suggest an alternative package to import instead.
+## Features
 
-If the alternative package is specified, auto-fixing will replace the import statement with the alternative package.
+- Restrict imports from specific packages
+- Replace restricted imports with alternative packages
+- Support for RegExp patterns in package names
+- Restrict specific named imports while allowing others
+- Partial string replacements using RegExp
+- Automatic merging with existing imports from replacement modules
 
-You can use RegExp to match multiple packages.
+## Options
 
-## Rule Details
+<!-- begin auto-generated rule options list -->
 
-Example configuration:
+| Name           | Description                                                                                                                                                                                                                 | Type     | Required |
+| :------------- | :-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | :------- | :------- |
+| `namedImports` | The named imports to be restricted. If not provided, all named imports will be restricted.                                                                                                                                  | String[] |          |
+| `replacement`  | The replacement for the import. If a string is provided, it will be used as the replacement for all imports. If an object is provided, the keys will be used as the pattern and the values will be used as the replacement. |          |          |
+| `target`       | The target of the import to be restricted                                                                                                                                                                                   | String   | Yes      |
+
+<!-- end auto-generated rule options list -->
+
+## Usage Examples
+
+### Basic Usage - Restricting Packages
+
+```json
+{
+  "rules": {
+    "restrict-replace-import/restrict-import": ["error", ["lodash"]]
+  }
+}
+```
+
+This will prevent imports from `lodash`:
+```js
+// ❌ Error: `lodash` is restricted from being used
+import _ from 'lodash'
+```
+
+### Replacing with Alternative Package
 
 ```json
 {
   "rules": {
     "restrict-replace-import/restrict-import": [
-      "error",
-      [
-        {
-          "target": "test-package",
-          "replacement": "replacement-package"
-        },
-        "another-package"
-        "with(?:-regex)?-support"
-      ]
+      "error", 
+      [{
+        "target": "react",
+        "replacement": "preact"
+      }]
     ]
   }
 }
 ```
 
-Examples of **incorrect** code for this rule with options above:
-
 ```js
-import testPackage from "test-package";
+// Before
+import { useState } from 'react'
 
-import anotherPackage from "another-package";
-
-import withRegexSupport from "with-regex-support";
-import withSupport from "with-support";
+// After
+import { useState } from 'preact'
 ```
 
-Examples of **correct** code for this rule with options above:
+### Using RegExp for Package Names
 
-```js
-import testPackage from "replacement-package";
+```json
+{
+  "rules": {
+    "restrict-replace-import/restrict-import": [
+      "error",
+      [{
+        "target": "with(?:-regex)?-support",
+        "replacement": "with-support-replacement"
+      }]
+    ]
+  }
+}
+```
 
-import theOtherPackage from "the-other-package";
+This will match and replace both:
+```js
+import { something } from 'with-regex-support'  // will be replaced
+import { something } from 'with-support'        // will be replaced
 ```
 
-### Options
+### Partial String Replacements
 
-This rule takes a single argument, an array of strings or objects.
+```json
+{
+  "rules": {
+    "restrict-replace-import/restrict-import": [
+      "error",
+      [{
+        "target": "with-partial-replacements",
+        "replacement": {
+          "par(regExp)?tial-": "successfully-",
+          "repla(regExp)?cements": "replaced",
+          "with-": ""
+        }
+      }]
+    ]
+  }
+}
+```
 
-Each string or object represents a package that should be restricted.
+```js
+// Before
+import { useState } from 'with-partial-replacements'
 
-If the array element is a string, it represents the name of the package that should be restricted.
+// After
+import { useState } from 'successfully-replaced'
+```
 
-If the array element is an object, it represents the name of the package that should be restricted and the alternative package that should be suggested instead.
+### Restricting Specific Named Imports
 
-The alternative package is optional.
+```json
+{
+  "rules": {
+    "restrict-replace-import/restrict-import": [
+      "error",
+      [{
+        "target": "restricted-module",
+        "namedImports": ["restrictedImport", "alsoRestricted"],
+        "replacement": "replacement-module" // Object is not supported yet
+      }]
+    ]
+  }
+}
+```
 
-Scheme:
+This configuration handles various scenarios:
 
-```ts
-type Restriction =
-  | string
-  | {
-      target: string;
-      replacement?: string;
-    };
+```js
+// ✅ Allowed - import not in restricted list
+import { allowedImport } from 'restricted-module'
+
+// ❌ Will be replaced
+import { restrictedImport } from 'restricted-module'
+// ↓ Becomes
+import { restrictedImport } from 'replacement-module'
+
+// Mixed imports are split
+import { restrictedImport, allowed } from 'restricted-module'
+// ↓ Becomes
+import { restrictedImport } from 'replacement-module'
+import { allowed } from 'restricted-module'
+
+// Handles aliases
+import { restrictedImport as aliasName } from 'restricted-module'
+// ↓ Becomes
+import { restrictedImport as aliasName } from 'replacement-module'
+
+// Merges with existing imports
+import { existingImport } from 'replacement-module';
+import { restrictedImport } from 'restricted-module';
+// ↓ Becomes
+import { existingImport, restrictedImport } from 'replacement-module';
 ```

package/eslint.config.mjs

@@ -0,0 +1,43 @@
+'use strict'
+
+import eslint from '@eslint/js'
+import eslintPluginEslintPlugin from 'eslint-plugin-eslint-plugin'
+import eslintPluginNode from 'eslint-plugin-node'
+import { fixupPluginRules } from '@eslint/compat'
+import globals from 'globals'
+
+/**
+ * @type {import('eslint').Linter.Config[]}
+ */
+export default [
+  eslint.configs.recommended,
+  {
+    languageOptions: {
+      ecmaVersion: 2023,
+      sourceType: 'commonjs',
+      globals: {
+        ...globals.node,
+      },
+    },
+    files: ['**/*.js'],
+    rules: {
+      ...eslintPluginEslintPlugin.configs.recommended.rules,
+      ...eslintPluginNode.configs.recommended.rules,
+    },
+    plugins: {
+      'eslint-plugin': eslintPluginEslintPlugin,
+      node: fixupPluginRules(eslintPluginNode),
+    },
+    linterOptions: {
+      reportUnusedDisableDirectives: true,
+    },
+  },
+  {
+    files: ['tests/**/*.js'],
+    languageOptions: {
+      globals: {
+        mocha: 'readonly',
+      },
+    },
+  },
+]

package/lib/index.js

@@ -2,21 +2,17 @@
  * @fileoverview ESLint Plugin for Restricting Import
  * @author shiwoo.park
  */
-"use strict";
+'use strict'
 
 //------------------------------------------------------------------------------
 // Requirements
 //------------------------------------------------------------------------------
 
-const requireIndex = require("requireindex");
+const requireIndex = require('requireindex')
 
 //------------------------------------------------------------------------------
 // Plugin Definition
 //------------------------------------------------------------------------------
 
-
 // import all rules in lib/rules
-module.exports.rules = requireIndex(__dirname + "/rules");
-
-
-
+module.exports.rules = requireIndex(__dirname + '/rules')

package/lib/rules/restrict-import.js

@@ -2,57 +2,459 @@
  * @fileoverview Prevent the Import of a Specific Package
  * @author shiwoo.park
  */
-"use strict";
+'use strict'
+
+/**
+ * @typedef {string | {[key: string]: string;}} Replacement
+ * @typedef {{replacement: Replacement | null; namedImports: string[] | null;}} ImportRestrictionOptions
+ */
+
+const createRestrictedPackagesMap = (options) => {
+  /**
+   * @type {Map<RegExp, ImportRestrictionOptions>}
+   */
+  const map = new Map()
+  options.forEach((config) => {
+    if (typeof config === 'string') {
+      map.set(new RegExp(`^${config}$`), {
+        replacement: null,
+        namedImports: null,
+      })
+    } else {
+      map.set(new RegExp(`^${config.target}$`), {
+        replacement: config.replacement || null,
+        namedImports: config.namedImports || null,
+      })
+    }
+  })
+  return map
+}
+
+/**
+ * @param {string} importSource
+ * @param {string[]} namedImports
+ * @param {Map<RegExp, ImportRestrictionOptions>} restrictedPackages
+ */
+const checkIsRestrictedImport = (importSource, namedImports, restrictedPackages) => {
+  for (const [pattern, restrictedPackageOptions] of restrictedPackages) {
+    if (pattern.test(importSource)) {
+      if (!restrictedPackageOptions.namedImports?.length) {
+        return {
+          type: 'module',
+          pattern,
+        }
+      }
+
+      const restrictedImportedName = restrictedPackageOptions.namedImports.find((namedImport) =>
+        namedImports.includes(namedImport),
+      )
+      if (restrictedImportedName) {
+        return {
+          type: 'importedName',
+          pattern,
+          restrictedImportedName,
+        }
+      }
+    }
+  }
+  return null
+}
+
+/**
+ * Strip the beginning and ending of RegExp pattern (e.g. ^pattern$ -> pattern)
+ * @param {string} regExpPatternSource
+ */
+const getPatternDisplayName = (regExpPatternSource) => regExpPatternSource.slice(1, -1)
+
+const getQuoteStyle = (target) => (target?.includes("'") ? "'" : '"')
+
+/**
+ * Format a list of import specifiers as a string
+ * @param {Array<{imported: string, local: string}>} specifiers
+ * @returns {string}
+ */
+const formatSpecifiers = (specifiers) => {
+  return specifiers.map((s) => (s.imported === s.local ? s.imported : `${s.imported} as ${s.local}`)).join(', ')
+}
+
+/**
+ * Creates the text for a new import statement
+ * @param {Object} options
+ * @param {Array} options.specifiers - The import specifiers
+ * @param {string} options.source - The import source
+ * @param {string} options.quote - The quote style
+ * @param {string} options.semicolon - The semicolon (if any)
+ * @returns {string}
+ */
+const createImportText = ({ specifiers, source, quote, semicolon = '' }) => {
+  const defaultSpecifier = specifiers.find((s) => s.type === 'ImportDefaultSpecifier')
+  const namespaceSpecifier = specifiers.find((s) => s.type === 'ImportNamespaceSpecifier')
+  const namedSpecifiers = specifiers.filter((s) => s.type === 'ImportSpecifier')
+
+  if (namespaceSpecifier) {
+    return `import * as ${namespaceSpecifier.local.name} from ${quote}${source}${quote}${semicolon}`
+  }
+
+  if (defaultSpecifier) {
+    if (namedSpecifiers.length === 0) {
+      return `import ${defaultSpecifier.local.name} from ${quote}${source}${quote}${semicolon}`
+    }
+
+    const namedText = namedSpecifiers
+      .map((s) => (s.imported.name === s.local.name ? s.imported.name : `${s.imported.name} as ${s.local.name}`))
+      .join(', ')
+
+    return `import ${defaultSpecifier.local.name}, { ${namedText} } from ${quote}${source}${quote}${semicolon}`
+  }
+
+  if (namedSpecifiers.length > 0) {
+    const namedText = namedSpecifiers
+      .map((s) => (s.imported.name === s.local.name ? s.imported.name : `${s.imported.name} as ${s.local.name}`))
+      .join(', ')
+
+    return `import { ${namedText} } from ${quote}${source}${quote}${semicolon}`
+  }
+
+  return `import ${quote}${source}${quote}${semicolon}`
+}
+
+/**
+ * @param {import('eslint').Rule.RuleContext} context
+ * @param {import('estree').ImportDeclaration} node
+ * @param {string[]} restrictedNames
+ * @param {string} replacement
+ * @returns {(fixer: import('eslint').Rule.RuleFixer) => void}
+ * @deprecated Function no longer used as each restriction is now handled individually
+ */
+// eslint-disable-next-line no-unused-vars
+const createNamedImportReplacer = (context, node, restrictedNames, replacement) => {
+  return (fixer) => {
+    if (!replacement) return null
+
+    const quote = getQuoteStyle(node.source.raw)
+    const semicolon = node.source.raw.endsWith(';') || node.source.value.endsWith(';') ? ';' : ''
+    const fixes = []
+
+    // Find restricted specifiers to move
+    const restrictedSpecifiers = node.specifiers.filter(
+      (specifier) => specifier.type === 'ImportSpecifier' && restrictedNames.includes(specifier.imported.name),
+    )
+
+    if (restrictedSpecifiers.length === 0) {
+      return null
+    }
+
+    // Format the restricted specifiers for moving
+    const specifiersToMove = restrictedSpecifiers.map((specifier) => ({
+      imported: specifier.imported.name,
+      local: specifier.local.name,
+    }))
+
+    // Handle the original import
+    const remainingSpecifiers = node.specifiers.filter(
+      (specifier) => specifier.type !== 'ImportSpecifier' || !restrictedNames.includes(specifier.imported.name),
+    )
+
+    // Remove or update the original import
+    if (remainingSpecifiers.length === 0) {
+      fixes.push(fixer.remove(node))
+    } else if (remainingSpecifiers.length < node.specifiers.length) {
+      const newImportText = createImportText({
+        specifiers: remainingSpecifiers,
+        source: node.source.value,
+        quote,
+        semicolon,
+      })
+      fixes.push(fixer.replaceText(node, newImportText))
+    }
+
+    // Add imports to the replacement module
+    const { sourceCode } = context
+    const allImports = sourceCode.ast.body.filter(
+      (node) => node.type === 'ImportDeclaration' && node.source.type === 'Literal',
+    )
+
+    const existingReplacementImport = allImports.find((importNode) => importNode.source.value === replacement)
+
+    if (existingReplacementImport) {
+      fixes.push(
+        ...updateExistingImport(
+          fixer,
+          sourceCode,
+          existingReplacementImport,
+          specifiersToMove,
+          quote,
+          semicolon,
+          replacement,
+        ),
+      )
+    } else {
+      // Create a new import for the replacement
+      const newSpecifiersText = formatSpecifiers(specifiersToMove)
+      const newImport = `import { ${newSpecifiersText} } from ${quote}${replacement}${quote}${semicolon}`
+      fixes.push(fixer.insertTextBefore(node, newImport + '\n'))
+    }
+
+    return fixes
+  }
+}
+
+/**
+ * Updates an existing import with new specifiers
+ * @param {import('eslint').Rule.RuleFixer} fixer
+ * @param {import('eslint').SourceCode} sourceCode
+ * @param {import('estree').ImportDeclaration} existingImport
+ * @param {Array<{imported: string, local: string}>} specifiersToAdd
+ * @param {string} quote
+ * @param {string} semicolon
+ * @param {string} replacement
+ * @returns {Array<import('eslint').Rule.Fix>}
+ */
+const updateExistingImport = (fixer, sourceCode, existingImport, specifiersToAdd, quote, semicolon, replacement) => {
+  const fixes = []
+  const existingNamedSpecifiers = existingImport.specifiers
+    .filter((s) => s.type === 'ImportSpecifier')
+    .map((s) => s.imported.name)
+
+  const newSpecifiersToAdd = specifiersToAdd.filter((s) => !existingNamedSpecifiers.includes(s.imported))
+
+  if (newSpecifiersToAdd.length === 0) {
+    return fixes
+  }
+
+  const existingText = sourceCode.getText(existingImport)
+  const namedSpecifiers = existingImport.specifiers.filter((s) => s.type === 'ImportSpecifier')
+
+  if (namedSpecifiers.length > 0) {
+    // Add new specifiers to existing named imports
+    const existingSpecifiersMatch = existingText.match(/import\s*(?:[^{]*,\s*)?{([^}]*)}/)
+    if (existingSpecifiersMatch) {
+      const existingSpecifiersText = existingSpecifiersMatch[1].trim()
+      const newSpecifierText = formatSpecifiers(newSpecifiersToAdd)
+      const combinedSpecifiers = `${existingSpecifiersText}, ${newSpecifierText}`
+      const newImportText = existingText.replace(/\{[^}]*\}/, `{ ${combinedSpecifiers} }`)
+      fixes.push(fixer.replaceText(existingImport, newImportText))
+    }
+  } else {
+    // Handle imports with default but no named imports
+    const defaultSpecifier = existingImport.specifiers.find((s) => s.type === 'ImportDefaultSpecifier')
+    if (defaultSpecifier) {
+      const defaultName = defaultSpecifier.local.name
+      const newSpecifiersText = formatSpecifiers(newSpecifiersToAdd)
+      const newText = `import ${defaultName}, { ${newSpecifiersText} } from ${quote}${replacement}${quote}${semicolon}`
+      fixes.push(fixer.replaceText(existingImport, newText))
+    }
+  }
+
+  return fixes
+}
+
+/**
+ * @param {import('estree').ImportDeclaration['source']} sourceNode
+ * @param {string} replacement
+ * @param {'"' | "'"} quote
+ * @returns {(fixer: import('eslint').Rule.RuleFixer) => void}
+ */
+const createStringReplacer = (sourceNode, replacement, quote) => {
+  return (fixer) => fixer.replaceText(sourceNode, `${quote}${replacement}${quote}`)
+}
+
+/**
+ * @param {import('estree').ImportDeclaration['source']} sourceNode
+ * @param {Replacement} replacementPatterns
+ * @param {'"' | "'"} quote
+ * @returns {(fixer: import('eslint').Rule.RuleFixer) => void}
+ */
+const createPatternReplacer = (sourceNode, replacementPatterns, quote) => {
+  return (fixer) => {
+    let result = sourceNode.value
+
+    if (typeof replacementPatterns === 'string') {
+      return createStringReplacer(sourceNode, replacementPatterns, quote)
+    }
+
+    for (const [pattern, replacement] of Object.entries(replacementPatterns)) {
+      const regex = new RegExp(pattern, 'g')
+      result = result.replace(regex, replacement)
+    }
+    return fixer.replaceText(sourceNode, `${quote}${result}${quote}`)
+  }
+}
+
+/**
+ * @param {import('estree').ImportDeclaration} node
+ * @param {Replacement} replacement
+ * @returns {(fixer: import('eslint').Rule.RuleFixer) => void}
+ */
+const createModuleReplacer = (node, replacement) => {
+  if (!replacement) return null
+
+  const quote = getQuoteStyle(node.source.raw)
+
+  if (typeof replacement === 'string') {
+    return createStringReplacer(node.source, replacement, quote)
+  }
+
+  return createPatternReplacer(node.source, replacement, quote)
+}
+
+/**
+ * @param {import('eslint').Rule.RuleContext} context
+ * @param {import('estree').ImportDeclaration} node
+ * @param {Array<{importName: string, replacement: string}>} importRestrictions
+ * @returns {(fixer: import('eslint').Rule.RuleFixer) => any}
+ */
+const createMultiNamedImportReplacer = (context, node, importRestrictions) => {
+  return (fixer) => {
+    if (!importRestrictions.length) return null
+
+    const quote = getQuoteStyle(node.source.raw)
+    const semicolon = node.source.raw.endsWith(';') || node.source.value.endsWith(';') ? ';' : ''
+    const fixes = []
+
+    const allRestrictedNames = importRestrictions.map((r) => r.importName)
+
+    // Group imports by replacement
+    const groupedByReplacement = importRestrictions.reduce((acc, restriction) => {
+      if (!restriction.replacement) return acc
+
+      if (!acc[restriction.replacement]) {
+        acc[restriction.replacement] = []
+      }
+
+      acc[restriction.replacement].push(restriction.importName)
+
+      return acc
+    }, {})
+
+    // Find non-restricted specifiers from the original import
+    const remainingSpecifiers = node.specifiers.filter(
+      (specifier) => specifier.type !== 'ImportSpecifier' || !allRestrictedNames.includes(specifier.imported.name),
+    )
+
+    // Update or remove the original import
+    if (remainingSpecifiers.length === 0) {
+      fixes.push(fixer.remove(node))
+    } else {
+      const newImportText = createImportText({
+        specifiers: remainingSpecifiers,
+        source: node.source.value,
+        quote,
+        semicolon,
+      })
+      fixes.push(fixer.replaceText(node, newImportText))
+    }
+
+    // Create new imports for each replacement module
+    const { sourceCode } = context
+    const allImports = sourceCode.ast.body.filter(
+      (node) => node.type === 'ImportDeclaration' && node.source.type === 'Literal',
+    )
+
+    // Process each replacement module
+    Object.entries(groupedByReplacement).forEach(([replacement, restrictedNames]) => {
+      // Find specifiers to move
+      const specifiersToMove = restrictedNames
+        .map((name) => {
+          const specifier = node.specifiers.find((s) => s.type === 'ImportSpecifier' && s.imported.name === name)
+          return specifier
+            ? {
+                imported: specifier.imported.name,
+                local: specifier.local.name,
+              }
+            : null
+        })
+        .filter(Boolean)
+
+      if (specifiersToMove.length === 0) return
+
+      // Find existing import for the same replacement module
+      const existingReplacementImport = allImports.find((importNode) => importNode.source.value === replacement)
+
+      if (existingReplacementImport) {
+        // Add to existing import
+        fixes.push(
+          ...updateExistingImport(
+            fixer,
+            sourceCode,
+            existingReplacementImport,
+            specifiersToMove,
+            quote,
+            semicolon,
+            replacement,
+          ),
+        )
+      } else {
+        // Create new import
+        const newSpecifiersText = formatSpecifiers(specifiersToMove)
+        const newImport = `import { ${newSpecifiersText} } from ${quote}${replacement}${quote}${semicolon}`
+        fixes.push(fixer.insertTextBefore(node, newImport + '\n'))
+      }
+    })
+
+    return fixes
+  }
+}
 
 /** @type {import('eslint').Rule.RuleModule} */
 module.exports = {
   meta: {
-    type: "problem",
+    type: 'problem',
     docs: {
-      description:
-        "Prevent the Import of a Specific Package",
+      description: 'Prevent the Import of a Specific Package',
       recommended: false,
-      url: "https://github.com/custardcream98/eslint-plugin-restrict-replace-import/blob/main/docs/rules/restrict-import.md",
+      url: 'https://github.com/custardcream98/eslint-plugin-restrict-replace-import/blob/main/docs/rules/restrict-import.md',
     },
-    fixable: "code",
+    fixable: 'code',
 
     messages: {
-      ImportRestriction:
-        "`{{ name }}` is restricted from being used.",
+      ImportRestriction: '`{{ name }}` is restricted from being used.',
       ImportRestrictionWithReplacement:
-        "`{{ name }}` is restricted from being used. Replace it with `{{ replacement }}`.",
+        '`{{ name }}` is restricted from being used. Replace it with `{{ replacement }}`.',
+      ImportedNameRestriction: "Import of '{{importedName}}' from '{{name}}' is restricted",
+      ImportedNameRestrictionWithReplacement:
+        "Import of '{{importedName}}' from '{{name}}' is restricted. Replace it with '{{replacement}}'.",
     },
 
     schema: {
-      type: "array",
+      type: 'array',
       maxLength: 1,
       minLength: 1,
       items: {
-        type: "array",
+        type: 'array',
         items: {
           oneOf: [
             {
-              type: "string",
+              type: 'string',
             },
             {
-              type: "object",
+              type: 'object',
               properties: {
                 target: {
-                  type: "string",
+                  type: 'string',
+                  description: 'The target of the import to be restricted',
+                },
+                namedImports: {
+                  type: 'array',
+                  items: { type: 'string' },
+                  description:
+                    'The named imports to be restricted. If not provided, all named imports will be restricted.',
                 },
                 replacement: {
                   oneOf: [
-                    { type: "string" },
-                    { 
-                      type: "object", 
+                    { type: 'string' },
+                    {
+                      type: 'object',
                       patternProperties: {
-                        ".*": { type: "string" }
-                      }
-                    }
-                  ]
+                        '.*': { type: 'string' },
+                      },
+                    },
+                  ],
+                  description:
+                    'The replacement for the import. If a string is provided, it will be used as the replacement for all imports. If an object is provided, the keys will be used as the pattern and the values will be used as the replacement.',
                 },
               },
-              required: ["target"],
+              required: ['target'],
               additionalProperties: false,
             },
           ],
@@ -62,106 +464,85 @@ module.exports = {
   },
 
   create(context) {
-    const restrictedPackages = new Map();
-    const restrictedPackagesOption = context.options[0];
-
-    restrictedPackagesOption.forEach((packageName) => {
-      if (typeof packageName === "string") {
-        restrictedPackages.set(
-          new RegExp(`^${packageName}$`),
-          null
-        );
-        return;
-      }
-
-      restrictedPackages.set(
-        new RegExp(`^${packageName.target}$`),
-        packageName.replacement
-          ? packageName.replacement
-          : null
-      );
-    });
-
-    const checkRestricted = (importSource) => {
-      const restrictedRegExp = Array.from(
-        restrictedPackages.keys()
-      ).find((packageName) => {
-        return packageName.test(importSource);
-      });
-
-      return {
-        isRestricted: !!restrictedRegExp,
-        restrictedRegExp,
-      };
-    };
-
-    const getReplacement = (restrictedRegExp) => {
-      const replacement = restrictedPackages.get(
-        restrictedRegExp
-      );
-
-      return replacement;
-    };
+    const restrictedPackages = createRestrictedPackagesMap(context.options[0])
 
     return {
       ImportDeclaration(node) {
-        const importSource = node.source.value;
-        const importSourceType = node.source.type;
+        if (node.source.type !== 'Literal') return
+
+        const importSource = node.source.value
+        const namedImports = node.specifiers
+          .filter((specifier) => specifier.type === 'ImportSpecifier')
+          .map((specifier) => specifier.imported.name)
+        const checkerResult = checkIsRestrictedImport(importSource, namedImports, restrictedPackages)
+
+        if (!checkerResult) return
 
-        const { isRestricted, restrictedRegExp } =
-          checkRestricted(importSource);
+        const restrictedPackageOptions = restrictedPackages.get(checkerResult.pattern)
+        const patternName = getPatternDisplayName(checkerResult.pattern.source)
 
-        if (
-          !isRestricted ||
-          importSourceType !== "Literal"
-        ) {
-          return;
+        if (checkerResult.type === 'module') {
+          context.report({
+            node,
+            messageId:
+              typeof restrictedPackageOptions.replacement === 'string'
+                ? 'ImportRestrictionWithReplacement'
+                : 'ImportRestriction',
+            data: {
+              name: patternName,
+              replacement: restrictedPackageOptions.replacement,
+            },
+            fix: createModuleReplacer(node, restrictedPackageOptions.replacement),
+          })
+          return
         }
 
-        const replacement = getReplacement(
-          restrictedRegExp
-        );
-        const quote = node.source.raw.includes("'")
-          ? "'"
-          : '"';
-
-        context.report({
-          node,
-          messageId: typeof replacement === "string"
-            ? "ImportRestrictionWithReplacement"
-            : "ImportRestriction",
-          data: {
-            name: restrictedRegExp.toString().slice(2, -2),
-            replacement,
-          },
-          fix: (fixer) => {
-            if (!replacement) {
-              return;
-            }
+        // Find potential rules and replacement mappings for multiple restricted named imports
 
-            if (typeof replacement === "string") {
-              return fixer.replaceText(
-                node.source,
-                `${quote}${replacement}${quote}`
-              );
-            }
+        /**
+         * @type {{importName: string, replacement: string | null, pattern: RegExp}[]}
+         */
+        const importRestrictions = []
 
-            if (typeof replacement === "object") {
-              let partiallyReplaced = node.source.value;
-              for (const [key, value] of Object.entries(replacement)) {
-                const regex = new RegExp(key, 'g');
-                partiallyReplaced = partiallyReplaced.replace(regex, value);
-              }
-              return fixer.replaceText(
-                node.source,
-                `${quote}${partiallyReplaced}${quote}`
-              );
+        // Check each named import for restrictions
+        namedImports.forEach((importName) => {
+          for (const [pattern, options] of restrictedPackages.entries()) {
+            if (
+              pattern.test(importSource) &&
+              options.namedImports &&
+              options.namedImports.includes(importName) &&
+              // TODO: handle options.replacement as an object
+              (typeof options.replacement === 'string' || options.replacement === null)
+            ) {
+              importRestrictions.push({
+                importName,
+                replacement: options.replacement,
+                pattern,
+              })
+
+              break // Only use the first matching restriction for an import
             }
+          }
+        })
 
-            return null;
-          },
-        });
+        if (importRestrictions.length === 0) {
+          return
+        }
+
+        // Report separate errors for each restricted import
+        importRestrictions.forEach((restriction) => {
+          context.report({
+            node,
+            messageId: restriction.replacement ? 'ImportedNameRestrictionWithReplacement' : 'ImportedNameRestriction',
+            data: {
+              importedName: restriction.importName,
+              name: importSource,
+              replacement: restriction.replacement,
+            },
+            fix: restriction.replacement ? createMultiNamedImportReplacer(context, node, importRestrictions) : null,
+          })
+        })
       },
-    };
+    }
   },
-};
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eslint-plugin-restrict-replace-import",
-  "version": "1.3.0",
+  "version": "1.5.0",
   "description": "ESLint Plugin for Restricting and Replacing Import",
   "keywords": [
     "eslint",
@@ -20,22 +20,27 @@
   "main": "./lib/index.js",
   "exports": "./lib/index.js",
   "scripts": {
+    "format": "prettier --write .",
     "lint": "npm-run-all \"lint:*\"",
     "lint:eslint-docs": "npm-run-all \"update:eslint-docs -- --check\"",
     "lint:js": "eslint .",
     "test": "mocha tests --recursive",
-    "update:eslint-docs": "eslint-doc-generator"
+    "update:eslint-docs": "eslint-doc-generator",
+    "release": "npm run lint && npm run test && npm publish"
   },
   "dependencies": {
     "requireindex": "^1.2.0"
   },
   "devDependencies": {
-    "eslint": "^8.19.0",
-    "eslint-doc-generator": "^1.0.0",
-    "eslint-plugin-eslint-plugin": "^5.0.0",
+    "@eslint/compat": "^1.2.7",
+    "@types/estree": "^1.0.6",
+    "eslint": "^9.22.0",
+    "eslint-doc-generator": "^2.1.0",
+    "eslint-plugin-eslint-plugin": "^6.4.0",
     "eslint-plugin-node": "^11.1.0",
     "mocha": "^10.0.0",
-    "npm-run-all": "^4.1.5"
+    "npm-run-all": "^4.1.5",
+    "prettier": "^3.5.3"
   },
   "engines": {
     "node": "^14.17.0 || ^16.0.0 || >= 18.0.0"

package/.eslintrc.js

@@ -1,19 +0,0 @@
-"use strict";
-
-module.exports = {
-  root: true,
-  extends: [
-    "eslint:recommended",
-    "plugin:eslint-plugin/recommended",
-    "plugin:node/recommended",
-  ],
-  env: {
-    node: true,
-  },
-  overrides: [
-    {
-      files: ["tests/**/*.js"],
-      env: { mocha: true },
-    },
-  ],
-};