eslint-plugin-rxjs-x 0.8.4 → 0.9.0

package/dist/index.mjs

@@ -1,14 +1,21 @@
 // package.json
 var name = "eslint-plugin-rxjs-x";
-var version = "0.8.4";
+var version = "0.9.0";
 
 // src/configs/recommended.ts
 var createRecommendedConfig = (plugin2) => ({
+  ...baseConfig,
   name: "rxjs-x/recommended",
   plugins: {
     // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-assertion -- "A type annotation is necessary."
     "rxjs-x": plugin2
-  },
+  }
+});
+var createLegacyRecommendedConfig = () => ({
+  ...baseConfig,
+  plugins: ["rxjs-x"]
+});
+var baseConfig = {
   rules: {
     "rxjs-x/no-async-subscribe": "error",
     "rxjs-x/no-create": "error",
@@ -31,7 +38,7 @@ var createRecommendedConfig = (plugin2) => ({
     "rxjs-x/prefer-root-operators": "error",
     "rxjs-x/throw-error": "error"
   }
-});
+};
 
 // src/configs/strict.ts
 var createStrictConfig = (plugin2) => ({
@@ -215,7 +222,7 @@ function getLoc(node) {
 
 // src/etc/get-type-services.ts
 import { ESLintUtils } from "@typescript-eslint/utils";
-import ts4 from "typescript";
+import * as tsutils2 from "ts-api-utils";
 
 // src/etc/is.ts
 import { AST_NODE_TYPES } from "@typescript-eslint/utils";
@@ -301,7 +308,7 @@ function isUnionType(node) {
 // src/etc/get-type-services.ts
 function getTypeServices(context) {
   const services = ESLintUtils.getParserServices(context);
-  const { esTreeNodeToTSNodeMap, program, getTypeAtLocation } = services;
+  const { program, getTypeAtLocation } = services;
   const typeChecker = program.getTypeChecker();
   const couldBeType2 = (node, name2, qualified) => {
     const type = getTypeAtLocation(node);
@@ -312,30 +319,18 @@ function getTypeServices(context) {
     );
   };
   const couldReturnType = (node, name2, qualified) => {
-    let tsTypeNode;
-    const tsNode = esTreeNodeToTSNodeMap.get(node);
-    if (ts4.isArrowFunction(tsNode) || ts4.isFunctionDeclaration(tsNode) || ts4.isMethodDeclaration(tsNode) || ts4.isFunctionExpression(tsNode)) {
-      if (tsNode.type) {
-        tsTypeNode = tsNode.type;
-      } else if (tsNode.body && ts4.isBlock(tsNode.body)) {
-        const returnStatement = tsNode.body.statements.find(ts4.isReturnStatement);
-        if (returnStatement == null ? void 0 : returnStatement.expression) {
-          tsTypeNode = returnStatement.expression;
-        }
-      } else {
-        tsTypeNode = tsNode.body;
-      }
-    } else if (ts4.isCallSignatureDeclaration(tsNode) || ts4.isMethodSignature(tsNode)) {
-      tsTypeNode = tsNode.type;
-    } else if (ts4.isPropertySignature(tsNode)) {
-    }
-    return Boolean(
-      tsTypeNode && couldBeType(
-        typeChecker.getTypeAtLocation(tsTypeNode),
+    const type = getTypeAtLocation(node);
+    for (const signature of tsutils2.getCallSignaturesOfType(type)) {
+      const returnType = signature.getReturnType();
+      if (couldBeType(
+        returnType,
         name2,
         qualified ? { ...qualified, typeChecker } : void 0
-      )
-    );
+      )) {
+        return true;
+      }
+    }
+    return false;
   };
   return {
     couldBeBehaviorSubject: (node) => couldBeType2(node, "BehaviorSubject"),
@@ -682,21 +677,30 @@ var finnishRule = ruleCreator({
         });
       } : () => {
       };
-      if (couldBeObservable(typeNode != null ? typeNode : nameNode) || couldReturnObservable(typeNode != null ? typeNode : nameNode)) {
-        for (const name2 of names) {
-          const { regExp, validate: validate2 } = name2;
-          if (regExp.test(text) && !validate2) {
+      const nameWithoutDollar = text.endsWith("$") ? text.slice(0, -1) : text;
+      for (const name2 of names) {
+        const { regExp, validate: validate2 } = name2;
+        if (regExp.test(text) || regExp.test(nameWithoutDollar)) {
+          if (validate2) {
+            shouldBeFinnish();
+          } else {
             shouldNotBeFinnish();
-            return;
           }
+          return;
         }
-        for (const type of types) {
-          const { regExp, validate: validate2 } = type;
-          if ((couldBeType2(typeNode != null ? typeNode : nameNode, regExp) || couldReturnType(typeNode != null ? typeNode : nameNode, regExp)) && !validate2) {
+      }
+      for (const type of types) {
+        const { regExp, validate: validate2 } = type;
+        if (couldBeType2(typeNode != null ? typeNode : nameNode, regExp) || couldReturnType(typeNode != null ? typeNode : nameNode, regExp)) {
+          if (validate2) {
+            shouldBeFinnish();
+          } else {
             shouldNotBeFinnish();
-            return;
           }
+          return;
         }
+      }
+      if (couldBeObservable(typeNode != null ? typeNode : nameNode) || couldReturnObservable(typeNode != null ? typeNode : nameNode)) {
         shouldBeFinnish();
       } else {
         shouldNotBeFinnish();
@@ -1099,7 +1103,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";
+import ts4 from "typescript";
 function isTypeReference2(type) {
   return Boolean(type.target);
 }
@@ -1144,7 +1148,7 @@ var noCyclicActionRule = ruleCreator({
       const operatorType = getTypeAtLocation(operatorCallExpression);
       const [signature] = typeChecker.getSignaturesOfType(
         operatorType,
-        ts5.SignatureKind.Call
+        ts4.SignatureKind.Call
       );
       if (!signature) {
         return;
@@ -1203,11 +1207,14 @@ var noCyclicActionRule = ruleCreator({
 });
 
 // src/rules/no-explicit-generics.ts
+import { ESLintUtils as ESLintUtils5 } from "@typescript-eslint/utils";
+import * as tsutils3 from "ts-api-utils";
 var noExplicitGenericsRule = ruleCreator({
   defaultOptions: [],
   meta: {
     docs: {
-      description: "Disallow unnecessary explicit generic type arguments."
+      description: "Disallow unnecessary explicit generic type arguments.",
+      requiresTypeChecking: true
     },
     messages: {
       forbidden: "Explicit generic type arguments are forbidden."
@@ -1223,6 +1230,17 @@ var noExplicitGenericsRule = ruleCreator({
         node
       });
     }
+    function isUnion(node) {
+      if (!node) {
+        return false;
+      }
+      if (isUnionType(node)) {
+        return true;
+      }
+      const { getTypeAtLocation } = ESLintUtils5.getParserServices(context);
+      const type = getTypeAtLocation(node);
+      return tsutils3.isUnionOrIntersectionType(type);
+    }
     function checkBehaviorSubjects(node) {
       var _a;
       const parent = node.parent;
@@ -1230,7 +1248,7 @@ var noExplicitGenericsRule = ruleCreator({
         arguments: [value]
       } = parent;
       const typeArgs = (_a = parent.typeArguments) == null ? void 0 : _a.params[0];
-      if (isArrayExpression(value) || isObjectExpression(value) || typeArgs && isUnionType(typeArgs)) {
+      if (isArrayExpression(value) || isObjectExpression(value) || isUnion(typeArgs)) {
         return;
       }
       report(node);
@@ -1242,7 +1260,7 @@ var noExplicitGenericsRule = ruleCreator({
         arguments: [, value]
       } = parent;
       const typeArgs = (_a = parent.typeArguments) == null ? void 0 : _a.params[0];
-      if (isArrayExpression(value) || isObjectExpression(value) || typeArgs && isUnionType(typeArgs)) {
+      if (isArrayExpression(value) || isObjectExpression(value) || isUnion(typeArgs)) {
         return;
       }
       report(node);
@@ -1362,7 +1380,7 @@ var noExposedSubjectsRule = ruleCreator({
 });
 
 // src/rules/no-finnish.ts
-import { ESLintUtils as ESLintUtils5 } from "@typescript-eslint/utils";
+import { ESLintUtils as ESLintUtils6 } from "@typescript-eslint/utils";
 var noFinnishRule = ruleCreator({
   defaultOptions: [],
   meta: {
@@ -1378,7 +1396,7 @@ var noFinnishRule = ruleCreator({
   },
   name: "no-finnish",
   create: (context) => {
-    const { esTreeNodeToTSNodeMap } = ESLintUtils5.getParserServices(context);
+    const { esTreeNodeToTSNodeMap } = ESLintUtils6.getParserServices(context);
     const { couldBeObservable, couldReturnObservable } = getTypeServices(context);
     function checkNode(nameNode, typeNode) {
       if (couldBeObservable(typeNode != null ? typeNode : nameNode) || couldReturnObservable(typeNode != null ? typeNode : nameNode)) {
@@ -1539,7 +1557,7 @@ var noFloatingObservablesRule = ruleCreator({
 });
 
 // src/rules/no-ignored-default-value.ts
-import { ESLintUtils as ESLintUtils6 } from "@typescript-eslint/utils";
+import { ESLintUtils as ESLintUtils7 } from "@typescript-eslint/utils";
 var noIgnoredDefaultValueRule = ruleCreator({
   defaultOptions: [],
   meta: {
@@ -1556,7 +1574,7 @@ var noIgnoredDefaultValueRule = ruleCreator({
   },
   name: "no-ignored-default-value",
   create: (context) => {
-    const { getTypeAtLocation } = ESLintUtils6.getParserServices(context);
+    const { getTypeAtLocation } = ESLintUtils7.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")) {
@@ -1642,7 +1660,7 @@ var noIgnoredDefaultValueRule = ruleCreator({
 });
 
 // src/rules/no-ignored-error.ts
-import { ESLintUtils as ESLintUtils7 } from "@typescript-eslint/utils";
+import { ESLintUtils as ESLintUtils8 } from "@typescript-eslint/utils";
 var noIgnoredErrorRule = ruleCreator({
   defaultOptions: [],
   meta: {
@@ -1659,7 +1677,7 @@ var noIgnoredErrorRule = ruleCreator({
   },
   name: "no-ignored-error",
   create: (context) => {
-    const { getTypeAtLocation } = ESLintUtils7.getParserServices(context);
+    const { getTypeAtLocation } = ESLintUtils8.getParserServices(context);
     const { couldBeObservable, couldBeFunction: couldBeFunction2 } = getTypeServices(context);
     function isMissingErrorCallback(callExpression) {
       if (callExpression.arguments.length >= 2) {
@@ -1779,6 +1797,37 @@ var noIgnoredNotifierRule = ruleCreator({
   }
 });
 
+// src/rules/no-ignored-observable.ts
+var noIgnoredObservableRule = ruleCreator({
+  defaultOptions: [],
+  meta: {
+    deprecated: true,
+    docs: {
+      description: "Disallow ignoring of observables returned by functions."
+    },
+    messages: {
+      forbidden: "Ignoring a returned Observable is forbidden."
+    },
+    replacedBy: ["no-floating-observables"],
+    schema: [],
+    type: "problem"
+  },
+  name: "no-ignored-observable",
+  create: (context) => {
+    const { couldBeObservable } = getTypeServices(context);
+    return {
+      "ExpressionStatement > CallExpression": (node) => {
+        if (couldBeObservable(node)) {
+          context.report({
+            messageId: "forbidden",
+            node
+          });
+        }
+      }
+    };
+  }
+});
+
 // src/rules/no-ignored-replay-buffer.ts
 var noIgnoredReplayBufferRule = ruleCreator({
   defaultOptions: [],
@@ -2023,10 +2072,11 @@ var noImplicitAnyCatchRule = ruleCreator({
     fixable: "code",
     hasSuggestions: true,
     messages: {
-      explicitAny: "Explicit `any` in `catchError`.",
-      implicitAny: "Implicit `any` in `catchError`.",
+      explicitAny: "Explicit `any` in error callback.",
+      implicitAny: "Implicit `any` in error callback.",
       narrowed: "Error type must be `unknown` or `any`.",
-      suggestExplicitUnknown: "Use `unknown` instead, this will force you to explicitly and safely assert the type is correct."
+      suggestExplicitUnknown: "Use `unknown` instead to explicitly and safely assert the type is correct.",
+      suggestExplicitAny: "Use `any` instead to explicitly opt out of type safety."
     },
     schema: [
       {
@@ -2049,6 +2099,22 @@ var noImplicitAnyCatchRule = ruleCreator({
     const { allowExplicitAny = true } = config;
     const { couldBeObservable } = getTypeServices(context);
     const sourceCode = context.sourceCode;
+    function createReplacerFix(typeAnnotation, replaceWith) {
+      return function fix(fixer) {
+        return fixer.replaceText(typeAnnotation, `: ${replaceWith}`);
+      };
+    }
+    function createInserterFix(param, annotateWith, { hasRestParams = false } = {}) {
+      return function fix(fixer) {
+        if (hasRestParams || isParenthesised(sourceCode, param)) {
+          return fixer.insertTextAfter(param, `: ${annotateWith}`);
+        }
+        return [
+          fixer.insertTextBefore(param, "("),
+          fixer.insertTextAfter(param, `: ${annotateWith})`)
+        ];
+      };
+    }
     function checkCallback(callback) {
       if (isArrowFunctionExpression(callback) || isFunctionExpression(callback)) {
         const [param, ...restParams] = callback.params;
@@ -2061,61 +2127,51 @@ var noImplicitAnyCatchRule = ruleCreator({
             typeAnnotation: { type }
           } = typeAnnotation;
           if (type === AST_NODE_TYPES5.TSAnyKeyword) {
-            let fix2 = function(fixer) {
-              return fixer.replaceText(typeAnnotation, ": unknown");
-            };
-            var fix = fix2;
             if (allowExplicitAny) {
               return;
             }
             context.report({
-              fix: fix2,
               messageId: "explicitAny",
               node: param,
               suggest: [
                 {
                   messageId: "suggestExplicitUnknown",
-                  fix: fix2
+                  fix: createReplacerFix(typeAnnotation, "unknown")
                 }
               ]
             });
           } else if (type !== AST_NODE_TYPES5.TSUnknownKeyword) {
-            let fix2 = function(fixer) {
-              return fixer.replaceText(typeAnnotation, ": unknown");
-            };
-            var fix = fix2;
             context.report({
               messageId: "narrowed",
               node: param,
               suggest: [
                 {
                   messageId: "suggestExplicitUnknown",
-                  fix: fix2
-                }
-              ]
+                  fix: createReplacerFix(typeAnnotation, "unknown")
+                },
+                allowExplicitAny ? {
+                  messageId: "suggestExplicitAny",
+                  fix: createReplacerFix(typeAnnotation, "any")
+                } : null
+              ].filter((x) => !!x)
             });
           }
         } else {
-          let fix2 = function(fixer) {
-            if (isParenthesised(sourceCode, param) || restParams.length > 0) {
-              return fixer.insertTextAfter(param, ": unknown");
-            }
-            return [
-              fixer.insertTextBefore(param, "("),
-              fixer.insertTextAfter(param, ": unknown)")
-            ];
-          };
-          var fix = fix2;
+          const hasRestParams = restParams.length > 0;
           context.report({
-            fix: fix2,
+            fix: allowExplicitAny ? createInserterFix(param, "any", { hasRestParams }) : void 0,
             messageId: "implicitAny",
             node: param,
             suggest: [
               {
                 messageId: "suggestExplicitUnknown",
-                fix: fix2
-              }
-            ]
+                fix: createInserterFix(param, "unknown", { hasRestParams })
+              },
+              allowExplicitAny ? {
+                messageId: "suggestExplicitAny",
+                fix: createInserterFix(param, "any", { hasRestParams })
+              } : null
+            ].filter((x) => !!x)
           });
         }
       }
@@ -2253,10 +2309,10 @@ var noInternalRule = ruleCreator({
 });
 
 // src/rules/no-misused-observables.ts
-import { AST_NODE_TYPES as AST_NODE_TYPES6, ESLintUtils as ESLintUtils8 } from "@typescript-eslint/utils";
+import { AST_NODE_TYPES as AST_NODE_TYPES6, ESLintUtils as ESLintUtils9 } from "@typescript-eslint/utils";
 import { getFunctionHeadLocation, isFunction } from "@typescript-eslint/utils/ast-utils";
-import * as tsutils2 from "ts-api-utils";
-import ts6 from "typescript";
+import * as tsutils4 from "ts-api-utils";
+import ts5 from "typescript";
 function parseChecksVoidReturn(checksVoidReturn) {
   var _a, _b, _c, _d, _e, _f;
   switch (checksVoidReturn) {
@@ -2337,7 +2393,7 @@ var noMisusedObservablesRule = ruleCreator({
   },
   name: "no-misused-observables",
   create: (context) => {
-    const { program, esTreeNodeToTSNodeMap, getTypeAtLocation } = ESLintUtils8.getParserServices(context);
+    const { program, esTreeNodeToTSNodeMap, getTypeAtLocation } = ESLintUtils9.getParserServices(context);
     const checker = program.getTypeChecker();
     const { couldBeObservable, couldReturnObservable } = getTypeServices(context);
     const [config = {}] = context.options;
@@ -2552,8 +2608,8 @@ function voidFunctionArguments(checker, tsNode) {
   }
   const voidReturnIndices = /* @__PURE__ */ new Set();
   const type = checker.getTypeAtLocation(tsNode.expression);
-  for (const subType of tsutils2.unionTypeParts(type)) {
-    const signatures = ts6.isCallExpression(tsNode) ? subType.getCallSignatures() : subType.getConstructSignatures();
+  for (const subType of tsutils4.unionConstituents(type)) {
+    const signatures = ts5.isCallExpression(tsNode) ? subType.getCallSignatures() : subType.getConstructSignatures();
     for (const signature of signatures) {
       for (const [index, parameter] of signature.parameters.entries()) {
         const type2 = checker.getTypeOfSymbolAtLocation(parameter, tsNode.expression);
@@ -2567,13 +2623,13 @@ function voidFunctionArguments(checker, tsNode) {
 }
 function isVoidReturningFunctionType(type) {
   let hasVoidReturn = false;
-  for (const subType of tsutils2.unionTypeParts(type)) {
+  for (const subType of tsutils4.unionConstituents(type)) {
     for (const signature of subType.getCallSignatures()) {
       const returnType = signature.getReturnType();
       if (couldBeType(returnType, "Observable")) {
         return false;
       }
-      hasVoidReturn || (hasVoidReturn = tsutils2.isTypeFlagSet(returnType, ts6.TypeFlags.Void));
+      hasVoidReturn || (hasVoidReturn = tsutils4.isTypeFlagSet(returnType, ts5.TypeFlags.Void));
     }
   }
   return hasVoidReturn;
@@ -2584,31 +2640,31 @@ function getHeritageTypes(checker, tsNode) {
 }
 function getMemberIfExists(type, memberName) {
   var _a, _b;
-  const escapedMemberName = ts6.escapeLeadingUnderscores(memberName);
+  const escapedMemberName = ts5.escapeLeadingUnderscores(memberName);
   const symbolMemberMatch = (_b = (_a = type.getSymbol()) == null ? void 0 : _a.members) == null ? void 0 : _b.get(escapedMemberName);
-  return symbolMemberMatch != null ? symbolMemberMatch : tsutils2.getPropertyOfType(type, escapedMemberName);
+  return symbolMemberMatch != null ? symbolMemberMatch : tsutils4.getPropertyOfType(type, escapedMemberName);
 }
 function isStaticMember(node) {
   return (isMethodDefinition(node) || isPropertyDefinition(node) || isAccessorProperty(node)) && node.static;
 }
 function getPropertyContextualType(checker, tsNode) {
-  if (ts6.isPropertyAssignment(tsNode)) {
+  if (ts5.isPropertyAssignment(tsNode)) {
     return checker.getContextualType(tsNode.initializer);
-  } else if (ts6.isShorthandPropertyAssignment(tsNode)) {
+  } else if (ts5.isShorthandPropertyAssignment(tsNode)) {
     return checker.getContextualType(tsNode.name);
-  } else if (ts6.isMethodDeclaration(tsNode)) {
-    if (ts6.isComputedPropertyName(tsNode.name)) {
+  } else if (ts5.isMethodDeclaration(tsNode)) {
+    if (ts5.isComputedPropertyName(tsNode.name)) {
       return;
     }
     const obj = tsNode.parent;
-    if (!ts6.isObjectLiteralExpression(obj)) {
+    if (!ts5.isObjectLiteralExpression(obj)) {
       return;
     }
     const objType = checker.getContextualType(obj);
     if (objType == null) {
       return;
     }
-    const propertySymbol = checker.getPropertyOfType(objType, tsNode.name.text);
+    const propertySymbol = tsutils4.unionConstituents(objType).map((t) => checker.getPropertyOfType(t, tsNode.name.getText())).find((p) => p);
     if (propertySymbol == null) {
       return;
     }
@@ -3071,8 +3127,6 @@ var noSubscribeInPipeRule = ruleCreator({
       recommended: "recommended",
       requiresTypeChecking: true
     },
-    fixable: void 0,
-    hasSuggestions: false,
     messages: {
       forbidden: "Subscribe calls within pipe operators are forbidden."
     },
@@ -3243,7 +3297,7 @@ import { ${functionName} } from ${quote}rxjs${quote};`
 });
 
 // src/rules/no-unbound-methods.ts
-import { ESLintUtils as ESLintUtils9 } from "@typescript-eslint/utils";
+import { ESLintUtils as ESLintUtils10 } from "@typescript-eslint/utils";
 var defaultOptions12 = [];
 var noUnboundMethodsRule = ruleCreator({
   defaultOptions: defaultOptions12,
@@ -3268,7 +3322,7 @@ var noUnboundMethodsRule = ruleCreator({
   },
   name: "no-unbound-methods",
   create: (context) => {
-    const { getTypeAtLocation } = ESLintUtils9.getParserServices(context);
+    const { getTypeAtLocation } = ESLintUtils10.getParserServices(context);
     const { couldBeObservable, couldBeSubscription } = getTypeServices(context);
     const nodeMap = /* @__PURE__ */ new WeakMap();
     const [config = {}] = context.options;
@@ -3539,9 +3593,9 @@ var noUnsafeFirstRule = ruleCreator({
 });
 
 // src/rules/no-unsafe-subject-next.ts
-import { ESLintUtils as ESLintUtils10 } from "@typescript-eslint/utils";
-import * as tsutils3 from "ts-api-utils";
-import ts7 from "typescript";
+import { ESLintUtils as ESLintUtils11 } from "@typescript-eslint/utils";
+import * as tsutils5 from "ts-api-utils";
+import ts6 from "typescript";
 var noUnsafeSubjectNext = ruleCreator({
   defaultOptions: [],
   meta: {
@@ -3558,25 +3612,25 @@ var noUnsafeSubjectNext = ruleCreator({
   },
   name: "no-unsafe-subject-next",
   create: (context) => {
-    const { getTypeAtLocation, program } = ESLintUtils10.getParserServices(context);
+    const { getTypeAtLocation, program } = ESLintUtils11.getParserServices(context);
     const typeChecker = program.getTypeChecker();
     return {
       [`CallExpression[callee.property.name='next']`]: (node) => {
         if (node.arguments.length === 0 && isMemberExpression(node.callee)) {
           const type = getTypeAtLocation(node.callee.object);
-          if (tsutils3.isTypeReference(type) && couldBeType(type, "Subject")) {
+          if (tsutils5.isTypeReference(type) && couldBeType(type, "Subject")) {
             const [typeArg] = typeChecker.getTypeArguments(type);
-            if (tsutils3.isTypeFlagSet(typeArg, ts7.TypeFlags.Any)) {
+            if (tsutils5.isTypeFlagSet(typeArg, ts6.TypeFlags.Any)) {
               return;
             }
-            if (tsutils3.isTypeFlagSet(typeArg, ts7.TypeFlags.Unknown)) {
+            if (tsutils5.isTypeFlagSet(typeArg, ts6.TypeFlags.Unknown)) {
               return;
             }
-            if (tsutils3.isTypeFlagSet(typeArg, ts7.TypeFlags.Void)) {
+            if (tsutils5.isTypeFlagSet(typeArg, ts6.TypeFlags.Void)) {
               return;
             }
-            if (tsutils3.isUnionType(typeArg) && typeArg.types.some(
-              (t) => tsutils3.isTypeFlagSet(t, ts7.TypeFlags.Void)
+            if (tsutils5.isUnionType(typeArg) && typeArg.types.some(
+              (t) => tsutils5.isTypeFlagSet(t, ts6.TypeFlags.Void)
             )) {
               return;
             }
@@ -3794,7 +3848,8 @@ var preferObserverRule = ruleCreator({
     fixable: "code",
     hasSuggestions: true,
     messages: {
-      forbidden: "Passing separate handlers is forbidden; pass an observer instead."
+      forbidden: "Passing separate handlers is forbidden; pass an observer instead.",
+      suggest: "Replace with observer object."
     },
     schema: [
       {
@@ -3845,7 +3900,7 @@ var preferObserverRule = ruleCreator({
           fix,
           suggest: [
             {
-              messageId: "forbidden",
+              messageId: "suggest",
               fix
             }
           ]
@@ -3859,7 +3914,7 @@ var preferObserverRule = ruleCreator({
             fix,
             suggest: [
               {
-                messageId: "forbidden",
+                messageId: "suggest",
                 fix
               }
             ]
@@ -4019,7 +4074,7 @@ var preferRootOperatorsRule = ruleCreator({
 });
 
 // src/rules/suffix-subjects.ts
-import { AST_NODE_TYPES as AST_NODE_TYPES9, ESLintUtils as ESLintUtils11 } from "@typescript-eslint/utils";
+import { AST_NODE_TYPES as AST_NODE_TYPES9, ESLintUtils as ESLintUtils12 } from "@typescript-eslint/utils";
 var defaultOptions18 = [];
 var suffixSubjectsRule = ruleCreator({
   defaultOptions: defaultOptions18,
@@ -4047,7 +4102,7 @@ var suffixSubjectsRule = ruleCreator({
   },
   name: "suffix-subjects",
   create: (context) => {
-    const { esTreeNodeToTSNodeMap } = ESLintUtils11.getParserServices(context);
+    const { esTreeNodeToTSNodeMap } = ESLintUtils12.getParserServices(context);
     const { couldBeType: couldBeType2 } = getTypeServices(context);
     const [config = {}] = context.options;
     const validate = {
@@ -4217,8 +4272,8 @@ var suffixSubjectsRule = ruleCreator({
 });
 
 // src/rules/throw-error.ts
-import { ESLintUtils as ESLintUtils12 } from "@typescript-eslint/utils";
-import * as tsutils4 from "ts-api-utils";
+import { ESLintUtils as ESLintUtils13 } from "@typescript-eslint/utils";
+import * as tsutils6 from "ts-api-utils";
 var defaultOptions19 = [];
 var throwErrorRule = ruleCreator({
   defaultOptions: defaultOptions19,
@@ -4247,7 +4302,7 @@ var throwErrorRule = ruleCreator({
   },
   name: "throw-error",
   create: (context) => {
-    const { esTreeNodeToTSNodeMap, program, getTypeAtLocation } = ESLintUtils12.getParserServices(context);
+    const { esTreeNodeToTSNodeMap, program, getTypeAtLocation } = ESLintUtils13.getParserServices(context);
     const { couldBeObservable, couldBeSubject } = getTypeServices(context);
     const [config = {}] = context.options;
     const { allowThrowingAny = true, allowThrowingUnknown = true } = config;
@@ -4262,10 +4317,10 @@ var throwErrorRule = ruleCreator({
         const body = tsNode.body;
         type = program.getTypeChecker().getTypeAtLocation(annotation != null ? annotation : body);
       }
-      if (allowThrowingAny && tsutils4.isIntrinsicAnyType(type)) {
+      if (allowThrowingAny && tsutils6.isIntrinsicAnyType(type)) {
         return;
       }
-      if (allowThrowingUnknown && tsutils4.isIntrinsicUnknownType(type)) {
+      if (allowThrowingUnknown && tsutils6.isIntrinsicUnknownType(type)) {
         return;
       }
       if (couldBeType(type, /^Error$/)) {
@@ -4319,6 +4374,7 @@ var allRules = {
   "no-ignored-default-value": noIgnoredDefaultValueRule,
   "no-ignored-error": noIgnoredErrorRule,
   "no-ignored-notifier": noIgnoredNotifierRule,
+  "no-ignored-observable": noIgnoredObservableRule,
   "no-ignored-replay-buffer": noIgnoredReplayBufferRule,
   "no-ignored-subscribe": noIgnoredSubscribeRule,
   "no-ignored-subscription": noIgnoredSubscriptionRule,
@@ -4362,8 +4418,9 @@ var plugin = {
 var rxjsX = {
   ...plugin,
   configs: {
-    recommended: createRecommendedConfig(plugin),
-    strict: createStrictConfig(plugin)
+    "recommended": createRecommendedConfig(plugin),
+    "strict": createStrictConfig(plugin),
+    "recommended-legacy": createLegacyRecommendedConfig()
   }
 };
 var index_default = rxjsX;