eslint-plugin-rxjs-x 0.2.3 → 0.3.0

package/dist/index.mjs

@@ -1,6 +1,6 @@
 // package.json
 var name = "eslint-plugin-rxjs-x";
-var version = "0.2.3";
+var version = "0.3.0";
 
 // src/configs/recommended.ts
 var createRecommendedConfig = (plugin2) => ({
@@ -117,74 +117,7 @@ var banObservablesRule = ruleCreator({
 });
 
 // src/rules/ban-operators.ts
-import { AST_NODE_TYPES as AST_NODE_TYPES2 } from "@typescript-eslint/utils";
 import { stripIndent as stripIndent2 } from "common-tags";
-var defaultOptions2 = [];
-var banOperatorsRule = ruleCreator({
-  defaultOptions: defaultOptions2,
-  meta: {
-    docs: {
-      description: "Disallow banned operators."
-    },
-    messages: {
-      forbidden: "RxJS operator is banned: {{name}}{{explanation}}."
-    },
-    schema: [
-      {
-        type: "object",
-        description: stripIndent2`
-          An object containing keys that are names of operators
-          and values that are either booleans or strings containing the explanation for the ban.`
-      }
-    ],
-    type: "problem"
-  },
-  name: "ban-operators",
-  create: (context) => {
-    const bans = [];
-    const [config] = context.options;
-    if (!config) {
-      return {};
-    }
-    Object.entries(config).forEach(([key, value]) => {
-      if (value !== false) {
-        bans.push({
-          explanation: typeof value === "string" ? value : "",
-          regExp: new RegExp(`^${key}$`)
-        });
-      }
-    });
-    function getFailure(name2) {
-      for (let b = 0, length = bans.length; b < length; ++b) {
-        const ban = bans[b];
-        if (ban.regExp.test(name2)) {
-          const explanation = ban.explanation ? `: ${ban.explanation}` : "";
-          return {
-            messageId: "forbidden",
-            data: { name: name2, explanation }
-          };
-        }
-      }
-      return void 0;
-    }
-    return {
-      [String.raw`ImportDeclaration[source.value=/^rxjs\u002foperators$/] > ImportSpecifier`]: (node) => {
-        const identifier = node.imported;
-        const name2 = identifier.type === AST_NODE_TYPES2.Identifier ? identifier.name : identifier.value;
-        const failure = getFailure(name2);
-        if (failure) {
-          context.report({
-            ...failure,
-            node: identifier
-          });
-        }
-      }
-    };
-  }
-});
-
-// src/rules/finnish.ts
-import { AST_NODE_TYPES as AST_NODE_TYPES5, ESLintUtils as ESLintUtils3 } from "@typescript-eslint/utils";
 
 // src/etc/could-be-function.ts
 import ts2 from "typescript";
@@ -301,55 +234,54 @@ function getLoc(node) {
 
 // src/etc/get-type-services.ts
 import { ESLintUtils as ESLintUtils2 } from "@typescript-eslint/utils";
-import * as tsutils2 from "ts-api-utils";
 import ts4 from "typescript";
 
 // src/etc/is.ts
-import { AST_NODE_TYPES as AST_NODE_TYPES3 } from "@typescript-eslint/utils";
+import { AST_NODE_TYPES as AST_NODE_TYPES2 } from "@typescript-eslint/utils";
 function hasTypeAnnotation(node) {
   return "typeAnnotation" in node && !!node.typeAnnotation;
 }
 function isArrayExpression(node) {
-  return node.type === AST_NODE_TYPES3.ArrayExpression;
+  return node.type === AST_NODE_TYPES2.ArrayExpression;
 }
 function isArrayPattern(node) {
-  return node.type === AST_NODE_TYPES3.ArrayPattern;
+  return node.type === AST_NODE_TYPES2.ArrayPattern;
 }
 function isArrowFunctionExpression(node) {
-  return node.type === AST_NODE_TYPES3.ArrowFunctionExpression;
+  return node.type === AST_NODE_TYPES2.ArrowFunctionExpression;
 }
 function isBlockStatement(node) {
-  return node.type === AST_NODE_TYPES3.BlockStatement;
+  return node.type === AST_NODE_TYPES2.BlockStatement;
 }
 function isCallExpression(node) {
-  return node.type === AST_NODE_TYPES3.CallExpression;
+  return node.type === AST_NODE_TYPES2.CallExpression;
 }
 function isFunctionDeclaration(node) {
-  return node.type === AST_NODE_TYPES3.FunctionDeclaration;
+  return node.type === AST_NODE_TYPES2.FunctionDeclaration;
 }
 function isFunctionExpression(node) {
-  return node.type === AST_NODE_TYPES3.FunctionExpression;
+  return node.type === AST_NODE_TYPES2.FunctionExpression;
 }
 function isIdentifier(node) {
-  return node.type === AST_NODE_TYPES3.Identifier;
+  return node.type === AST_NODE_TYPES2.Identifier;
 }
 function isLiteral(node) {
-  return node.type === AST_NODE_TYPES3.Literal;
+  return node.type === AST_NODE_TYPES2.Literal;
 }
 function isMemberExpression(node) {
-  return node.type === AST_NODE_TYPES3.MemberExpression;
+  return node.type === AST_NODE_TYPES2.MemberExpression;
 }
 function isObjectExpression(node) {
-  return node.type === AST_NODE_TYPES3.ObjectExpression;
+  return node.type === AST_NODE_TYPES2.ObjectExpression;
 }
 function isObjectPattern(node) {
-  return node.type === AST_NODE_TYPES3.ObjectPattern;
+  return node.type === AST_NODE_TYPES2.ObjectPattern;
 }
 function isProgram(node) {
-  return node.type === AST_NODE_TYPES3.Program;
+  return node.type === AST_NODE_TYPES2.Program;
 }
 function isProperty(node) {
-  return node.type === AST_NODE_TYPES3.Property;
+  return node.type === AST_NODE_TYPES2.Property;
 }
 
 // src/etc/get-type-services.ts
@@ -358,7 +290,7 @@ function getTypeServices(context) {
   const { esTreeNodeToTSNodeMap, program, getTypeAtLocation } = services;
   const typeChecker = program.getTypeChecker();
   const couldBeType2 = (node, name2, qualified) => {
-    const type = getType(node);
+    const type = getTypeAtLocation(node);
     return couldBeType(
       type,
       name2,
@@ -382,17 +314,13 @@ function getTypeServices(context) {
       )
     );
   };
-  const getType = (node) => {
-    return getTypeAtLocation(node);
-  };
   return {
     couldBeBehaviorSubject: (node) => couldBeType2(node, "BehaviorSubject"),
-    couldBeError: (node) => couldBeType2(node, "Error"),
     couldBeFunction: (node) => {
       if (isArrowFunctionExpression(node) || isFunctionDeclaration(node)) {
         return true;
       }
-      return couldBeFunction(getType(node));
+      return couldBeFunction(getTypeAtLocation(node));
     },
     couldBeMonoTypeOperatorFunction: (node) => couldBeType2(node, "MonoTypeOperatorFunction"),
     couldBeObservable: (node) => couldBeType2(node, "Observable"),
@@ -400,29 +328,88 @@ function getTypeServices(context) {
     couldBeSubscription: (node) => couldBeType2(node, "Subscription"),
     couldBeType: couldBeType2,
     couldReturnObservable: (node) => couldReturnType(node, "Observable"),
-    couldReturnType,
-    getType,
-    isAny: (node) => tsutils2.isIntrinsicAnyType(getType(node)),
-    isReferenceType: (node) => tsutils2.isTypeReference(getType(node)),
-    isUnknown: (node) => tsutils2.isIntrinsicUnknownType(getType(node)),
-    typeChecker
+    couldReturnType
   };
 }
 
 // src/etc/is-import.ts
 import { DefinitionType } from "@typescript-eslint/scope-manager";
-import { AST_NODE_TYPES as AST_NODE_TYPES4 } from "@typescript-eslint/utils";
+import { AST_NODE_TYPES as AST_NODE_TYPES3 } from "@typescript-eslint/utils";
 function isImport(scope, name2, source) {
   const variable = scope.variables.find((variable2) => variable2.name === name2);
   if (variable) {
     return variable.defs.some(
-      (def) => def.type === DefinitionType.ImportBinding && def.parent.type === AST_NODE_TYPES4.ImportDeclaration && (typeof source === "string" ? def.parent.source.value === source : source.test(def.parent.source.value))
+      (def) => def.type === DefinitionType.ImportBinding && def.parent.type === AST_NODE_TYPES3.ImportDeclaration && (typeof source === "string" ? def.parent.source.value === source : source.test(def.parent.source.value))
     );
   }
   return scope.upper ? isImport(scope.upper, name2, source) : false;
 }
 
+// src/rules/ban-operators.ts
+var defaultOptions2 = [];
+var banOperatorsRule = ruleCreator({
+  defaultOptions: defaultOptions2,
+  meta: {
+    docs: {
+      description: "Disallow banned operators.",
+      requiresTypeChecking: true
+    },
+    messages: {
+      forbidden: "RxJS operator is banned: {{name}}{{explanation}}."
+    },
+    schema: [
+      {
+        type: "object",
+        description: stripIndent2`
+          An object containing keys that are names of operators
+          and values that are either booleans or strings containing the explanation for the ban.`
+      }
+    ],
+    type: "problem"
+  },
+  name: "ban-operators",
+  create: (context) => {
+    const { couldBeType: couldBeType2 } = getTypeServices(context);
+    const bans = [];
+    const [config] = context.options;
+    if (!config) {
+      return {};
+    }
+    Object.entries(config).forEach(([key, value]) => {
+      if (value !== false) {
+        bans.push({
+          name: key,
+          explanation: typeof value === "string" ? value : ""
+        });
+      }
+    });
+    function checkNode(node) {
+      for (const ban of bans) {
+        if (couldBeType2(node, ban.name, { name: /[/\\]rxjs[/\\]/ })) {
+          const explanation = ban.explanation ? `: ${ban.explanation}` : "";
+          context.report({
+            messageId: "forbidden",
+            data: { name: ban.name, explanation },
+            node
+          });
+          return;
+        }
+      }
+    }
+    return {
+      "CallExpression[callee.property.name='pipe'] > CallExpression[callee.name]": (node) => {
+        checkNode(node.callee);
+      },
+      "CallExpression[callee.property.name='pipe'] > CallExpression[callee.type=\"MemberExpression\"]": (node) => {
+        const callee = node.callee;
+        checkNode(callee.property);
+      }
+    };
+  }
+});
+
 // src/rules/finnish.ts
+import { AST_NODE_TYPES as AST_NODE_TYPES4, ESLintUtils as ESLintUtils3 } from "@typescript-eslint/utils";
 var defaultOptions3 = [];
 var finnishRule = ruleCreator({
   defaultOptions: defaultOptions3,
@@ -550,7 +537,7 @@ var finnishRule = ruleCreator({
         if (!found) {
           return;
         }
-        if (!validate.variables && found.type === AST_NODE_TYPES5.VariableDeclarator) {
+        if (!validate.variables && found.type === AST_NODE_TYPES4.VariableDeclarator) {
           return;
         }
         if (!validate.parameters) {
@@ -629,7 +616,7 @@ var finnishRule = ruleCreator({
         if (!found) {
           return;
         }
-        if (!validate.variables && found.type === AST_NODE_TYPES5.VariableDeclarator) {
+        if (!validate.variables && found.type === AST_NODE_TYPES4.VariableDeclarator) {
           return;
         }
         if (!validate.parameters) {
@@ -723,6 +710,7 @@ var justRule = ruleCreator({
 var macroRule = ruleCreator({
   defaultOptions: [],
   meta: {
+    deprecated: true,
     docs: {
       description: "Require the use of the RxJS Tools Babel macro."
     },
@@ -919,6 +907,7 @@ var noCreateRule = ruleCreator({
 });
 
 // src/rules/no-cyclic-action.ts
+import { ESLintUtils as ESLintUtils4 } from "@typescript-eslint/utils";
 import { stripIndent as stripIndent3 } from "common-tags";
 import ts5 from "typescript";
 
@@ -926,7 +915,7 @@ import ts5 from "typescript";
 var defaultObservable = String.raw`[Aa]ction(s|s\$|\$)$`;
 
 // src/rules/no-cyclic-action.ts
-function isTypeReference3(type) {
+function isTypeReference2(type) {
   return Boolean(type.target);
 }
 var defaultOptions4 = [];
@@ -958,7 +947,8 @@ var noCyclicActionRule = ruleCreator({
     const [config = {}] = context.options;
     const { observable = defaultObservable } = config;
     const observableRegExp = new RegExp(observable);
-    const { getType, typeChecker } = getTypeServices(context);
+    const { getTypeAtLocation, program } = ESLintUtils4.getParserServices(context);
+    const typeChecker = program.getTypeChecker();
     function checkNode(pipeCallExpression) {
       const operatorCallExpression = pipeCallExpression.arguments.find(
         (arg) => isCallExpression(arg) && isIdentifier(arg.callee) && arg.callee.name === "ofType"
@@ -966,7 +956,7 @@ var noCyclicActionRule = ruleCreator({
       if (!operatorCallExpression) {
         return;
       }
-      const operatorType = getType(operatorCallExpression);
+      const operatorType = getTypeAtLocation(operatorCallExpression);
       const [signature] = typeChecker.getSignaturesOfType(
         operatorType,
         ts5.SignatureKind.Call
@@ -975,15 +965,15 @@ var noCyclicActionRule = ruleCreator({
         return;
       }
       const operatorReturnType = typeChecker.getReturnTypeOfSignature(signature);
-      if (!isTypeReference3(operatorReturnType)) {
+      if (!isTypeReference2(operatorReturnType)) {
         return;
       }
       const [operatorElementType] = typeChecker.getTypeArguments(operatorReturnType);
       if (!operatorElementType) {
         return;
       }
-      const pipeType = getType(pipeCallExpression);
-      if (!isTypeReference3(pipeType)) {
+      const pipeType = getTypeAtLocation(pipeCallExpression);
+      if (!isTypeReference2(pipeType)) {
         return;
       }
       const [pipeElementType] = typeChecker.getTypeArguments(pipeType);
@@ -1182,7 +1172,7 @@ var noExposedSubjectsRule = ruleCreator({
 });
 
 // src/rules/no-finnish.ts
-import { ESLintUtils as ESLintUtils4 } from "@typescript-eslint/utils";
+import { ESLintUtils as ESLintUtils5 } from "@typescript-eslint/utils";
 var noFinnishRule = ruleCreator({
   defaultOptions: [],
   meta: {
@@ -1198,7 +1188,7 @@ var noFinnishRule = ruleCreator({
   },
   name: "no-finnish",
   create: (context) => {
-    const { esTreeNodeToTSNodeMap } = ESLintUtils4.getParserServices(context);
+    const { esTreeNodeToTSNodeMap } = ESLintUtils5.getParserServices(context);
     const { couldBeObservable, couldReturnObservable } = getTypeServices(context);
     function checkNode(nameNode, typeNode) {
       if (couldBeObservable(typeNode != null ? typeNode : nameNode) || couldReturnObservable(typeNode != null ? typeNode : nameNode)) {
@@ -1277,6 +1267,108 @@ var noFinnishRule = ruleCreator({
   }
 });
 
+// src/rules/no-ignored-default-value.ts
+import { ESLintUtils as ESLintUtils6 } from "@typescript-eslint/utils";
+var noIgnoredDefaultValueRule = ruleCreator({
+  defaultOptions: [],
+  meta: {
+    docs: {
+      description: "Disallow using `firstValueFrom`, `lastValueFrom`, `first`, and `last` without specifying a default value.",
+      requiresTypeChecking: true
+    },
+    messages: {
+      forbidden: "Not specifying a default value is forbidden."
+    },
+    schema: [],
+    type: "problem"
+  },
+  name: "no-ignored-default-value",
+  create: (context) => {
+    const { getTypeAtLocation } = ESLintUtils6.getParserServices(context);
+    const { couldBeObservable, couldBeType: couldBeType2 } = getTypeServices(context);
+    function checkConfigObj(configArg) {
+      if (!configArg.properties.some((p) => isProperty(p) && isIdentifier(p.key) && p.key.name === "defaultValue")) {
+        context.report({
+          messageId: "forbidden",
+          node: configArg
+        });
+      }
+    }
+    function checkConfigType(configArg) {
+      const configArgType = getTypeAtLocation(configArg);
+      if (!(configArgType == null ? void 0 : configArgType.getProperties().some((p) => p.name === "defaultValue"))) {
+        context.report({
+          messageId: "forbidden",
+          node: configArg
+        });
+      }
+    }
+    function checkArg(arg) {
+      if (isIdentifier(arg)) {
+        checkConfigType(arg);
+        return;
+      } else if (isMemberExpression(arg) && isIdentifier(arg.property)) {
+        checkConfigType(arg.property);
+        return;
+      }
+      if (!isObjectExpression(arg)) {
+        return;
+      }
+      checkConfigObj(arg);
+    }
+    function checkFunctionArgs(node, args) {
+      if (!couldBeType2(node, "firstValueFrom", { name: /[/\\]rxjs[/\\]/ }) && !couldBeType2(node, "lastValueFrom", { name: /[/\\]rxjs[/\\]/ })) {
+        return;
+      }
+      if (!args || args.length <= 0) {
+        return;
+      }
+      const [observableArg, configArg] = args;
+      if (!couldBeObservable(observableArg)) {
+        return;
+      }
+      if (!configArg) {
+        context.report({
+          messageId: "forbidden",
+          node
+        });
+        return;
+      }
+      checkArg(configArg);
+    }
+    function checkOperatorArgs(node, args) {
+      if (!couldBeType2(node, "first", { name: /[/\\]rxjs[/\\]/ }) && !couldBeType2(node, "last", { name: /[/\\]rxjs[/\\]/ })) {
+        return;
+      }
+      if (!args || args.length <= 0) {
+        context.report({
+          messageId: "forbidden",
+          node
+        });
+        return;
+      }
+      const [arg] = args;
+      checkArg(arg);
+    }
+    return {
+      "CallExpression[callee.name=/^(firstValueFrom|lastValueFrom)$/]": (node) => {
+        checkFunctionArgs(node.callee, node.arguments);
+      },
+      "CallExpression[callee.property.name=/^(firstValueFrom|lastValueFrom)$/]": (node) => {
+        const memberExpression = node.callee;
+        checkFunctionArgs(memberExpression.property, node.arguments);
+      },
+      "CallExpression[callee.property.name='pipe'] > CallExpression[callee.name=/^(first|last)$/]": (node) => {
+        checkOperatorArgs(node.callee, node.arguments);
+      },
+      "CallExpression[callee.property.name='pipe'] > CallExpression[callee.property.name=/^(first|last)$/]": (node) => {
+        const memberExpression = node.callee;
+        checkOperatorArgs(memberExpression.property, node.arguments);
+      }
+    };
+  }
+});
+
 // src/rules/no-ignored-error.ts
 var noIgnoredErrorRule = ruleCreator({
   defaultOptions: [],
@@ -1412,7 +1504,6 @@ var noIgnoredObservableRule = ruleCreator({
 });
 
 // src/rules/no-ignored-replay-buffer.ts
-import { AST_NODE_TYPES as AST_NODE_TYPES6 } from "@typescript-eslint/utils";
 var noIgnoredReplayBufferRule = ruleCreator({
   defaultOptions: [],
   meta: {
@@ -1429,7 +1520,7 @@ var noIgnoredReplayBufferRule = ruleCreator({
   name: "no-ignored-replay-buffer",
   create: (context) => {
     function checkShareReplayConfig(node, shareReplayConfigArg) {
-      if (!shareReplayConfigArg.properties.some((p) => p.type === AST_NODE_TYPES6.Property && p.key.type === AST_NODE_TYPES6.Identifier && p.key.name === "bufferSize")) {
+      if (!shareReplayConfigArg.properties.some((p) => isProperty(p) && isIdentifier(p.key) && p.key.name === "bufferSize")) {
         context.report({
           messageId: "forbidden",
           node
@@ -1444,8 +1535,8 @@ var noIgnoredReplayBufferRule = ruleCreator({
         });
       }
       if (node.name === "shareReplay" && (args == null ? void 0 : args.length) === 1) {
-        const arg = args[0];
-        if (arg.type === AST_NODE_TYPES6.ObjectExpression) {
+        const [arg] = args;
+        if (isObjectExpression(arg)) {
           checkShareReplayConfig(node, arg);
         }
       }
@@ -1595,7 +1686,7 @@ var noIgnoredTakewhileValueRule = ruleCreator({
 
 // src/rules/no-implicit-any-catch.ts
 import {
-  AST_NODE_TYPES as AST_NODE_TYPES7
+  AST_NODE_TYPES as AST_NODE_TYPES5
 } from "@typescript-eslint/utils";
 function isParenthesised(sourceCode, node) {
   const before = sourceCode.getTokenBefore(node);
@@ -1651,7 +1742,7 @@ var noImplicitAnyCatchRule = ruleCreator({
           const {
             typeAnnotation: { type }
           } = typeAnnotation;
-          if (type === AST_NODE_TYPES7.TSAnyKeyword) {
+          if (type === AST_NODE_TYPES5.TSAnyKeyword) {
             let fix2 = function(fixer) {
               return fixer.replaceText(typeAnnotation, ": unknown");
             };
@@ -1670,7 +1761,7 @@ var noImplicitAnyCatchRule = ruleCreator({
                 }
               ]
             });
-          } else if (type !== AST_NODE_TYPES7.TSUnknownKeyword) {
+          } else if (type !== AST_NODE_TYPES5.TSUnknownKeyword) {
             let fix2 = function(fixer) {
               return fixer.replaceText(typeAnnotation, ": unknown");
             };
@@ -1965,7 +2056,7 @@ function isExpressionObserver(expressionStatement, couldBeType2) {
 }
 
 // src/rules/no-sharereplay.ts
-import { AST_NODE_TYPES as AST_NODE_TYPES8 } from "@typescript-eslint/utils";
+import { AST_NODE_TYPES as AST_NODE_TYPES6 } from "@typescript-eslint/utils";
 var defaultOptions7 = [];
 var noSharereplayRule = ruleCreator({
   defaultOptions: defaultOptions7,
@@ -1996,7 +2087,7 @@ var noSharereplayRule = ruleCreator({
       "CallExpression[callee.name='shareReplay']": (node) => {
         let report = true;
         if (allowConfig) {
-          report = node.arguments.length !== 1 || node.arguments[0].type !== AST_NODE_TYPES8.ObjectExpression;
+          report = node.arguments.length !== 1 || node.arguments[0].type !== AST_NODE_TYPES6.ObjectExpression;
         }
         if (report) {
           context.report({
@@ -2226,6 +2317,7 @@ var noTopromiseRule = ruleCreator({
 });
 
 // src/rules/no-unbound-methods.ts
+import { ESLintUtils as ESLintUtils7 } from "@typescript-eslint/utils";
 var noUnboundMethodsRule = ruleCreator({
   defaultOptions: [],
   meta: {
@@ -2242,11 +2334,12 @@ var noUnboundMethodsRule = ruleCreator({
   },
   name: "no-unbound-methods",
   create: (context) => {
-    const { couldBeObservable, couldBeSubscription, getType } = getTypeServices(context);
+    const { getTypeAtLocation } = ESLintUtils7.getParserServices(context);
+    const { couldBeObservable, couldBeSubscription } = getTypeServices(context);
     const nodeMap = /* @__PURE__ */ new WeakMap();
     function mapArguments(node) {
       node.arguments.filter(isMemberExpression).forEach((arg) => {
-        const argType = getType(arg);
+        const argType = getTypeAtLocation(arg);
         if (argType.getCallSignatures().length > 0) {
           nodeMap.set(arg);
         }
@@ -2419,7 +2512,8 @@ var noUnsafeFirstRule = ruleCreator({
 });
 
 // src/rules/no-unsafe-subject-next.ts
-import * as tsutils3 from "ts-api-utils";
+import { ESLintUtils as ESLintUtils8 } from "@typescript-eslint/utils";
+import * as tsutils2 from "ts-api-utils";
 import ts6 from "typescript";
 var noUnsafeSubjectNext = ruleCreator({
   defaultOptions: [],
@@ -2437,24 +2531,25 @@ var noUnsafeSubjectNext = ruleCreator({
   },
   name: "no-unsafe-subject-next",
   create: (context) => {
-    const { getType, typeChecker } = getTypeServices(context);
+    const { getTypeAtLocation, program } = ESLintUtils8.getParserServices(context);
+    const typeChecker = program.getTypeChecker();
     return {
       [`CallExpression[callee.property.name='next']`]: (node) => {
         if (node.arguments.length === 0 && isMemberExpression(node.callee)) {
-          const type = getType(node.callee.object);
-          if (tsutils3.isTypeReference(type) && couldBeType(type, "Subject")) {
+          const type = getTypeAtLocation(node.callee.object);
+          if (tsutils2.isTypeReference(type) && couldBeType(type, "Subject")) {
             const [typeArg] = typeChecker.getTypeArguments(type);
-            if (tsutils3.isTypeFlagSet(typeArg, ts6.TypeFlags.Any)) {
+            if (tsutils2.isTypeFlagSet(typeArg, ts6.TypeFlags.Any)) {
               return;
             }
-            if (tsutils3.isTypeFlagSet(typeArg, ts6.TypeFlags.Unknown)) {
+            if (tsutils2.isTypeFlagSet(typeArg, ts6.TypeFlags.Unknown)) {
               return;
             }
-            if (tsutils3.isTypeFlagSet(typeArg, ts6.TypeFlags.Void)) {
+            if (tsutils2.isTypeFlagSet(typeArg, ts6.TypeFlags.Void)) {
               return;
             }
-            if (tsutils3.isUnionType(typeArg) && typeArg.types.some(
-              (t) => tsutils3.isTypeFlagSet(t, ts6.TypeFlags.Void)
+            if (tsutils2.isUnionType(typeArg) && typeArg.types.some(
+              (t) => tsutils2.isTypeFlagSet(t, ts6.TypeFlags.Void)
             )) {
               return;
             }
@@ -2800,7 +2895,7 @@ function isValidArgText(argText) {
 }
 
 // src/rules/suffix-subjects.ts
-import { AST_NODE_TYPES as AST_NODE_TYPES9, ESLintUtils as ESLintUtils5 } from "@typescript-eslint/utils";
+import { AST_NODE_TYPES as AST_NODE_TYPES7, ESLintUtils as ESLintUtils9 } from "@typescript-eslint/utils";
 var defaultOptions13 = [];
 var suffixSubjectsRule = ruleCreator({
   defaultOptions: defaultOptions13,
@@ -2828,7 +2923,7 @@ var suffixSubjectsRule = ruleCreator({
   },
   name: "suffix-subjects",
   create: (context) => {
-    const { esTreeNodeToTSNodeMap } = ESLintUtils5.getParserServices(context);
+    const { esTreeNodeToTSNodeMap } = ESLintUtils9.getParserServices(context);
     const { couldBeType: couldBeType2 } = getTypeServices(context);
     const [config = {}] = context.options;
     const validate = {
@@ -2884,7 +2979,7 @@ var suffixSubjectsRule = ruleCreator({
         if (!found) {
           return;
         }
-        if (!validate.variables && found.type === AST_NODE_TYPES9.VariableDeclarator) {
+        if (!validate.variables && found.type === AST_NODE_TYPES7.VariableDeclarator) {
           return;
         }
         if (!validate.parameters) {
@@ -2951,7 +3046,7 @@ var suffixSubjectsRule = ruleCreator({
         if (!found) {
           return;
         }
-        if (!validate.variables && found.type === AST_NODE_TYPES9.VariableDeclarator) {
+        if (!validate.variables && found.type === AST_NODE_TYPES7.VariableDeclarator) {
           return;
         }
         if (!validate.parameters) {
@@ -2998,49 +3093,75 @@ var suffixSubjectsRule = ruleCreator({
 });
 
 // src/rules/throw-error.ts
-import { ESLintUtils as ESLintUtils6 } from "@typescript-eslint/utils";
-import * as tsutils4 from "ts-api-utils";
+import { ESLintUtils as ESLintUtils10 } from "@typescript-eslint/utils";
+import * as tsutils3 from "ts-api-utils";
+var defaultOptions14 = [];
 var throwErrorRule = ruleCreator({
-  defaultOptions: [],
+  defaultOptions: defaultOptions14,
   meta: {
     docs: {
-      description: "Enforce passing only `Error` values to error notifications.",
+      description: "Enforce passing only `Error` values to `throwError`.",
       requiresTypeChecking: true
     },
     messages: {
-      forbidden: "Passing non-Error values are forbidden."
+      forbidden: "Passing non-Error values is forbidden."
     },
-    schema: [],
+    schema: [
+      {
+        properties: {
+          allowThrowingAny: { type: "boolean", default: true, description: "Whether to always allow throwing values typed as `any`." },
+          allowThrowingUnknown: { type: "boolean", default: true, description: "Whether to always allow throwing values typed as `unknown`." }
+        },
+        type: "object"
+      }
+    ],
     type: "problem"
   },
   name: "throw-error",
   create: (context) => {
-    const { esTreeNodeToTSNodeMap, program } = ESLintUtils6.getParserServices(context);
-    const { couldBeObservable, getType } = getTypeServices(context);
-    function checkNode(node) {
-      let type = getType(node);
+    const { esTreeNodeToTSNodeMap, program, getTypeAtLocation } = ESLintUtils10.getParserServices(context);
+    const { couldBeObservable } = getTypeServices(context);
+    const [config = {}] = context.options;
+    const { allowThrowingAny = true, allowThrowingUnknown = true } = config;
+    function checkThrowArgument(node) {
+      var _a;
+      let type = getTypeAtLocation(node);
+      let reportNode = node;
       if (couldBeFunction(type)) {
+        reportNode = (_a = node.body) != null ? _a : node;
         const tsNode = esTreeNodeToTSNodeMap.get(node);
         const annotation = tsNode.type;
         const body = tsNode.body;
         type = program.getTypeChecker().getTypeAtLocation(annotation != null ? annotation : body);
       }
-      if (!tsutils4.isIntrinsicAnyType(type) && !tsutils4.isIntrinsicUnknownType(type) && !couldBeType(type, /^(Error|DOMException)$/)) {
-        context.report({
-          messageId: "forbidden",
-          node
-        });
+      if (allowThrowingAny && tsutils3.isIntrinsicAnyType(type)) {
+        return;
+      }
+      if (allowThrowingUnknown && tsutils3.isIntrinsicUnknownType(type)) {
+        return;
+      }
+      if (couldBeType(type, /^Error$/)) {
+        return;
+      }
+      context.report({
+        messageId: "forbidden",
+        node: reportNode
+      });
+    }
+    function checkNode(node) {
+      if (couldBeObservable(node)) {
+        const [arg] = node.arguments;
+        if (arg) {
+          checkThrowArgument(arg);
+        }
       }
     }
     return {
-      "ThrowStatement > *": checkNode,
       "CallExpression[callee.name='throwError']": (node) => {
-        if (couldBeObservable(node)) {
-          const [arg] = node.arguments;
-          if (arg) {
-            checkNode(arg);
-          }
-        }
+        checkNode(node);
+      },
+      "CallExpression[callee.property.name='throwError']": (node) => {
+        checkNode(node);
       }
     };
   }
@@ -3063,6 +3184,7 @@ var plugin = {
     "no-explicit-generics": noExplicitGenericsRule,
     "no-exposed-subjects": noExposedSubjectsRule,
     "no-finnish": noFinnishRule,
+    "no-ignored-default-value": noIgnoredDefaultValueRule,
     "no-ignored-error": noIgnoredErrorRule,
     "no-ignored-notifier": noIgnoredNotifierRule,
     "no-ignored-observable": noIgnoredObservableRule,