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

package/README.md

@@ -126,7 +126,7 @@ You can also restrict specific named imports from a package while allowing other
         {
           "target": "restricted-module",
           "namedImports": ["restrictedImport", "alsoRestricted"],
-          "replacement": "replacement-module"
+          "replacement": "replacement-module" // Object is not supported yet
         }
       ]
     ]

package/docs/rules/restrict-import.md

@@ -129,7 +129,7 @@ import { useState } from 'successfully-replaced'
       [{
         "target": "restricted-module",
         "namedImports": ["restrictedImport", "alsoRestricted"],
-        "replacement": "replacement-module"
+        "replacement": "replacement-module" // Object is not supported yet
       }]
     ]
   }

package/lib/rules/restrict-import.js

@@ -4,9 +4,14 @@
  */
 'use strict'
 
+/**
+ * @typedef {string | {[key: string]: string;}} Replacement
+ * @typedef {{replacement: Replacement | null; namedImports: string[] | null;}} ImportRestrictionOptions
+ */
+
 const createRestrictedPackagesMap = (options) => {
   /**
-   * @type {Map<RegExp, { replacement: string | { [key: string]: string } | null, namedImports: string[] | null }>}
+   * @type {Map<RegExp, ImportRestrictionOptions>}
    */
   const map = new Map()
   options.forEach((config) => {
@@ -28,7 +33,7 @@ const createRestrictedPackagesMap = (options) => {
 /**
  * @param {string} importSource
  * @param {string[]} namedImports
- * @param {Map<RegExp, { replacement: string | { [key: string]: string } | null, namedImports: string[] | null }>} restrictedPackages
+ * @param {Map<RegExp, ImportRestrictionOptions>} restrictedPackages
  */
 const checkIsRestrictedImport = (importSource, namedImports, restrictedPackages) => {
   for (const [pattern, restrictedPackageOptions] of restrictedPackages) {
@@ -119,7 +124,9 @@ const createImportText = ({ specifiers, source, quote, semicolon = '' }) => {
  * @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
@@ -254,7 +261,7 @@ const createStringReplacer = (sourceNode, replacement, quote) => {
 
 /**
  * @param {import('estree').ImportDeclaration['source']} sourceNode
- * @param {string | { [key: string]: string }} replacementPatterns
+ * @param {Replacement} replacementPatterns
  * @param {'"' | "'"} quote
  * @returns {(fixer: import('eslint').Rule.RuleFixer) => void}
  */
@@ -276,7 +283,7 @@ const createPatternReplacer = (sourceNode, replacementPatterns, quote) => {
 
 /**
  * @param {import('estree').ImportDeclaration} node
- * @param {string | { [key: string]: string }} replacement
+ * @param {Replacement} replacement
  * @returns {(fixer: import('eslint').Rule.RuleFixer) => void}
  */
 const createModuleReplacer = (node, replacement) => {
@@ -291,6 +298,104 @@ const createModuleReplacer = (node, replacement) => {
   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: {
@@ -392,26 +497,49 @@ module.exports = {
           return
         }
 
-        const restrictedImports = restrictedPackageOptions.namedImports.filter((name) => namedImports.includes(name))
+        // Find potential rules and replacement mappings for multiple restricted named imports
+
+        /**
+         * @type {{importName: string, replacement: string | null, pattern: RegExp}[]}
+         */
+        const importRestrictions = []
+
+        // 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
+            }
+          }
+        })
 
-        restrictedImports.forEach((restrictedImportedName) => {
+        if (importRestrictions.length === 0) {
+          return
+        }
+
+        // Report separate errors for each restricted import
+        importRestrictions.forEach((restriction) => {
           context.report({
             node,
-            messageId:
-              typeof restrictedPackageOptions.replacement === 'string'
-                ? 'ImportedNameRestrictionWithReplacement'
-                : 'ImportedNameRestriction',
+            messageId: restriction.replacement ? 'ImportedNameRestrictionWithReplacement' : 'ImportedNameRestriction',
             data: {
-              importedName: restrictedImportedName,
+              importedName: restriction.importName,
               name: importSource,
-              replacement: restrictedPackageOptions.replacement,
+              replacement: restriction.replacement,
             },
-            fix: createNamedImportReplacer(
-              context,
-              node,
-              restrictedPackageOptions.namedImports,
-              restrictedPackageOptions.replacement,
-            ),
+            fix: restriction.replacement ? createMultiNamedImportReplacer(context, node, importRestrictions) : null,
           })
         })
       },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eslint-plugin-restrict-replace-import",
-  "version": "1.4.0",
+  "version": "1.5.0",
   "description": "ESLint Plugin for Restricting and Replacing Import",
   "keywords": [
     "eslint",
@@ -26,7 +26,7 @@
     "lint:js": "eslint .",
     "test": "mocha tests --recursive",
     "update:eslint-docs": "eslint-doc-generator",
-    "publish": "npm run lint && npm run test && npm publish"
+    "release": "npm run lint && npm run test && npm publish"
   },
   "dependencies": {
     "requireindex": "^1.2.0"