eslint-plugin-react-web-api 1.34.0-beta.0 → 1.34.0-beta.1

package/dist/index.js

@@ -55,7 +55,7 @@ var settings = {
 
 // package.json
 var name2 = "eslint-plugin-react-web-api";
-var version = "1.34.0-beta.0";
+var version = "1.34.0-beta.1";
 var createRule = shared.createRuleForPlugin("web-api");
 function getPhaseKindOfFunction(node) {
   return tsPattern.match(node).when(core.isFunctionOfUseEffectSetup, () => "setup").when(core.isFunctionOfUseEffectCleanup, () => "cleanup").when(core.isFunctionOfComponentDidMount, () => "mount").when(core.isFunctionOfComponentWillUnmount, () => "unmount").otherwise(() => eff._);
@@ -158,139 +158,140 @@ var no_leaked_event_listener_default = createRule({
     schema: []
   },
   name: RULE_NAME,
-  create(context) {
-    if (!context.sourceCode.text.includes("addEventListener")) {
-      return {};
+  create,
+  defaultOptions: []
+});
+function create(context) {
+  if (!context.sourceCode.text.includes("addEventListener")) {
+    return {};
+  }
+  if (!/use\w*Effect|componentDidMount|componentWillUnmount/u.test(context.sourceCode.text)) {
+    return {};
+  }
+  const fEntries = [];
+  const aEntries = [];
+  const rEntries = [];
+  const abortedSignals = [];
+  function isSameObject(a, b) {
+    switch (true) {
+      case (a.type === utils.AST_NODE_TYPES.MemberExpression && b.type === utils.AST_NODE_TYPES.MemberExpression):
+        return AST__namespace.isNodeEqual(a.object, b.object);
+      // TODO: Maybe there other cases to consider here.
+      default:
+        return false;
     }
-    if (!/use\w*Effect|componentDidMount|componentWillUnmount/u.test(context.sourceCode.text)) {
-      return {};
+  }
+  function isInverseEntry(aEntry, rEntry) {
+    const { type: aType, callee: aCallee, capture: aCapture, listener: aListener, phase: aPhase } = aEntry;
+    const { type: rType, callee: rCallee, capture: rCapture, listener: rListener, phase: rPhase } = rEntry;
+    if (!core.isInversePhase(aPhase, rPhase)) {
+      return false;
     }
-    const fEntries = [];
-    const aEntries = [];
-    const rEntries = [];
-    const abortedSignals = [];
-    function isSameObject(a, b) {
-      switch (true) {
-        case (a.type === utils.AST_NODE_TYPES.MemberExpression && b.type === utils.AST_NODE_TYPES.MemberExpression):
-          return AST__namespace.isNodeEqual(a.object, b.object);
-        // TODO: Maybe there other cases to consider here.
-        default:
-          return false;
-      }
+    return isSameObject(aCallee, rCallee) && AST__namespace.isNodeEqual(aListener, rListener) && VAR__namespace.isNodeValueEqual(aType, rType, [
+      context.sourceCode.getScope(aType),
+      context.sourceCode.getScope(rType)
+    ]) && aCapture === rCapture;
+  }
+  function checkInlineFunction(node, callKind, options) {
+    const listener = node.arguments.at(1);
+    if (!AST__namespace.isFunction(listener)) {
+      return;
     }
-    function isInverseEntry(aEntry, rEntry) {
-      const { type: aType, callee: aCallee, capture: aCapture, listener: aListener, phase: aPhase } = aEntry;
-      const { type: rType, callee: rCallee, capture: rCapture, listener: rListener, phase: rPhase } = rEntry;
-      if (!core.isInversePhase(aPhase, rPhase)) {
-        return false;
-      }
-      return isSameObject(aCallee, rCallee) && AST__namespace.isNodeEqual(aListener, rListener) && VAR__namespace.isNodeValueEqual(aType, rType, [
-        context.sourceCode.getScope(aType),
-        context.sourceCode.getScope(rType)
-      ]) && aCapture === rCapture;
+    if (options.signal != null) {
+      return;
     }
-    function checkInlineFunction(node, callKind, options) {
-      const listener = node.arguments.at(1);
-      if (!AST__namespace.isFunction(listener)) {
+    context.report({
+      messageId: "unexpectedInlineFunction",
+      node: listener,
+      data: { eventMethodKind: callKind }
+    });
+  }
+  return {
+    [":function"](node) {
+      const kind = getFunctionKind(node);
+      fEntries.push({ kind, node });
+    },
+    [":function:exit"]() {
+      fEntries.pop();
+    },
+    ["CallExpression"](node) {
+      const fKind = fEntries.findLast((x) => x.kind !== "other")?.kind;
+      if (fKind == null) {
         return;
       }
-      if (options.signal != null) {
+      if (!core.ERPhaseRelevance.has(fKind)) {
         return;
       }
-      context.report({
-        messageId: "unexpectedInlineFunction",
-        node: listener,
-        data: { eventMethodKind: callKind }
-      });
-    }
-    return {
-      [":function"](node) {
-        const kind = getFunctionKind(node);
-        fEntries.push({ kind, node });
-      },
-      [":function:exit"]() {
-        fEntries.pop();
-      },
-      ["CallExpression"](node) {
-        const fKind = fEntries.findLast((x) => x.kind !== "other")?.kind;
-        if (fKind == null) {
+      tsPattern.match(getCallKind(node)).with("addEventListener", (callKind) => {
+        const [type, listener, options] = node.arguments;
+        if (type == null || listener == null) {
           return;
         }
-        if (!core.ERPhaseRelevance.has(fKind)) {
+        const opts = options == null ? defaultOptions : getOptions(options, context.sourceCode.getScope(options));
+        const { callee } = node;
+        checkInlineFunction(node, callKind, opts);
+        aEntries.push({
+          ...opts,
+          kind: "addEventListener",
+          type,
+          node,
+          callee,
+          listener,
+          phase: fKind
+        });
+      }).with("removeEventListener", (callKind) => {
+        const [type, listener, options] = node.arguments;
+        if (type == null || listener == null) {
           return;
         }
-        tsPattern.match(getCallKind(node)).with("addEventListener", (callKind) => {
-          const [type, listener, options] = node.arguments;
-          if (type == null || listener == null) {
-            return;
-          }
-          const opts = options == null ? defaultOptions : getOptions(options, context.sourceCode.getScope(options));
-          const { callee } = node;
-          checkInlineFunction(node, callKind, opts);
-          aEntries.push({
-            ...opts,
-            kind: "addEventListener",
-            type,
-            node,
-            callee,
-            listener,
-            phase: fKind
-          });
-        }).with("removeEventListener", (callKind) => {
-          const [type, listener, options] = node.arguments;
-          if (type == null || listener == null) {
-            return;
-          }
-          const opts = options == null ? defaultOptions : getOptions(options, context.sourceCode.getScope(options));
-          const { callee } = node;
-          checkInlineFunction(node, callKind, opts);
-          rEntries.push({
-            ...opts,
-            kind: "removeEventListener",
-            type,
-            node,
-            callee,
-            listener,
-            phase: fKind
-          });
-        }).with("abort", () => {
-          abortedSignals.push(node.callee);
-        }).otherwise(() => eff._);
-      },
-      ["Program:exit"]() {
-        for (const aEntry of aEntries) {
-          const signal = aEntry.signal;
-          if (signal != null && abortedSignals.some((a) => isSameObject(a, signal))) {
+        const opts = options == null ? defaultOptions : getOptions(options, context.sourceCode.getScope(options));
+        const { callee } = node;
+        checkInlineFunction(node, callKind, opts);
+        rEntries.push({
+          ...opts,
+          kind: "removeEventListener",
+          type,
+          node,
+          callee,
+          listener,
+          phase: fKind
+        });
+      }).with("abort", () => {
+        abortedSignals.push(node.callee);
+      }).otherwise(() => eff._);
+    },
+    ["Program:exit"]() {
+      for (const aEntry of aEntries) {
+        const signal = aEntry.signal;
+        if (signal != null && abortedSignals.some((a) => isSameObject(a, signal))) {
+          continue;
+        }
+        if (rEntries.some((rEntry) => isInverseEntry(aEntry, rEntry))) {
+          continue;
+        }
+        switch (aEntry.phase) {
+          case "setup":
+          case "cleanup":
+            context.report({
+              messageId: "expectedRemoveEventListenerInCleanup",
+              node: aEntry.node,
+              data: {
+                effectMethodKind: "useEffect"
+              }
+            });
             continue;
-          }
-          if (rEntries.some((rEntry) => isInverseEntry(aEntry, rEntry))) {
+          case "mount":
+          case "unmount":
+            context.report({
+              messageId: "expectedRemoveEventListenerInUnmount",
+              node: aEntry.node
+            });
             continue;
-          }
-          switch (aEntry.phase) {
-            case "setup":
-            case "cleanup":
-              context.report({
-                messageId: "expectedRemoveEventListenerInCleanup",
-                node: aEntry.node,
-                data: {
-                  effectMethodKind: "useEffect"
-                }
-              });
-              continue;
-            case "mount":
-            case "unmount":
-              context.report({
-                messageId: "expectedRemoveEventListenerInUnmount",
-                node: aEntry.node
-              });
-              continue;
-          }
         }
       }
-    };
-  },
-  defaultOptions: []
-});
+    }
+  };
+}
 var RULE_NAME2 = "no-leaked-interval";
 var RULE_FEATURES2 = [
   "CHK"
@@ -320,107 +321,108 @@ var no_leaked_interval_default = createRule({
     schema: []
   },
   name: RULE_NAME2,
-  create(context) {
-    if (!context.sourceCode.text.includes("setInterval")) {
-      return {};
-    }
-    const fEntries = [];
-    const sEntries = [];
-    const cEntries = [];
-    function isInverseEntry(a, b) {
-      return core.isInstanceIdEqual(context, a.timerId, b.timerId);
-    }
-    return {
-      [":function"](node) {
-        const kind = getPhaseKindOfFunction(node) ?? "other";
-        fEntries.push({ kind, node });
-      },
-      [":function:exit"]() {
-        fEntries.pop();
-      },
-      ["CallExpression"](node) {
-        switch (getCallKind2(node)) {
-          case "setInterval": {
-            const fEntry = fEntries.findLast((x) => x.kind !== "other");
-            if (fEntry == null) {
-              break;
-            }
-            if (!core.ERPhaseRelevance.has(fEntry.kind)) {
-              break;
-            }
-            const intervalIdNode = VAR__namespace.getVariableDeclaratorId(node);
-            if (intervalIdNode == null) {
-              context.report({
-                messageId: "expectedIntervalId",
-                node
-              });
-              break;
-            }
-            sEntries.push({
-              kind: "interval",
-              node,
-              callee: node.callee,
-              phase: fEntry.kind,
-              timerId: intervalIdNode
-            });
+  create: create2,
+  defaultOptions: []
+});
+function create2(context) {
+  if (!context.sourceCode.text.includes("setInterval")) {
+    return {};
+  }
+  const fEntries = [];
+  const sEntries = [];
+  const cEntries = [];
+  function isInverseEntry(a, b) {
+    return core.isInstanceIdEqual(context, a.timerId, b.timerId);
+  }
+  return {
+    [":function"](node) {
+      const kind = getPhaseKindOfFunction(node) ?? "other";
+      fEntries.push({ kind, node });
+    },
+    [":function:exit"]() {
+      fEntries.pop();
+    },
+    ["CallExpression"](node) {
+      switch (getCallKind2(node)) {
+        case "setInterval": {
+          const fEntry = fEntries.findLast((x) => x.kind !== "other");
+          if (fEntry == null) {
             break;
           }
-          case "clearInterval": {
-            const fEntry = fEntries.findLast((x) => x.kind !== "other");
-            if (fEntry == null) {
-              break;
-            }
-            if (!core.ERPhaseRelevance.has(fEntry.kind)) {
-              break;
-            }
-            const [intervalIdNode] = node.arguments;
-            if (intervalIdNode == null) {
-              break;
-            }
-            cEntries.push({
-              kind: "interval",
-              node,
-              callee: node.callee,
-              phase: fEntry.kind,
-              timerId: intervalIdNode
+          if (!core.ERPhaseRelevance.has(fEntry.kind)) {
+            break;
+          }
+          const intervalIdNode = VAR__namespace.getVariableDeclaratorId(node);
+          if (intervalIdNode == null) {
+            context.report({
+              messageId: "expectedIntervalId",
+              node
             });
             break;
           }
+          sEntries.push({
+            kind: "interval",
+            node,
+            callee: node.callee,
+            phase: fEntry.kind,
+            timerId: intervalIdNode
+          });
+          break;
         }
-      },
-      ["Program:exit"]() {
-        for (const sEntry of sEntries) {
-          if (cEntries.some((cEntry) => isInverseEntry(sEntry, cEntry))) {
-            continue;
+        case "clearInterval": {
+          const fEntry = fEntries.findLast((x) => x.kind !== "other");
+          if (fEntry == null) {
+            break;
           }
-          switch (sEntry.phase) {
-            case "setup":
-            case "cleanup":
-              context.report({
-                messageId: "expectedClearIntervalInCleanup",
-                node: sEntry.node,
-                data: {
-                  kind: "useEffect"
-                }
-              });
-              continue;
-            case "mount":
-            case "unmount":
-              context.report({
-                messageId: "expectedClearIntervalInUnmount",
-                node: sEntry.node,
-                data: {
-                  kind: "componentDidMount"
-                }
-              });
-              continue;
+          if (!core.ERPhaseRelevance.has(fEntry.kind)) {
+            break;
           }
+          const [intervalIdNode] = node.arguments;
+          if (intervalIdNode == null) {
+            break;
+          }
+          cEntries.push({
+            kind: "interval",
+            node,
+            callee: node.callee,
+            phase: fEntry.kind,
+            timerId: intervalIdNode
+          });
+          break;
         }
       }
-    };
-  },
-  defaultOptions: []
-});
+    },
+    ["Program:exit"]() {
+      for (const sEntry of sEntries) {
+        if (cEntries.some((cEntry) => isInverseEntry(sEntry, cEntry))) {
+          continue;
+        }
+        switch (sEntry.phase) {
+          case "setup":
+          case "cleanup":
+            context.report({
+              messageId: "expectedClearIntervalInCleanup",
+              node: sEntry.node,
+              data: {
+                kind: "useEffect"
+              }
+            });
+            continue;
+          case "mount":
+          case "unmount":
+            context.report({
+              messageId: "expectedClearIntervalInUnmount",
+              node: sEntry.node,
+              data: {
+                kind: "componentDidMount"
+              }
+            });
+            continue;
+        }
+      }
+    }
+  };
+}
 var RULE_NAME3 = "no-leaked-resize-observer";
 var RULE_FEATURES3 = [
   "CHK"
@@ -469,121 +471,122 @@ var no_leaked_resize_observer_default = createRule({
     schema: []
   },
   name: RULE_NAME3,
-  create(context) {
-    if (!context.sourceCode.text.includes("ResizeObserver")) {
-      return {};
-    }
-    const fEntries = [];
-    const observers = [];
-    const oEntries = [];
-    const uEntries = [];
-    const dEntries = [];
-    return {
-      [":function"](node) {
-        const kind = getFunctionKind2(node);
-        fEntries.push({ kind, node });
-      },
-      [":function:exit"]() {
-        fEntries.pop();
-      },
-      ["CallExpression"](node) {
-        if (node.callee.type !== utils.AST_NODE_TYPES.MemberExpression) {
-          return;
-        }
-        const fKind = fEntries.findLast((x) => x.kind !== "other")?.kind;
-        if (fKind == null || !core.ERPhaseRelevance.has(fKind)) {
-          return;
-        }
-        const { object } = node.callee;
-        tsPattern.match(getCallKind3(context, node)).with("disconnect", () => {
-          dEntries.push({
-            kind: "disconnect",
-            node,
-            callee: node.callee,
-            observer: object,
-            observerKind: "ResizeObserver",
-            phase: fKind
-          });
-        }).with("observe", () => {
-          const [element] = node.arguments;
-          if (element == null) {
-            return;
-          }
-          oEntries.push({
-            kind: "observe",
-            node,
-            callee: node.callee,
-            element,
-            observer: object,
-            observerKind: "ResizeObserver",
-            phase: fKind
-          });
-        }).with("unobserve", () => {
-          const [element] = node.arguments;
-          if (element == null) {
-            return;
-          }
-          uEntries.push({
-            kind: "unobserve",
-            node,
-            callee: node.callee,
-            element,
-            observer: object,
-            observerKind: "ResizeObserver",
-            phase: fKind
-          });
-        }).otherwise(() => eff._);
-      },
-      ["NewExpression"](node) {
-        const fEntry = fEntries.findLast((x) => x.kind !== "other");
-        if (fEntry == null) return;
-        if (!core.ERPhaseRelevance.has(fEntry.kind)) {
-          return;
-        }
-        if (!isNewResizeObserver(node)) {
+  create: create3,
+  defaultOptions: []
+});
+function create3(context) {
+  if (!context.sourceCode.text.includes("ResizeObserver")) {
+    return {};
+  }
+  const fEntries = [];
+  const observers = [];
+  const oEntries = [];
+  const uEntries = [];
+  const dEntries = [];
+  return {
+    [":function"](node) {
+      const kind = getFunctionKind2(node);
+      fEntries.push({ kind, node });
+    },
+    [":function:exit"]() {
+      fEntries.pop();
+    },
+    ["CallExpression"](node) {
+      if (node.callee.type !== utils.AST_NODE_TYPES.MemberExpression) {
+        return;
+      }
+      const fKind = fEntries.findLast((x) => x.kind !== "other")?.kind;
+      if (fKind == null || !core.ERPhaseRelevance.has(fKind)) {
+        return;
+      }
+      const { object } = node.callee;
+      tsPattern.match(getCallKind3(context, node)).with("disconnect", () => {
+        dEntries.push({
+          kind: "disconnect",
+          node,
+          callee: node.callee,
+          observer: object,
+          observerKind: "ResizeObserver",
+          phase: fKind
+        });
+      }).with("observe", () => {
+        const [element] = node.arguments;
+        if (element == null) {
           return;
         }
-        const id = core.getInstanceId(node);
-        if (id == null) {
-          context.report({
-            messageId: "unexpectedFloatingInstance",
-            node
-          });
+        oEntries.push({
+          kind: "observe",
+          node,
+          callee: node.callee,
+          element,
+          observer: object,
+          observerKind: "ResizeObserver",
+          phase: fKind
+        });
+      }).with("unobserve", () => {
+        const [element] = node.arguments;
+        if (element == null) {
           return;
         }
-        observers.push({
-          id,
+        uEntries.push({
+          kind: "unobserve",
           node,
-          phase: fEntry.kind,
-          phaseNode: fEntry.node
+          callee: node.callee,
+          element,
+          observer: object,
+          observerKind: "ResizeObserver",
+          phase: fKind
         });
-      },
-      ["Program:exit"]() {
-        for (const { id, node, phaseNode } of observers) {
-          if (dEntries.some((e) => core.isInstanceIdEqual(context, e.observer, id))) {
-            continue;
-          }
-          const oentries = oEntries.filter((e) => core.isInstanceIdEqual(context, e.observer, id));
-          const uentries = uEntries.filter((e) => core.isInstanceIdEqual(context, e.observer, id));
-          const isDynamic = (node2) => node2?.type === utils.AST_NODE_TYPES.CallExpression || AST__namespace.isConditional(node2);
-          const isPhaseNode = (node2) => node2 === phaseNode;
-          const hasDynamicallyAdded = oentries.some((e) => !isPhaseNode(AST__namespace.findParentNode(e.node, eff.or(isDynamic, isPhaseNode))));
-          if (hasDynamicallyAdded) {
-            context.report({ messageId: "expectedDisconnectInControlFlow", node });
+      }).otherwise(() => eff._);
+    },
+    ["NewExpression"](node) {
+      const fEntry = fEntries.findLast((x) => x.kind !== "other");
+      if (fEntry == null) return;
+      if (!core.ERPhaseRelevance.has(fEntry.kind)) {
+        return;
+      }
+      if (!isNewResizeObserver(node)) {
+        return;
+      }
+      const id = core.getInstanceId(node);
+      if (id == null) {
+        context.report({
+          messageId: "unexpectedFloatingInstance",
+          node
+        });
+        return;
+      }
+      observers.push({
+        id,
+        node,
+        phase: fEntry.kind,
+        phaseNode: fEntry.node
+      });
+    },
+    ["Program:exit"]() {
+      for (const { id, node, phaseNode } of observers) {
+        if (dEntries.some((e) => core.isInstanceIdEqual(context, e.observer, id))) {
+          continue;
+        }
+        const oentries = oEntries.filter((e) => core.isInstanceIdEqual(context, e.observer, id));
+        const uentries = uEntries.filter((e) => core.isInstanceIdEqual(context, e.observer, id));
+        const isDynamic = (node2) => node2?.type === utils.AST_NODE_TYPES.CallExpression || AST__namespace.isConditional(node2);
+        const isPhaseNode = (node2) => node2 === phaseNode;
+        const hasDynamicallyAdded = oentries.some((e) => !isPhaseNode(AST__namespace.findParentNode(e.node, eff.or(isDynamic, isPhaseNode))));
+        if (hasDynamicallyAdded) {
+          context.report({ messageId: "expectedDisconnectInControlFlow", node });
+          continue;
+        }
+        for (const oEntry of oentries) {
+          if (uentries.some((uEntry) => core.isInstanceIdEqual(context, uEntry.element, oEntry.element))) {
             continue;
           }
-          for (const oEntry of oentries) {
-            if (uentries.some((uEntry) => core.isInstanceIdEqual(context, uEntry.element, oEntry.element))) {
-              continue;
-            }
-            context.report({ messageId: "expectedDisconnectOrUnobserveInCleanup", node: oEntry.node });
-          }
+          context.report({ messageId: "expectedDisconnectOrUnobserveInCleanup", node: oEntry.node });
         }
       }
-    };
-  },
-  defaultOptions: []
-});
+    }
+  };
+}
 var RULE_NAME4 = "no-leaked-timeout";
 var RULE_FEATURES4 = [
   "CHK"
@@ -613,97 +616,98 @@ var no_leaked_timeout_default = createRule({
     schema: []
   },
   name: RULE_NAME4,
-  create(context) {
-    if (!context.sourceCode.text.includes("setTimeout")) {
-      return {};
-    }
-    const fEntries = [];
-    const sEntries = [];
-    const rEntries = [];
-    function isInverseEntry(a, b) {
-      return core.isInstanceIdEqual(context, a.timerId, b.timerId);
-    }
-    return {
-      [":function"](node) {
-        const kind = getPhaseKindOfFunction(node) ?? "other";
-        fEntries.push({ kind, node });
-      },
-      [":function:exit"]() {
-        fEntries.pop();
-      },
-      ["CallExpression"](node) {
-        const fEntry = fEntries.findLast((f) => f.kind !== "other");
-        if (!core.ERPhaseRelevance.has(fEntry?.kind)) {
-          return;
-        }
-        switch (getCallKind4(node)) {
-          case "setTimeout": {
-            const timeoutIdNode = VAR__namespace.getVariableDeclaratorId(node);
-            if (timeoutIdNode == null) {
-              context.report({
-                messageId: "expectedTimeoutId",
-                node
-              });
-              break;
-            }
-            sEntries.push({
-              kind: "timeout",
-              node,
-              callee: node.callee,
-              phase: fEntry.kind,
-              timerId: timeoutIdNode
+  create: create4,
+  defaultOptions: []
+});
+function create4(context) {
+  if (!context.sourceCode.text.includes("setTimeout")) {
+    return {};
+  }
+  const fEntries = [];
+  const sEntries = [];
+  const rEntries = [];
+  function isInverseEntry(a, b) {
+    return core.isInstanceIdEqual(context, a.timerId, b.timerId);
+  }
+  return {
+    [":function"](node) {
+      const kind = getPhaseKindOfFunction(node) ?? "other";
+      fEntries.push({ kind, node });
+    },
+    [":function:exit"]() {
+      fEntries.pop();
+    },
+    ["CallExpression"](node) {
+      const fEntry = fEntries.findLast((f) => f.kind !== "other");
+      if (!core.ERPhaseRelevance.has(fEntry?.kind)) {
+        return;
+      }
+      switch (getCallKind4(node)) {
+        case "setTimeout": {
+          const timeoutIdNode = VAR__namespace.getVariableDeclaratorId(node);
+          if (timeoutIdNode == null) {
+            context.report({
+              messageId: "expectedTimeoutId",
+              node
             });
             break;
           }
-          case "clearTimeout": {
-            const [timeoutIdNode] = node.arguments;
-            if (timeoutIdNode == null) {
-              break;
-            }
-            rEntries.push({
-              kind: "timeout",
-              node,
-              callee: node.callee,
-              phase: fEntry.kind,
-              timerId: timeoutIdNode
-            });
+          sEntries.push({
+            kind: "timeout",
+            node,
+            callee: node.callee,
+            phase: fEntry.kind,
+            timerId: timeoutIdNode
+          });
+          break;
+        }
+        case "clearTimeout": {
+          const [timeoutIdNode] = node.arguments;
+          if (timeoutIdNode == null) {
             break;
           }
+          rEntries.push({
+            kind: "timeout",
+            node,
+            callee: node.callee,
+            phase: fEntry.kind,
+            timerId: timeoutIdNode
+          });
+          break;
         }
-      },
-      ["Program:exit"]() {
-        for (const sEntry of sEntries) {
-          if (rEntries.some((rEntry) => isInverseEntry(sEntry, rEntry))) {
+      }
+    },
+    ["Program:exit"]() {
+      for (const sEntry of sEntries) {
+        if (rEntries.some((rEntry) => isInverseEntry(sEntry, rEntry))) {
+          continue;
+        }
+        switch (sEntry.phase) {
+          case "setup":
+          case "cleanup":
+            context.report({
+              messageId: "expectedClearTimeoutInCleanup",
+              node: sEntry.node,
+              data: {
+                kind: "useEffect"
+              }
+            });
+            continue;
+          case "mount":
+          case "unmount":
+            context.report({
+              messageId: "expectedClearTimeoutInUnmount",
+              node: sEntry.node,
+              data: {
+                kind: "componentDidMount"
+              }
+            });
             continue;
-          }
-          switch (sEntry.phase) {
-            case "setup":
-            case "cleanup":
-              context.report({
-                messageId: "expectedClearTimeoutInCleanup",
-                node: sEntry.node,
-                data: {
-                  kind: "useEffect"
-                }
-              });
-              continue;
-            case "mount":
-            case "unmount":
-              context.report({
-                messageId: "expectedClearTimeoutInUnmount",
-                node: sEntry.node,
-                data: {
-                  kind: "componentDidMount"
-                }
-              });
-              continue;
-          }
         }
       }
-    };
-  },
-  defaultOptions: []
-});
+    }
+  };
+}
 
 // src/plugin.ts
 var plugin = {