eslint-plugin-rxjs-x 0.8.5 → 0.9.1

package/dist/index.mjs

@@ -1,14 +1,21 @@
 // package.json
 var name = "eslint-plugin-rxjs-x";
-var version = "0.8.5";
+var version = "0.9.1";
 
 // 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";
@@ -291,17 +298,26 @@ function isPropertyDefinition(node) {
 function isSpreadElement(node) {
   return node.type === AST_NODE_TYPES.SpreadElement;
 }
+function isTSAsExpression(node) {
+  return node.type === AST_NODE_TYPES.TSAsExpression;
+}
+function isTSSatisfiesExpression(node) {
+  return node.type === AST_NODE_TYPES.TSSatisfiesExpression;
+}
 function isUnaryExpression(node) {
   return node.type === AST_NODE_TYPES.UnaryExpression;
 }
 function isUnionType(node) {
   return node.type === AST_NODE_TYPES.TSUnionType;
 }
+function isVariableDeclarator(node) {
+  return node.type === AST_NODE_TYPES.VariableDeclarator;
+}
 
 // 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 +328,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"),
@@ -586,8 +590,9 @@ var banOperatorsRule = ruleCreator({
 });
 
 // src/rules/finnish.ts
-import { AST_NODE_TYPES as AST_NODE_TYPES4, ESLintUtils as ESLintUtils3 } from "@typescript-eslint/utils";
+import { ESLintUtils as ESLintUtils3 } from "@typescript-eslint/utils";
 var defaultOptions3 = [];
+var baseShouldBeFinnish = "Finnish notation should be used here.";
 var finnishRule = ruleCreator({
   defaultOptions: defaultOptions3,
   meta: {
@@ -596,7 +601,8 @@ var finnishRule = ruleCreator({
       requiresTypeChecking: true
     },
     messages: {
-      shouldBeFinnish: "Finnish notation should be used here.",
+      shouldBeFinnish: baseShouldBeFinnish,
+      shouldBeFinnishProperty: `${baseShouldBeFinnish} Add a type annotation, assertion, or 'satisfies' to silence this rule.`,
       shouldNotBeFinnish: "Finnish notation should not be used here."
     },
     schema: [
@@ -606,7 +612,8 @@ var finnishRule = ruleCreator({
           methods: { type: "boolean", description: "Require for methods." },
           names: { type: "object", description: "Enforce for specific names. Keys are a RegExp, values are a boolean." },
           parameters: { type: "boolean", description: "Require for parameters." },
-          properties: { type: "boolean", description: "Require for properties." },
+          properties: { type: "boolean", description: 'Require for properties, except object literal keys (see "objects" option).' },
+          objects: { type: "boolean", description: "Require for object literal keys." },
           strict: { type: "boolean", description: "Disallow Finnish notation for non-Observables." },
           types: { type: "object", description: "Enforce for specific types. Keys are a RegExp, values are a boolean." },
           variables: { type: "boolean", description: "Require for variables." }
@@ -632,6 +639,7 @@ var finnishRule = ruleCreator({
       methods: true,
       parameters: true,
       properties: true,
+      objects: true,
       variables: true,
       ...config
     };
@@ -661,7 +669,7 @@ var finnishRule = ruleCreator({
         validate: false
       });
     }
-    function checkNode(nameNode, typeNode) {
+    function checkNode(nameNode, typeNode, shouldMessage = "shouldBeFinnish") {
       const tsNode = esTreeNodeToTSNodeMap.get(nameNode);
       const text = tsNode.getText();
       const hasFinnish = text.endsWith("$");
@@ -672,7 +680,7 @@ var finnishRule = ruleCreator({
       } : () => {
         context.report({
           loc: getLoc(tsNode),
-          messageId: "shouldBeFinnish"
+          messageId: shouldMessage
         });
       };
       const shouldNotBeFinnish = hasFinnish ? () => {
@@ -682,21 +690,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();
@@ -714,7 +731,7 @@ var finnishRule = ruleCreator({
         if (!found) {
           return;
         }
-        if (!validate.variables && found.type === AST_NODE_TYPES4.VariableDeclarator) {
+        if (!validate.variables && isVariableDeclarator(found)) {
           return;
         }
         if (!validate.parameters) {
@@ -775,12 +792,29 @@ var finnishRule = ruleCreator({
         }
       },
       "ObjectExpression > Property[computed=false] > Identifier": (node) => {
-        if (validate.properties) {
-          const parent = node.parent;
-          if (node === parent.key && !isSourcesObjectAcceptingStaticObservableCreator(parent.parent.parent)) {
-            checkNode(node);
+        if (!validate.objects) {
+          return;
+        }
+        const found = findParent(
+          node,
+          "CallExpression",
+          "VariableDeclarator",
+          "TSSatisfiesExpression",
+          "TSAsExpression"
+        );
+        if (found) {
+          if (isCallExpression(found)) {
+            return;
+          } else if (isVariableDeclarator(found) && !!found.id.typeAnnotation) {
+            return;
+          } else if (isTSAsExpression(found) || isTSSatisfiesExpression(found)) {
+            return;
           }
         }
+        const parent = node.parent;
+        if (node === parent.key) {
+          checkNode(node, void 0, "shouldBeFinnishProperty");
+        }
       },
       "ObjectPattern > Property > Identifier": (node) => {
         const found = findParent(
@@ -793,7 +827,7 @@ var finnishRule = ruleCreator({
         if (!found) {
           return;
         }
-        if (!validate.variables && found.type === AST_NODE_TYPES4.VariableDeclarator) {
+        if (!validate.variables && isVariableDeclarator(found)) {
           return;
         }
         if (!validate.parameters) {
@@ -1099,7 +1133,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 +1178,7 @@ var noCyclicActionRule = ruleCreator({
       const operatorType = getTypeAtLocation(operatorCallExpression);
       const [signature] = typeChecker.getSignaturesOfType(
         operatorType,
-        ts5.SignatureKind.Call
+        ts4.SignatureKind.Call
       );
       if (!signature) {
         return;
@@ -1204,7 +1238,7 @@ var noCyclicActionRule = ruleCreator({
 
 // src/rules/no-explicit-generics.ts
 import { ESLintUtils as ESLintUtils5 } from "@typescript-eslint/utils";
-import * as tsutils2 from "ts-api-utils";
+import * as tsutils3 from "ts-api-utils";
 var noExplicitGenericsRule = ruleCreator({
   defaultOptions: [],
   meta: {
@@ -1235,7 +1269,7 @@ var noExplicitGenericsRule = ruleCreator({
       }
       const { getTypeAtLocation } = ESLintUtils5.getParserServices(context);
       const type = getTypeAtLocation(node);
-      return tsutils2.isUnionOrIntersectionType(type);
+      return tsutils3.isUnionOrIntersectionType(type);
     }
     function checkBehaviorSubjects(node) {
       var _a;
@@ -1793,6 +1827,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: [],
@@ -2013,7 +2078,7 @@ var noIgnoredTakewhileValueRule = ruleCreator({
 
 // src/rules/no-implicit-any-catch.ts
 import {
-  AST_NODE_TYPES as AST_NODE_TYPES5
+  AST_NODE_TYPES as AST_NODE_TYPES4
 } from "@typescript-eslint/utils";
 function isParenthesised(sourceCode, node) {
   const before = sourceCode.getTokenBefore(node);
@@ -2037,10 +2102,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: [
       {
@@ -2063,6 +2129,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;
@@ -2074,62 +2156,52 @@ var noImplicitAnyCatchRule = ruleCreator({
           const {
             typeAnnotation: { type }
           } = typeAnnotation;
-          if (type === AST_NODE_TYPES5.TSAnyKeyword) {
-            let fix2 = function(fixer) {
-              return fixer.replaceText(typeAnnotation, ": unknown");
-            };
-            var fix = fix2;
+          if (type === AST_NODE_TYPES4.TSAnyKeyword) {
             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;
+          } else if (type !== AST_NODE_TYPES4.TSUnknownKeyword) {
             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)
           });
         }
       }
@@ -2267,10 +2339,10 @@ var noInternalRule = ruleCreator({
 });
 
 // src/rules/no-misused-observables.ts
-import { AST_NODE_TYPES as AST_NODE_TYPES6, ESLintUtils as ESLintUtils9 } from "@typescript-eslint/utils";
+import { AST_NODE_TYPES as AST_NODE_TYPES5, ESLintUtils as ESLintUtils9 } from "@typescript-eslint/utils";
 import { getFunctionHeadLocation, isFunction } from "@typescript-eslint/utils/ast-utils";
-import * as tsutils3 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) {
@@ -2566,8 +2638,8 @@ function voidFunctionArguments(checker, tsNode) {
   }
   const voidReturnIndices = /* @__PURE__ */ new Set();
   const type = checker.getTypeAtLocation(tsNode.expression);
-  for (const subType of tsutils3.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);
@@ -2581,13 +2653,13 @@ function voidFunctionArguments(checker, tsNode) {
 }
 function isVoidReturningFunctionType(type) {
   let hasVoidReturn = false;
-  for (const subType of tsutils3.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 = tsutils3.isTypeFlagSet(returnType, ts6.TypeFlags.Void));
+      hasVoidReturn || (hasVoidReturn = tsutils4.isTypeFlagSet(returnType, ts5.TypeFlags.Void));
     }
   }
   return hasVoidReturn;
@@ -2598,31 +2670,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 : tsutils3.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;
     }
@@ -2633,55 +2705,55 @@ function getPropertyContextualType(checker, tsNode) {
 }
 function isPossiblyFunctionType(node) {
   switch (node.typeAnnotation.type) {
-    case AST_NODE_TYPES6.TSConditionalType:
-    case AST_NODE_TYPES6.TSConstructorType:
-    case AST_NODE_TYPES6.TSFunctionType:
-    case AST_NODE_TYPES6.TSImportType:
-    case AST_NODE_TYPES6.TSIndexedAccessType:
-    case AST_NODE_TYPES6.TSInferType:
-    case AST_NODE_TYPES6.TSIntersectionType:
-    case AST_NODE_TYPES6.TSQualifiedName:
-    case AST_NODE_TYPES6.TSThisType:
-    case AST_NODE_TYPES6.TSTypeOperator:
-    case AST_NODE_TYPES6.TSTypeQuery:
-    case AST_NODE_TYPES6.TSTypeReference:
-    case AST_NODE_TYPES6.TSUnionType:
+    case AST_NODE_TYPES5.TSConditionalType:
+    case AST_NODE_TYPES5.TSConstructorType:
+    case AST_NODE_TYPES5.TSFunctionType:
+    case AST_NODE_TYPES5.TSImportType:
+    case AST_NODE_TYPES5.TSIndexedAccessType:
+    case AST_NODE_TYPES5.TSInferType:
+    case AST_NODE_TYPES5.TSIntersectionType:
+    case AST_NODE_TYPES5.TSQualifiedName:
+    case AST_NODE_TYPES5.TSThisType:
+    case AST_NODE_TYPES5.TSTypeOperator:
+    case AST_NODE_TYPES5.TSTypeQuery:
+    case AST_NODE_TYPES5.TSTypeReference:
+    case AST_NODE_TYPES5.TSUnionType:
       return true;
-    case AST_NODE_TYPES6.TSTypeLiteral:
+    case AST_NODE_TYPES5.TSTypeLiteral:
       return node.typeAnnotation.members.some(
-        (member) => member.type === AST_NODE_TYPES6.TSCallSignatureDeclaration || member.type === AST_NODE_TYPES6.TSConstructSignatureDeclaration
+        (member) => member.type === AST_NODE_TYPES5.TSCallSignatureDeclaration || member.type === AST_NODE_TYPES5.TSConstructSignatureDeclaration
       );
-    case AST_NODE_TYPES6.TSAbstractKeyword:
-    case AST_NODE_TYPES6.TSAnyKeyword:
-    case AST_NODE_TYPES6.TSArrayType:
-    case AST_NODE_TYPES6.TSAsyncKeyword:
-    case AST_NODE_TYPES6.TSBigIntKeyword:
-    case AST_NODE_TYPES6.TSBooleanKeyword:
-    case AST_NODE_TYPES6.TSDeclareKeyword:
-    case AST_NODE_TYPES6.TSExportKeyword:
-    case AST_NODE_TYPES6.TSIntrinsicKeyword:
-    case AST_NODE_TYPES6.TSLiteralType:
-    case AST_NODE_TYPES6.TSMappedType:
-    case AST_NODE_TYPES6.TSNamedTupleMember:
-    case AST_NODE_TYPES6.TSNeverKeyword:
-    case AST_NODE_TYPES6.TSNullKeyword:
-    case AST_NODE_TYPES6.TSNumberKeyword:
-    case AST_NODE_TYPES6.TSObjectKeyword:
-    case AST_NODE_TYPES6.TSOptionalType:
-    case AST_NODE_TYPES6.TSPrivateKeyword:
-    case AST_NODE_TYPES6.TSProtectedKeyword:
-    case AST_NODE_TYPES6.TSPublicKeyword:
-    case AST_NODE_TYPES6.TSReadonlyKeyword:
-    case AST_NODE_TYPES6.TSRestType:
-    case AST_NODE_TYPES6.TSStaticKeyword:
-    case AST_NODE_TYPES6.TSStringKeyword:
-    case AST_NODE_TYPES6.TSSymbolKeyword:
-    case AST_NODE_TYPES6.TSTemplateLiteralType:
-    case AST_NODE_TYPES6.TSTupleType:
-    case AST_NODE_TYPES6.TSTypePredicate:
-    case AST_NODE_TYPES6.TSUndefinedKeyword:
-    case AST_NODE_TYPES6.TSUnknownKeyword:
-    case AST_NODE_TYPES6.TSVoidKeyword:
+    case AST_NODE_TYPES5.TSAbstractKeyword:
+    case AST_NODE_TYPES5.TSAnyKeyword:
+    case AST_NODE_TYPES5.TSArrayType:
+    case AST_NODE_TYPES5.TSAsyncKeyword:
+    case AST_NODE_TYPES5.TSBigIntKeyword:
+    case AST_NODE_TYPES5.TSBooleanKeyword:
+    case AST_NODE_TYPES5.TSDeclareKeyword:
+    case AST_NODE_TYPES5.TSExportKeyword:
+    case AST_NODE_TYPES5.TSIntrinsicKeyword:
+    case AST_NODE_TYPES5.TSLiteralType:
+    case AST_NODE_TYPES5.TSMappedType:
+    case AST_NODE_TYPES5.TSNamedTupleMember:
+    case AST_NODE_TYPES5.TSNeverKeyword:
+    case AST_NODE_TYPES5.TSNullKeyword:
+    case AST_NODE_TYPES5.TSNumberKeyword:
+    case AST_NODE_TYPES5.TSObjectKeyword:
+    case AST_NODE_TYPES5.TSOptionalType:
+    case AST_NODE_TYPES5.TSPrivateKeyword:
+    case AST_NODE_TYPES5.TSProtectedKeyword:
+    case AST_NODE_TYPES5.TSPublicKeyword:
+    case AST_NODE_TYPES5.TSReadonlyKeyword:
+    case AST_NODE_TYPES5.TSRestType:
+    case AST_NODE_TYPES5.TSStaticKeyword:
+    case AST_NODE_TYPES5.TSStringKeyword:
+    case AST_NODE_TYPES5.TSSymbolKeyword:
+    case AST_NODE_TYPES5.TSTemplateLiteralType:
+    case AST_NODE_TYPES5.TSTupleType:
+    case AST_NODE_TYPES5.TSTypePredicate:
+    case AST_NODE_TYPES5.TSUndefinedKeyword:
+    case AST_NODE_TYPES5.TSUnknownKeyword:
+    case AST_NODE_TYPES5.TSVoidKeyword:
       return false;
   }
 }
@@ -2808,7 +2880,7 @@ function isExpressionObserver(expressionStatement, couldBeType2) {
 }
 
 // src/rules/no-sharereplay.ts
-import { AST_NODE_TYPES as AST_NODE_TYPES7 } from "@typescript-eslint/utils";
+import { AST_NODE_TYPES as AST_NODE_TYPES6 } from "@typescript-eslint/utils";
 var defaultOptions10 = [];
 var noSharereplayRule = ruleCreator({
   defaultOptions: defaultOptions10,
@@ -2839,7 +2911,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_TYPES7.ObjectExpression;
+          report = node.arguments.length !== 1 || node.arguments[0].type !== AST_NODE_TYPES6.ObjectExpression;
         }
         if (report) {
           context.report({
@@ -3076,7 +3148,7 @@ var noSubscribeHandlersRule = ruleCreator({
 });
 
 // src/rules/no-subscribe-in-pipe.ts
-import { AST_NODE_TYPES as AST_NODE_TYPES8 } from "@typescript-eslint/utils";
+import { AST_NODE_TYPES as AST_NODE_TYPES7 } from "@typescript-eslint/utils";
 var noSubscribeInPipeRule = ruleCreator({
   defaultOptions: [],
   meta: {
@@ -3085,8 +3157,6 @@ var noSubscribeInPipeRule = ruleCreator({
       recommended: "recommended",
       requiresTypeChecking: true
     },
-    fixable: void 0,
-    hasSuggestions: false,
     messages: {
       forbidden: "Subscribe calls within pipe operators are forbidden."
     },
@@ -3099,7 +3169,7 @@ var noSubscribeInPipeRule = ruleCreator({
     function isWithinPipe(node) {
       let parent = node.parent;
       while (parent) {
-        if (parent.type === AST_NODE_TYPES8.CallExpression && parent.callee.type === AST_NODE_TYPES8.MemberExpression && parent.callee.property.type === AST_NODE_TYPES8.Identifier && parent.callee.property.name === "pipe") {
+        if (parent.type === AST_NODE_TYPES7.CallExpression && parent.callee.type === AST_NODE_TYPES7.MemberExpression && parent.callee.property.type === AST_NODE_TYPES7.Identifier && parent.callee.property.name === "pipe") {
           return true;
         }
         parent = parent.parent;
@@ -3554,8 +3624,8 @@ var noUnsafeFirstRule = ruleCreator({
 
 // src/rules/no-unsafe-subject-next.ts
 import { ESLintUtils as ESLintUtils11 } from "@typescript-eslint/utils";
-import * as tsutils4 from "ts-api-utils";
-import ts7 from "typescript";
+import * as tsutils5 from "ts-api-utils";
+import ts6 from "typescript";
 var noUnsafeSubjectNext = ruleCreator({
   defaultOptions: [],
   meta: {
@@ -3578,19 +3648,19 @@ var noUnsafeSubjectNext = ruleCreator({
       [`CallExpression[callee.property.name='next']`]: (node) => {
         if (node.arguments.length === 0 && isMemberExpression(node.callee)) {
           const type = getTypeAtLocation(node.callee.object);
-          if (tsutils4.isTypeReference(type) && couldBeType(type, "Subject")) {
+          if (tsutils5.isTypeReference(type) && couldBeType(type, "Subject")) {
             const [typeArg] = typeChecker.getTypeArguments(type);
-            if (tsutils4.isTypeFlagSet(typeArg, ts7.TypeFlags.Any)) {
+            if (tsutils5.isTypeFlagSet(typeArg, ts6.TypeFlags.Any)) {
               return;
             }
-            if (tsutils4.isTypeFlagSet(typeArg, ts7.TypeFlags.Unknown)) {
+            if (tsutils5.isTypeFlagSet(typeArg, ts6.TypeFlags.Unknown)) {
               return;
             }
-            if (tsutils4.isTypeFlagSet(typeArg, ts7.TypeFlags.Void)) {
+            if (tsutils5.isTypeFlagSet(typeArg, ts6.TypeFlags.Void)) {
               return;
             }
-            if (tsutils4.isUnionType(typeArg) && typeArg.types.some(
-              (t) => tsutils4.isTypeFlagSet(t, ts7.TypeFlags.Void)
+            if (tsutils5.isUnionType(typeArg) && typeArg.types.some(
+              (t) => tsutils5.isTypeFlagSet(t, ts6.TypeFlags.Void)
             )) {
               return;
             }
@@ -4034,7 +4104,7 @@ var preferRootOperatorsRule = ruleCreator({
 });
 
 // src/rules/suffix-subjects.ts
-import { AST_NODE_TYPES as AST_NODE_TYPES9, ESLintUtils as ESLintUtils12 } from "@typescript-eslint/utils";
+import { AST_NODE_TYPES as AST_NODE_TYPES8, ESLintUtils as ESLintUtils12 } from "@typescript-eslint/utils";
 var defaultOptions18 = [];
 var suffixSubjectsRule = ruleCreator({
   defaultOptions: defaultOptions18,
@@ -4118,7 +4188,7 @@ var suffixSubjectsRule = ruleCreator({
         if (!found) {
           return;
         }
-        if (!validate.variables && found.type === AST_NODE_TYPES9.VariableDeclarator) {
+        if (!validate.variables && found.type === AST_NODE_TYPES8.VariableDeclarator) {
           return;
         }
         if (!validate.parameters) {
@@ -4185,7 +4255,7 @@ var suffixSubjectsRule = ruleCreator({
         if (!found) {
           return;
         }
-        if (!validate.variables && found.type === AST_NODE_TYPES9.VariableDeclarator) {
+        if (!validate.variables && found.type === AST_NODE_TYPES8.VariableDeclarator) {
           return;
         }
         if (!validate.parameters) {
@@ -4233,7 +4303,7 @@ var suffixSubjectsRule = ruleCreator({
 
 // src/rules/throw-error.ts
 import { ESLintUtils as ESLintUtils13 } from "@typescript-eslint/utils";
-import * as tsutils5 from "ts-api-utils";
+import * as tsutils6 from "ts-api-utils";
 var defaultOptions19 = [];
 var throwErrorRule = ruleCreator({
   defaultOptions: defaultOptions19,
@@ -4277,10 +4347,10 @@ var throwErrorRule = ruleCreator({
         const body = tsNode.body;
         type = program.getTypeChecker().getTypeAtLocation(annotation != null ? annotation : body);
       }
-      if (allowThrowingAny && tsutils5.isIntrinsicAnyType(type)) {
+      if (allowThrowingAny && tsutils6.isIntrinsicAnyType(type)) {
         return;
       }
-      if (allowThrowingUnknown && tsutils5.isIntrinsicUnknownType(type)) {
+      if (allowThrowingUnknown && tsutils6.isIntrinsicUnknownType(type)) {
         return;
       }
       if (couldBeType(type, /^Error$/)) {
@@ -4334,6 +4404,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,
@@ -4377,8 +4448,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;