Import restricting rules now catch specific names if they are immediately destructured

Author: denis-sokolov

src/imports/defineImportsRule/check.ts

@@ -141,19 +141,21 @@ export function makeCheckingFunction({
             ? node.specifiers.filter((specifier) =>
                 names.includes(getSpecifierName(specifier.exported)),
               )
-            : [];
-      if (specifiers.length === 0) {
-        throw Error(
-          "You have provided a forbiddenName or forbiddenNames, but I did not pass you any of these as actually imported.",
-        );
-      }
-      specifiers.forEach((specifier) => {
-        context.report({
-          loc: specifier.loc,
-          message,
+            : "can-not-find-specifiers";
+      if (specifiers !== "can-not-find-specifiers") {
+        if (specifiers.length === 0) {
+          throw Error(
+            "You have provided a forbiddenName or forbiddenNames, but I did not pass you any of these as actually imported.",
+          );
+        }
+        specifiers.forEach((specifier) => {
+          context.report({
+            loc: specifier.loc,
+            message,
+          });
         });
-      });
-      return;
+        return;
+      }
     }
     context.report({
       fix: fix

src/imports/defineImportsRule/index.ts

@@ -83,8 +83,25 @@ export function defineImportsRule(f: (details: ImportDetails) => CheckResult) {
       ImportExpression(node) {
         if (node.source.type !== "Literal") return;
         if (typeof node.source.value !== "string") return;
+
+        const names: string[] = (function () {
+          const { parent } = node;
+          if (parent.type !== "AwaitExpression") return [];
+          const grandParent = parent.parent;
+          if (grandParent.type !== "VariableDeclarator") return [];
+          const declarator = grandParent;
+          if (declarator.id.type !== "ObjectPattern") return [];
+          const { properties } = declarator.id;
+          return properties
+            .map((property) => {
+              if (property.type !== "Property") return undefined;
+              if (property.key.type !== "Identifier") return undefined;
+              return property.key.name;
+            })
+            .filter(Boolean);
+        })();
         check({
-          names: [],
+          names,
           node: {
             ...node,
             source: { ...node.source, value: node.source.value },

src/rules/no-forward-ref.test.ts

@@ -21,6 +21,12 @@ invalid(
   "import { type Ref, forwardRef, useState } from 'react'",
 );
 
+invalid(
+  rule,
+  "can not import forwardRef using dynamic import",
+  "const { forwardRef } = await import('react')",
+);
+
 invalid(
   rule,
   "can not import ForwardedRef",