eslint-plugin-rxjs-x 0.5.0 → 0.5.1

package/dist/index.mjs

@@ -1,9 +1,10 @@
 // package.json
 var name = "eslint-plugin-rxjs-x";
-var version = "0.5.0";
+var version = "0.5.1";
 
 // src/configs/recommended.ts
 var createRecommendedConfig = (plugin2) => ({
+  name: "rxjs-x/recommended",
   plugins: {
     "rxjs-x": plugin2
   },
@@ -32,6 +33,7 @@ var createRecommendedConfig = (plugin2) => ({
 
 // src/configs/strict.ts
 var createStrictConfig = (plugin2) => ({
+  name: "rxjs-x/strict",
   plugins: {
     "rxjs-x": plugin2
   },
@@ -51,6 +53,7 @@ var createStrictConfig = (plugin2) => ({
     }],
     "rxjs-x/no-index": "error",
     "rxjs-x/no-internal": "error",
+    "rxjs-x/no-misused-observables": "error",
     "rxjs-x/no-nested-subscribe": "error",
     "rxjs-x/no-redundant-notify": "error",
     "rxjs-x/no-sharereplay": "error",
@@ -320,12 +323,18 @@ function isImportNamespaceSpecifier(node) {
 function isImportSpecifier(node) {
   return node.type === AST_NODE_TYPES2.ImportSpecifier;
 }
+function isJSXExpressionContainer(node) {
+  return node.type === AST_NODE_TYPES2.JSXExpressionContainer;
+}
 function isLiteral(node) {
   return node.type === AST_NODE_TYPES2.Literal;
 }
 function isMemberExpression(node) {
   return node.type === AST_NODE_TYPES2.MemberExpression;
 }
+function isMethodDefinition(node) {
+  return node.type === AST_NODE_TYPES2.MethodDefinition;
+}
 function isObjectExpression(node) {
   return node.type === AST_NODE_TYPES2.ObjectExpression;
 }
@@ -338,6 +347,9 @@ function isProgram(node) {
 function isProperty(node) {
   return node.type === AST_NODE_TYPES2.Property;
 }
+function isPropertyDefinition(node) {
+  return node.type === AST_NODE_TYPES2.PropertyDefinition;
+}
 function isUnaryExpression(node) {
   return node.type === AST_NODE_TYPES2.UnaryExpression;
 }
@@ -363,6 +375,7 @@ function getTypeServices(context) {
       tsTypeNode = (_a = tsNode.type) != null ? _a : tsNode.body;
     } else if (ts4.isCallSignatureDeclaration(tsNode) || ts4.isMethodSignature(tsNode)) {
       tsTypeNode = tsNode.type;
+    } else if (ts4.isPropertySignature(tsNode)) {
     }
     return Boolean(
       tsTypeNode && couldBeType(
@@ -2086,6 +2099,403 @@ 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 * as tsutils2 from "ts-api-utils";
+import ts6 from "typescript";
+function parseChecksVoidReturn(checksVoidReturn) {
+  var _a, _b, _c, _d, _e, _f;
+  switch (checksVoidReturn) {
+    case false:
+      return false;
+    case true:
+    case void 0:
+      return {
+        arguments: true,
+        attributes: true,
+        inheritedMethods: true,
+        properties: true,
+        returns: true,
+        variables: true
+      };
+    default:
+      return {
+        arguments: (_a = checksVoidReturn.arguments) != null ? _a : true,
+        attributes: (_b = checksVoidReturn.attributes) != null ? _b : true,
+        inheritedMethods: (_c = checksVoidReturn.inheritedMethods) != null ? _c : true,
+        properties: (_d = checksVoidReturn.properties) != null ? _d : true,
+        returns: (_e = checksVoidReturn.returns) != null ? _e : true,
+        variables: (_f = checksVoidReturn.variables) != null ? _f : true
+      };
+  }
+}
+var defaultOptions8 = [];
+var noMisusedObservablesRule = ruleCreator({
+  defaultOptions: defaultOptions8,
+  meta: {
+    docs: {
+      description: "Disallow Observables in places not designed to handle them.",
+      recommended: "strict",
+      requiresTypeChecking: true
+    },
+    messages: {
+      forbiddenVoidReturnArgument: "Observable returned in function argument where a void return was expected.",
+      forbiddenVoidReturnAttribute: "Observable-returning function provided to attribute where a void return was expected.",
+      forbiddenVoidReturnInheritedMethod: "Observable-returning method provided where a void return was expected by extended/implemented type '{{heritageTypeName}}'.",
+      forbiddenVoidReturnProperty: "Observable-returning function provided to property where a void return was expected.",
+      forbiddenVoidReturnReturnValue: "Observable-returning function provided to return value where a void return was expected.",
+      forbiddenVoidReturnVariable: "Observable-returning function provided to variable where a void return was expected.",
+      forbiddenSpread: "Expected a non-Observable value to be spread into an object."
+    },
+    schema: [
+      {
+        properties: {
+          checksVoidReturn: {
+            default: true,
+            description: "Disallow returning an Observable from a function typed as returning `void`.",
+            oneOf: [
+              {
+                default: true,
+                type: "boolean",
+                description: "Disallow returning an Observable from all types of functions typed as returning `void`."
+              },
+              {
+                type: "object",
+                additionalProperties: false,
+                description: "Which forms of functions may have checking disabled.",
+                properties: {
+                  arguments: { type: "boolean", description: "Disallow passing an Observable-returning function as an argument where the parameter type expects a function that returns `void`." },
+                  attributes: { type: "boolean", description: "Disallow passing an Observable-returning function as a JSX attribute expected to be a function that returns `void`." },
+                  inheritedMethods: { type: "boolean", description: "Disallow providing an Observable-returning function where a function that returns `void` is expected by an extended or implemented type." },
+                  properties: { type: "boolean", description: "Disallow providing an Observable-returning function where a function that returns `void` is expected by a property." },
+                  returns: { type: "boolean", description: "Disallow returning an Observable-returning function where a function that returns `void` is expected." },
+                  variables: { type: "boolean", description: "Disallow assigning or declaring an Observable-returning function where a function that returns `void` is expected." }
+                }
+              }
+            ]
+          },
+          checksSpreads: { type: "boolean", default: true, description: "Disallow `...` spreading an Observable." }
+        },
+        type: "object"
+      }
+    ],
+    type: "problem"
+  },
+  name: "no-misused-observables",
+  create: (context) => {
+    const { program, esTreeNodeToTSNodeMap, getTypeAtLocation } = ESLintUtils8.getParserServices(context);
+    const checker = program.getTypeChecker();
+    const { couldBeObservable, couldReturnObservable } = getTypeServices(context);
+    const [config = {}] = context.options;
+    const { checksVoidReturn = true, checksSpreads = true } = config;
+    const parsedChecksVoidReturn = parseChecksVoidReturn(checksVoidReturn);
+    const voidReturnChecks = parsedChecksVoidReturn ? {
+      ...parsedChecksVoidReturn.arguments && {
+        CallExpression: checkArguments,
+        NewExpression: checkArguments
+      },
+      ...parsedChecksVoidReturn.attributes && {
+        JSXAttribute: checkJSXAttribute
+      },
+      ...parsedChecksVoidReturn.inheritedMethods && {
+        ClassDeclaration: checkClassLikeOrInterfaceNode,
+        ClassExpression: checkClassLikeOrInterfaceNode,
+        TSInterfaceDeclaration: checkClassLikeOrInterfaceNode
+      },
+      ...parsedChecksVoidReturn.properties && {
+        Property: checkProperty
+      },
+      ...parsedChecksVoidReturn.returns && {
+        ReturnStatement: checkReturnStatement
+      },
+      ...parsedChecksVoidReturn.variables && {
+        AssignmentExpression: checkAssignment,
+        VariableDeclarator: checkVariableDeclaration
+      }
+    } : {};
+    const spreadChecks = {
+      SpreadElement: (node) => {
+        if (couldBeObservable(node.argument)) {
+          context.report({
+            messageId: "forbiddenSpread",
+            node: node.argument
+          });
+        }
+      }
+    };
+    function checkArguments(node) {
+      const tsNode = esTreeNodeToTSNodeMap.get(node);
+      const voidArgs = voidFunctionArguments(checker, tsNode);
+      if (!voidArgs.size) {
+        return;
+      }
+      for (const [index, argument] of node.arguments.entries()) {
+        if (!voidArgs.has(index)) {
+          continue;
+        }
+        if (couldReturnObservable(argument)) {
+          context.report({
+            messageId: "forbiddenVoidReturnArgument",
+            node: argument
+          });
+        }
+      }
+    }
+    function checkJSXAttribute(node) {
+      if (!node.value || !isJSXExpressionContainer(node.value)) {
+        return;
+      }
+      if (couldReturnObservable(node.value.expression)) {
+        context.report({
+          messageId: "forbiddenVoidReturnAttribute",
+          node: node.value
+        });
+      }
+    }
+    function checkClassLikeOrInterfaceNode(node) {
+      var _a;
+      const tsNode = esTreeNodeToTSNodeMap.get(node);
+      const heritageTypes = getHeritageTypes(checker, tsNode);
+      if (!(heritageTypes == null ? void 0 : heritageTypes.length)) {
+        return;
+      }
+      for (const element of node.body.body) {
+        const tsElement = esTreeNodeToTSNodeMap.get(element);
+        const memberName = (_a = tsElement == null ? void 0 : tsElement.name) == null ? void 0 : _a.getText();
+        if (memberName === void 0) {
+          continue;
+        }
+        if (!couldReturnObservable(element)) {
+          continue;
+        }
+        if (isStaticMember(element)) {
+          continue;
+        }
+        for (const heritageType of heritageTypes) {
+          const heritageMember = getMemberIfExists(heritageType, memberName);
+          if (heritageMember === void 0) {
+            continue;
+          }
+          const memberType = checker.getTypeOfSymbolAtLocation(heritageMember, tsElement);
+          if (!isVoidReturningFunctionType(memberType)) {
+            continue;
+          }
+          context.report({
+            messageId: "forbiddenVoidReturnInheritedMethod",
+            node: element,
+            data: { heritageTypeName: checker.typeToString(heritageType) }
+          });
+        }
+      }
+    }
+    function checkProperty(node) {
+      const tsNode = esTreeNodeToTSNodeMap.get(node);
+      const contextualType = getPropertyContextualType(checker, tsNode);
+      if (contextualType === void 0) {
+        return;
+      }
+      if (!isVoidReturningFunctionType(contextualType)) {
+        return;
+      }
+      if (!couldReturnObservable(node.value)) {
+        return;
+      }
+      context.report({
+        messageId: "forbiddenVoidReturnProperty",
+        node: node.value
+      });
+    }
+    function checkReturnStatement(node) {
+      const tsNode = esTreeNodeToTSNodeMap.get(node);
+      if (tsNode.expression === void 0 || !node.argument) {
+        return;
+      }
+      function getFunctionNode() {
+        let current = node.parent;
+        while (current && !isArrowFunctionExpression(current) && !isFunctionExpression(current) && !isFunctionDeclaration(current)) {
+          current = current.parent;
+        }
+        return current;
+      }
+      const functionNode = getFunctionNode();
+      if ((functionNode == null ? void 0 : functionNode.returnType) && !isPossiblyFunctionType(functionNode.returnType)) {
+        return;
+      }
+      const contextualType = checker.getContextualType(tsNode.expression);
+      if (contextualType === void 0) {
+        return;
+      }
+      if (!isVoidReturningFunctionType(contextualType)) {
+        return;
+      }
+      if (!couldReturnObservable(node.argument)) {
+        return;
+      }
+      context.report({
+        node: node.argument,
+        messageId: "forbiddenVoidReturnReturnValue"
+      });
+    }
+    function checkAssignment(node) {
+      const varType = getTypeAtLocation(node.left);
+      if (!isVoidReturningFunctionType(varType)) {
+        return;
+      }
+      if (couldReturnObservable(node.right)) {
+        context.report({
+          messageId: "forbiddenVoidReturnVariable",
+          node: node.right
+        });
+      }
+    }
+    function checkVariableDeclaration(node) {
+      const tsNode = esTreeNodeToTSNodeMap.get(node);
+      if (tsNode.initializer === void 0 || !node.init || !node.id.typeAnnotation) {
+        return;
+      }
+      if (!isPossiblyFunctionType(node.id.typeAnnotation)) {
+        return;
+      }
+      const varType = getTypeAtLocation(node.id);
+      if (!isVoidReturningFunctionType(varType)) {
+        return;
+      }
+      if (couldReturnObservable(node.init)) {
+        context.report({
+          messageId: "forbiddenVoidReturnVariable",
+          node: node.init
+        });
+      }
+    }
+    return {
+      ...checksVoidReturn ? voidReturnChecks : {},
+      ...checksSpreads ? spreadChecks : {}
+    };
+  }
+});
+function voidFunctionArguments(checker, tsNode) {
+  if (!tsNode.arguments) {
+    return /* @__PURE__ */ new Set();
+  }
+  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 signature of signatures) {
+      for (const [index, parameter] of signature.parameters.entries()) {
+        const type2 = checker.getTypeOfSymbolAtLocation(parameter, tsNode.expression);
+        if (isVoidReturningFunctionType(type2)) {
+          voidReturnIndices.add(index);
+        }
+      }
+    }
+  }
+  return voidReturnIndices;
+}
+function isVoidReturningFunctionType(type) {
+  let hasVoidReturn = false;
+  for (const subType of tsutils2.unionTypeParts(type)) {
+    for (const signature of subType.getCallSignatures()) {
+      const returnType = signature.getReturnType();
+      hasVoidReturn || (hasVoidReturn = tsutils2.isTypeFlagSet(returnType, ts6.TypeFlags.Void));
+    }
+  }
+  return hasVoidReturn;
+}
+function getHeritageTypes(checker, tsNode) {
+  var _a;
+  return (_a = tsNode.heritageClauses) == null ? void 0 : _a.flatMap((clause) => clause.types).map((typeExpressions) => checker.getTypeAtLocation(typeExpressions));
+}
+function getMemberIfExists(type, memberName) {
+  var _a, _b;
+  const escapedMemberName = ts6.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);
+}
+function isStaticMember(node) {
+  return (isMethodDefinition(node) || isPropertyDefinition(node)) && node.static;
+}
+function getPropertyContextualType(checker, tsNode) {
+  if (ts6.isPropertyAssignment(tsNode)) {
+    return checker.getContextualType(tsNode.initializer);
+  } else if (ts6.isShorthandPropertyAssignment(tsNode)) {
+    return checker.getContextualType(tsNode.name);
+  } else if (ts6.isMethodDeclaration(tsNode)) {
+    if (ts6.isComputedPropertyName(tsNode.name)) {
+      return;
+    }
+    const obj = tsNode.parent;
+    if (!ts6.isObjectLiteralExpression(obj)) {
+      return;
+    }
+    const objType = checker.getContextualType(obj);
+    if (objType === void 0) {
+      return;
+    }
+    const propertySymbol = checker.getPropertyOfType(objType, tsNode.name.text);
+    if (propertySymbol === void 0) {
+      return;
+    }
+    return checker.getTypeOfSymbolAtLocation(propertySymbol, tsNode.name);
+  } else {
+    return void 0;
+  }
+}
+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:
+      return true;
+    case AST_NODE_TYPES6.TSTypeLiteral:
+      return node.typeAnnotation.members.some(
+        (member) => member.type === AST_NODE_TYPES6.TSCallSignatureDeclaration || member.type === AST_NODE_TYPES6.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:
+      return false;
+  }
+}
+
 // src/rules/no-nested-subscribe.ts
 var noNestedSubscribeRule = ruleCreator({
   defaultOptions: [],
@@ -2208,10 +2618,10 @@ function isExpressionObserver(expressionStatement, couldBeType2) {
 }
 
 // src/rules/no-sharereplay.ts
-import { AST_NODE_TYPES as AST_NODE_TYPES6 } from "@typescript-eslint/utils";
-var defaultOptions8 = [];
+import { AST_NODE_TYPES as AST_NODE_TYPES7 } from "@typescript-eslint/utils";
+var defaultOptions9 = [];
 var noSharereplayRule = ruleCreator({
-  defaultOptions: defaultOptions8,
+  defaultOptions: defaultOptions9,
   meta: {
     docs: {
       description: "Disallow unsafe `shareReplay` usage.",
@@ -2239,7 +2649,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_TYPES6.ObjectExpression;
+          report = node.arguments.length !== 1 || node.arguments[0].type !== AST_NODE_TYPES7.ObjectExpression;
         }
         if (report) {
           context.report({
@@ -2534,7 +2944,7 @@ import { ${functionName} } from ${quote}rxjs${quote};`
 });
 
 // src/rules/no-unbound-methods.ts
-import { ESLintUtils as ESLintUtils8 } from "@typescript-eslint/utils";
+import { ESLintUtils as ESLintUtils9 } from "@typescript-eslint/utils";
 var noUnboundMethodsRule = ruleCreator({
   defaultOptions: [],
   meta: {
@@ -2551,7 +2961,7 @@ var noUnboundMethodsRule = ruleCreator({
   },
   name: "no-unbound-methods",
   create: (context) => {
-    const { getTypeAtLocation } = ESLintUtils8.getParserServices(context);
+    const { getTypeAtLocation } = ESLintUtils9.getParserServices(context);
     const { couldBeObservable, couldBeSubscription } = getTypeServices(context);
     const nodeMap = /* @__PURE__ */ new WeakMap();
     function mapArguments(node) {
@@ -2599,9 +3009,9 @@ var noUnboundMethodsRule = ruleCreator({
 
 // src/rules/no-unsafe-catch.ts
 import { stripIndent as stripIndent4 } from "common-tags";
-var defaultOptions9 = [];
+var defaultOptions10 = [];
 var noUnsafeCatchRule = ruleCreator({
-  defaultOptions: defaultOptions9,
+  defaultOptions: defaultOptions10,
   meta: {
     docs: {
       description: "Disallow unsafe `catchError` usage in effects and epics.",
@@ -2660,9 +3070,9 @@ var noUnsafeCatchRule = ruleCreator({
 
 // src/rules/no-unsafe-first.ts
 import { stripIndent as stripIndent5 } from "common-tags";
-var defaultOptions10 = [];
+var defaultOptions11 = [];
 var noUnsafeFirstRule = ruleCreator({
-  defaultOptions: defaultOptions10,
+  defaultOptions: defaultOptions11,
   meta: {
     docs: {
       description: "Disallow unsafe `first`/`take` usage in effects and epics.",
@@ -2729,9 +3139,9 @@ var noUnsafeFirstRule = ruleCreator({
 });
 
 // src/rules/no-unsafe-subject-next.ts
-import { ESLintUtils as ESLintUtils9 } from "@typescript-eslint/utils";
-import * as tsutils2 from "ts-api-utils";
-import ts6 from "typescript";
+import { ESLintUtils as ESLintUtils10 } from "@typescript-eslint/utils";
+import * as tsutils3 from "ts-api-utils";
+import ts7 from "typescript";
 var noUnsafeSubjectNext = ruleCreator({
   defaultOptions: [],
   meta: {
@@ -2748,25 +3158,25 @@ var noUnsafeSubjectNext = ruleCreator({
   },
   name: "no-unsafe-subject-next",
   create: (context) => {
-    const { getTypeAtLocation, program } = ESLintUtils9.getParserServices(context);
+    const { getTypeAtLocation, program } = ESLintUtils10.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 (tsutils2.isTypeReference(type) && couldBeType(type, "Subject")) {
+          if (tsutils3.isTypeReference(type) && couldBeType(type, "Subject")) {
             const [typeArg] = typeChecker.getTypeArguments(type);
-            if (tsutils2.isTypeFlagSet(typeArg, ts6.TypeFlags.Any)) {
+            if (tsutils3.isTypeFlagSet(typeArg, ts7.TypeFlags.Any)) {
               return;
             }
-            if (tsutils2.isTypeFlagSet(typeArg, ts6.TypeFlags.Unknown)) {
+            if (tsutils3.isTypeFlagSet(typeArg, ts7.TypeFlags.Unknown)) {
               return;
             }
-            if (tsutils2.isTypeFlagSet(typeArg, ts6.TypeFlags.Void)) {
+            if (tsutils3.isTypeFlagSet(typeArg, ts7.TypeFlags.Void)) {
               return;
             }
-            if (tsutils2.isUnionType(typeArg) && typeArg.types.some(
-              (t) => tsutils2.isTypeFlagSet(t, ts6.TypeFlags.Void)
+            if (tsutils3.isUnionType(typeArg) && typeArg.types.some(
+              (t) => tsutils3.isTypeFlagSet(t, ts7.TypeFlags.Void)
             )) {
               return;
             }
@@ -2784,9 +3194,9 @@ var noUnsafeSubjectNext = ruleCreator({
 // src/rules/no-unsafe-switchmap.ts
 import { stripIndent as stripIndent6 } from "common-tags";
 import decamelize from "decamelize";
-var defaultOptions11 = [];
+var defaultOptions12 = [];
 var noUnsafeSwitchmapRule = ruleCreator({
-  defaultOptions: defaultOptions11,
+  defaultOptions: defaultOptions12,
   meta: {
     docs: {
       description: "Disallow unsafe `switchMap` usage in effects and epics.",
@@ -2909,7 +3319,7 @@ var noUnsafeSwitchmapRule = ruleCreator({
 
 // src/rules/no-unsafe-takeuntil.ts
 import { stripIndent as stripIndent7 } from "common-tags";
-var defaultOptions12 = [];
+var defaultOptions13 = [];
 var allowedOperators = [
   "count",
   "defaultIfEmpty",
@@ -2934,7 +3344,7 @@ var allowedOperators = [
   "toArray"
 ];
 var noUnsafeTakeuntilRule = ruleCreator({
-  defaultOptions: defaultOptions12,
+  defaultOptions: defaultOptions13,
   meta: {
     docs: {
       description: "Disallow applying operators after `takeUntil`.",
@@ -3013,9 +3423,9 @@ var noUnsafeTakeuntilRule = ruleCreator({
 });
 
 // src/rules/prefer-observer.ts
-var defaultOptions13 = [];
+var defaultOptions14 = [];
 var preferObserverRule = ruleCreator({
-  defaultOptions: defaultOptions13,
+  defaultOptions: defaultOptions14,
   meta: {
     docs: {
       description: "Disallow passing separate handlers to `subscribe` and `tap`.",
@@ -3250,10 +3660,10 @@ var preferRootOperatorsRule = ruleCreator({
 });
 
 // src/rules/suffix-subjects.ts
-import { AST_NODE_TYPES as AST_NODE_TYPES7, ESLintUtils as ESLintUtils10 } from "@typescript-eslint/utils";
-var defaultOptions14 = [];
+import { AST_NODE_TYPES as AST_NODE_TYPES8, ESLintUtils as ESLintUtils11 } from "@typescript-eslint/utils";
+var defaultOptions15 = [];
 var suffixSubjectsRule = ruleCreator({
-  defaultOptions: defaultOptions14,
+  defaultOptions: defaultOptions15,
   meta: {
     docs: {
       description: "Enforce the use of a suffix in subject identifiers.",
@@ -3278,7 +3688,7 @@ var suffixSubjectsRule = ruleCreator({
   },
   name: "suffix-subjects",
   create: (context) => {
-    const { esTreeNodeToTSNodeMap } = ESLintUtils10.getParserServices(context);
+    const { esTreeNodeToTSNodeMap } = ESLintUtils11.getParserServices(context);
     const { couldBeType: couldBeType2 } = getTypeServices(context);
     const [config = {}] = context.options;
     const validate = {
@@ -3334,7 +3744,7 @@ var suffixSubjectsRule = ruleCreator({
         if (!found) {
           return;
         }
-        if (!validate.variables && found.type === AST_NODE_TYPES7.VariableDeclarator) {
+        if (!validate.variables && found.type === AST_NODE_TYPES8.VariableDeclarator) {
           return;
         }
         if (!validate.parameters) {
@@ -3401,7 +3811,7 @@ var suffixSubjectsRule = ruleCreator({
         if (!found) {
           return;
         }
-        if (!validate.variables && found.type === AST_NODE_TYPES7.VariableDeclarator) {
+        if (!validate.variables && found.type === AST_NODE_TYPES8.VariableDeclarator) {
           return;
         }
         if (!validate.parameters) {
@@ -3448,11 +3858,11 @@ var suffixSubjectsRule = ruleCreator({
 });
 
 // src/rules/throw-error.ts
-import { ESLintUtils as ESLintUtils11 } from "@typescript-eslint/utils";
-import * as tsutils3 from "ts-api-utils";
-var defaultOptions15 = [];
+import { ESLintUtils as ESLintUtils12 } from "@typescript-eslint/utils";
+import * as tsutils4 from "ts-api-utils";
+var defaultOptions16 = [];
 var throwErrorRule = ruleCreator({
-  defaultOptions: defaultOptions15,
+  defaultOptions: defaultOptions16,
   meta: {
     docs: {
       description: "Enforce passing only `Error` values to `throwError`.",
@@ -3478,7 +3888,7 @@ var throwErrorRule = ruleCreator({
   },
   name: "throw-error",
   create: (context) => {
-    const { esTreeNodeToTSNodeMap, program, getTypeAtLocation } = ESLintUtils11.getParserServices(context);
+    const { esTreeNodeToTSNodeMap, program, getTypeAtLocation } = ESLintUtils12.getParserServices(context);
     const { couldBeObservable } = getTypeServices(context);
     const [config = {}] = context.options;
     const { allowThrowingAny = true, allowThrowingUnknown = true } = config;
@@ -3493,10 +3903,10 @@ var throwErrorRule = ruleCreator({
         const body = tsNode.body;
         type = program.getTypeChecker().getTypeAtLocation(annotation != null ? annotation : body);
       }
-      if (allowThrowingAny && tsutils3.isIntrinsicAnyType(type)) {
+      if (allowThrowingAny && tsutils4.isIntrinsicAnyType(type)) {
         return;
       }
-      if (allowThrowingUnknown && tsutils3.isIntrinsicUnknownType(type)) {
+      if (allowThrowingUnknown && tsutils4.isIntrinsicUnknownType(type)) {
         return;
       }
       if (couldBeType(type, /^Error$/)) {
@@ -3554,6 +3964,7 @@ var plugin = {
     "no-implicit-any-catch": noImplicitAnyCatchRule,
     "no-index": noIndexRule,
     "no-internal": noInternalRule,
+    "no-misused-observables": noMisusedObservablesRule,
     "no-nested-subscribe": noNestedSubscribeRule,
     "no-redundant-notify": noRedundantNotifyRule,
     "no-sharereplay": noSharereplayRule,