eslint-plugin-rxjs-x 0.4.1 → 0.5.1

package/dist/index.js

@@ -1,9 +1,10 @@
 "use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { newObj[key] = obj[key]; } } } newObj.default = obj; return newObj; } } function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }// package.json
 var name = "eslint-plugin-rxjs-x";
-var version = "0.4.1";
+var version = "0.5.1";
 
 // src/configs/recommended.ts
 var createRecommendedConfig = (plugin2) => ({
+  name: "rxjs-x/recommended",
   plugins: {
     "rxjs-x": plugin2
   },
@@ -20,14 +21,19 @@ var createRecommendedConfig = (plugin2) => ({
     "rxjs-x/no-redundant-notify": "error",
     "rxjs-x/no-sharereplay": "error",
     "rxjs-x/no-subject-unsubscribe": "error",
+    "rxjs-x/no-topromise": "error",
     "rxjs-x/no-unbound-methods": "error",
     "rxjs-x/no-unsafe-subject-next": "error",
-    "rxjs-x/no-unsafe-takeuntil": "error"
+    "rxjs-x/no-unsafe-takeuntil": "error",
+    "rxjs-x/prefer-observer": "error",
+    "rxjs-x/prefer-root-operators": "error",
+    "rxjs-x/throw-error": "error"
   }
 });
 
 // src/configs/strict.ts
 var createStrictConfig = (plugin2) => ({
+  name: "rxjs-x/strict",
   plugins: {
     "rxjs-x": plugin2
   },
@@ -36,10 +42,10 @@ var createStrictConfig = (plugin2) => ({
     "rxjs-x/no-create": "error",
     "rxjs-x/no-explicit-generics": "error",
     "rxjs-x/no-exposed-subjects": "error",
+    "rxjs-x/no-floating-observables": "error",
     "rxjs-x/no-ignored-default-value": "error",
     "rxjs-x/no-ignored-error": "error",
     "rxjs-x/no-ignored-notifier": "error",
-    "rxjs-x/no-ignored-observable": "error",
     "rxjs-x/no-ignored-replay-buffer": "error",
     "rxjs-x/no-ignored-takewhile-value": "error",
     "rxjs-x/no-implicit-any-catch": ["error", {
@@ -47,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",
@@ -162,7 +169,7 @@ var banObservablesRule = ruleCreator({
 var _typescript = require('typescript'); var _typescript2 = _interopRequireDefault(_typescript);
 
 // src/etc/could-be-type.ts
-var _tsapiutils = require('ts-api-utils'); var tsutils = _interopRequireWildcard(_tsapiutils); var tsutils2 = _interopRequireWildcard(_tsapiutils); var tsutils3 = _interopRequireWildcard(_tsapiutils);
+var _tsapiutils = require('ts-api-utils'); var tsutils = _interopRequireWildcard(_tsapiutils); var tsutils2 = _interopRequireWildcard(_tsapiutils); var tsutils3 = _interopRequireWildcard(_tsapiutils); var tsutils4 = _interopRequireWildcard(_tsapiutils);
 
 function couldBeType(type, name2, qualified) {
   if (tsutils.isTypeReference(type)) {
@@ -295,6 +302,9 @@ function isBlockStatement(node) {
 function isCallExpression(node) {
   return node.type === _utils.AST_NODE_TYPES.CallExpression;
 }
+function isChainExpression(node) {
+  return node.type === _utils.AST_NODE_TYPES.ChainExpression;
+}
 function isFunctionDeclaration(node) {
   return node.type === _utils.AST_NODE_TYPES.FunctionDeclaration;
 }
@@ -313,12 +323,18 @@ function isImportNamespaceSpecifier(node) {
 function isImportSpecifier(node) {
   return node.type === _utils.AST_NODE_TYPES.ImportSpecifier;
 }
+function isJSXExpressionContainer(node) {
+  return node.type === _utils.AST_NODE_TYPES.JSXExpressionContainer;
+}
 function isLiteral(node) {
   return node.type === _utils.AST_NODE_TYPES.Literal;
 }
 function isMemberExpression(node) {
   return node.type === _utils.AST_NODE_TYPES.MemberExpression;
 }
+function isMethodDefinition(node) {
+  return node.type === _utils.AST_NODE_TYPES.MethodDefinition;
+}
 function isObjectExpression(node) {
   return node.type === _utils.AST_NODE_TYPES.ObjectExpression;
 }
@@ -331,6 +347,12 @@ function isProgram(node) {
 function isProperty(node) {
   return node.type === _utils.AST_NODE_TYPES.Property;
 }
+function isPropertyDefinition(node) {
+  return node.type === _utils.AST_NODE_TYPES.PropertyDefinition;
+}
+function isUnaryExpression(node) {
+  return node.type === _utils.AST_NODE_TYPES.UnaryExpression;
+}
 
 // src/etc/get-type-services.ts
 function getTypeServices(context) {
@@ -353,6 +375,7 @@ function getTypeServices(context) {
       tsTypeNode = (_a = tsNode.type) != null ? _a : tsNode.body;
     } else if (_typescript2.default.isCallSignatureDeclaration(tsNode) || _typescript2.default.isMethodSignature(tsNode)) {
       tsTypeNode = tsNode.type;
+    } else if (_typescript2.default.isPropertySignature(tsNode)) {
     }
     return Boolean(
       tsTypeNode && couldBeType(
@@ -1318,6 +1341,87 @@ var noFinnishRule = ruleCreator({
   }
 });
 
+// src/rules/no-floating-observables.ts
+var defaultOptions6 = [];
+var messageBase = "Observables must be subscribed to, returned, converted to a promise and awaited, or be explicitly marked as ignored with the `void` operator.";
+var messageBaseNoVoid = "Observables must be subscribed to, returned, or converted to a promise and awaited.";
+var noFloatingObservablesRule = ruleCreator({
+  defaultOptions: defaultOptions6,
+  meta: {
+    docs: {
+      description: "Require Observables to be handled appropriately.",
+      recommended: "strict",
+      requiresTypeChecking: true
+    },
+    messages: {
+      forbidden: messageBase,
+      forbiddenNoVoid: messageBaseNoVoid
+    },
+    schema: [
+      {
+        properties: {
+          ignoreVoid: { type: "boolean", default: true, description: "Whether to ignore `void` expressions." }
+        },
+        type: "object"
+      }
+    ],
+    type: "problem"
+  },
+  name: "no-floating-observables",
+  create: (context) => {
+    const { couldBeObservable } = getTypeServices(context);
+    const [config = {}] = context.options;
+    const { ignoreVoid = true } = config;
+    function checkNode(node) {
+      if (couldBeObservable(node)) {
+        context.report({
+          messageId: ignoreVoid ? "forbidden" : "forbiddenNoVoid",
+          node
+        });
+      }
+    }
+    function checkVoid(node) {
+      if (ignoreVoid) return;
+      if (node.operator !== "void") return;
+      let expression = node.argument;
+      if (isChainExpression(expression)) {
+        expression = expression.expression;
+      }
+      if (!isCallExpression(expression)) return;
+      checkNode(expression);
+    }
+    return {
+      "ExpressionStatement > CallExpression": (node) => {
+        checkNode(node);
+      },
+      "ExpressionStatement > UnaryExpression": (node) => {
+        checkVoid(node);
+      },
+      "ExpressionStatement > ChainExpression": (node) => {
+        if (!isCallExpression(node.expression)) return;
+        checkNode(node.expression);
+      },
+      "ExpressionStatement > SequenceExpression": (node) => {
+        node.expressions.forEach((expression) => {
+          if (isCallExpression(expression)) {
+            checkNode(expression);
+          }
+        });
+      },
+      "ExpressionStatement > ArrayExpression": (node) => {
+        node.elements.forEach((expression) => {
+          if (!expression) return;
+          if (isCallExpression(expression)) {
+            checkNode(expression);
+          } else if (isUnaryExpression(expression)) {
+            checkVoid(expression);
+          }
+        });
+      }
+    };
+  }
+});
+
 // src/rules/no-ignored-default-value.ts
 
 var noIgnoredDefaultValueRule = ruleCreator({
@@ -1559,37 +1663,6 @@ var noIgnoredNotifierRule = ruleCreator({
   }
 });
 
-// src/rules/no-ignored-observable.ts
-var noIgnoredObservableRule = ruleCreator({
-  defaultOptions: [],
-  meta: {
-    docs: {
-      description: "Disallow ignoring observables returned by functions.",
-      recommended: "strict",
-      requiresTypeChecking: true
-    },
-    messages: {
-      forbidden: "Ignoring a returned Observable is forbidden."
-    },
-    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: [],
@@ -1780,9 +1853,9 @@ function isParenthesised(sourceCode, node) {
   const after = sourceCode.getTokenAfter(node);
   return before && after && before.value === "(" && before.range[1] <= node.range[0] && after.value === ")" && after.range[0] >= node.range[1];
 }
-var defaultOptions6 = [];
+var defaultOptions7 = [];
 var noImplicitAnyCatchRule = ruleCreator({
-  defaultOptions: defaultOptions6,
+  defaultOptions: defaultOptions7,
   meta: {
     docs: {
       description: "Disallow implicit `any` error parameters in `catchError` operators.",
@@ -2026,6 +2099,403 @@ var noInternalRule = ruleCreator({
   }
 });
 
+// src/rules/no-misused-observables.ts
+
+
+
+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 } = _utils.ESLintUtils.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 = _typescript2.default.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, _typescript2.default.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 = _typescript2.default.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 (_typescript2.default.isPropertyAssignment(tsNode)) {
+    return checker.getContextualType(tsNode.initializer);
+  } else if (_typescript2.default.isShorthandPropertyAssignment(tsNode)) {
+    return checker.getContextualType(tsNode.name);
+  } else if (_typescript2.default.isMethodDeclaration(tsNode)) {
+    if (_typescript2.default.isComputedPropertyName(tsNode.name)) {
+      return;
+    }
+    const obj = tsNode.parent;
+    if (!_typescript2.default.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 _utils.AST_NODE_TYPES.TSConditionalType:
+    case _utils.AST_NODE_TYPES.TSConstructorType:
+    case _utils.AST_NODE_TYPES.TSFunctionType:
+    case _utils.AST_NODE_TYPES.TSImportType:
+    case _utils.AST_NODE_TYPES.TSIndexedAccessType:
+    case _utils.AST_NODE_TYPES.TSInferType:
+    case _utils.AST_NODE_TYPES.TSIntersectionType:
+    case _utils.AST_NODE_TYPES.TSQualifiedName:
+    case _utils.AST_NODE_TYPES.TSThisType:
+    case _utils.AST_NODE_TYPES.TSTypeOperator:
+    case _utils.AST_NODE_TYPES.TSTypeQuery:
+    case _utils.AST_NODE_TYPES.TSTypeReference:
+    case _utils.AST_NODE_TYPES.TSUnionType:
+      return true;
+    case _utils.AST_NODE_TYPES.TSTypeLiteral:
+      return node.typeAnnotation.members.some(
+        (member) => member.type === _utils.AST_NODE_TYPES.TSCallSignatureDeclaration || member.type === _utils.AST_NODE_TYPES.TSConstructSignatureDeclaration
+      );
+    case _utils.AST_NODE_TYPES.TSAbstractKeyword:
+    case _utils.AST_NODE_TYPES.TSAnyKeyword:
+    case _utils.AST_NODE_TYPES.TSArrayType:
+    case _utils.AST_NODE_TYPES.TSAsyncKeyword:
+    case _utils.AST_NODE_TYPES.TSBigIntKeyword:
+    case _utils.AST_NODE_TYPES.TSBooleanKeyword:
+    case _utils.AST_NODE_TYPES.TSDeclareKeyword:
+    case _utils.AST_NODE_TYPES.TSExportKeyword:
+    case _utils.AST_NODE_TYPES.TSIntrinsicKeyword:
+    case _utils.AST_NODE_TYPES.TSLiteralType:
+    case _utils.AST_NODE_TYPES.TSMappedType:
+    case _utils.AST_NODE_TYPES.TSNamedTupleMember:
+    case _utils.AST_NODE_TYPES.TSNeverKeyword:
+    case _utils.AST_NODE_TYPES.TSNullKeyword:
+    case _utils.AST_NODE_TYPES.TSNumberKeyword:
+    case _utils.AST_NODE_TYPES.TSObjectKeyword:
+    case _utils.AST_NODE_TYPES.TSOptionalType:
+    case _utils.AST_NODE_TYPES.TSPrivateKeyword:
+    case _utils.AST_NODE_TYPES.TSProtectedKeyword:
+    case _utils.AST_NODE_TYPES.TSPublicKeyword:
+    case _utils.AST_NODE_TYPES.TSReadonlyKeyword:
+    case _utils.AST_NODE_TYPES.TSRestType:
+    case _utils.AST_NODE_TYPES.TSStaticKeyword:
+    case _utils.AST_NODE_TYPES.TSStringKeyword:
+    case _utils.AST_NODE_TYPES.TSSymbolKeyword:
+    case _utils.AST_NODE_TYPES.TSTemplateLiteralType:
+    case _utils.AST_NODE_TYPES.TSTupleType:
+    case _utils.AST_NODE_TYPES.TSTypePredicate:
+    case _utils.AST_NODE_TYPES.TSUndefinedKeyword:
+    case _utils.AST_NODE_TYPES.TSUnknownKeyword:
+    case _utils.AST_NODE_TYPES.TSVoidKeyword:
+      return false;
+  }
+}
+
 // src/rules/no-nested-subscribe.ts
 var noNestedSubscribeRule = ruleCreator({
   defaultOptions: [],
@@ -2149,9 +2619,9 @@ function isExpressionObserver(expressionStatement, couldBeType2) {
 
 // src/rules/no-sharereplay.ts
 
-var defaultOptions7 = [];
+var defaultOptions9 = [];
 var noSharereplayRule = ruleCreator({
-  defaultOptions: defaultOptions7,
+  defaultOptions: defaultOptions9,
   meta: {
     docs: {
       description: "Disallow unsafe `shareReplay` usage.",
@@ -2385,7 +2855,7 @@ var noTopromiseRule = ruleCreator({
   meta: {
     docs: {
       description: "Disallow use of the `toPromise` method.",
-      recommended: "strict",
+      recommended: "recommended",
       requiresTypeChecking: true
     },
     hasSuggestions: true,
@@ -2539,9 +3009,9 @@ var noUnboundMethodsRule = ruleCreator({
 
 // src/rules/no-unsafe-catch.ts
 
-var defaultOptions8 = [];
+var defaultOptions10 = [];
 var noUnsafeCatchRule = ruleCreator({
-  defaultOptions: defaultOptions8,
+  defaultOptions: defaultOptions10,
   meta: {
     docs: {
       description: "Disallow unsafe `catchError` usage in effects and epics.",
@@ -2600,9 +3070,9 @@ var noUnsafeCatchRule = ruleCreator({
 
 // src/rules/no-unsafe-first.ts
 
-var defaultOptions9 = [];
+var defaultOptions11 = [];
 var noUnsafeFirstRule = ruleCreator({
-  defaultOptions: defaultOptions9,
+  defaultOptions: defaultOptions11,
   meta: {
     docs: {
       description: "Disallow unsafe `first`/`take` usage in effects and epics.",
@@ -2694,19 +3164,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 (tsutils2.isTypeReference(type) && couldBeType(type, "Subject")) {
+          if (tsutils3.isTypeReference(type) && couldBeType(type, "Subject")) {
             const [typeArg] = typeChecker.getTypeArguments(type);
-            if (tsutils2.isTypeFlagSet(typeArg, _typescript2.default.TypeFlags.Any)) {
+            if (tsutils3.isTypeFlagSet(typeArg, _typescript2.default.TypeFlags.Any)) {
               return;
             }
-            if (tsutils2.isTypeFlagSet(typeArg, _typescript2.default.TypeFlags.Unknown)) {
+            if (tsutils3.isTypeFlagSet(typeArg, _typescript2.default.TypeFlags.Unknown)) {
               return;
             }
-            if (tsutils2.isTypeFlagSet(typeArg, _typescript2.default.TypeFlags.Void)) {
+            if (tsutils3.isTypeFlagSet(typeArg, _typescript2.default.TypeFlags.Void)) {
               return;
             }
-            if (tsutils2.isUnionType(typeArg) && typeArg.types.some(
-              (t) => tsutils2.isTypeFlagSet(t, _typescript2.default.TypeFlags.Void)
+            if (tsutils3.isUnionType(typeArg) && typeArg.types.some(
+              (t) => tsutils3.isTypeFlagSet(t, _typescript2.default.TypeFlags.Void)
             )) {
               return;
             }
@@ -2724,9 +3194,9 @@ var noUnsafeSubjectNext = ruleCreator({
 // src/rules/no-unsafe-switchmap.ts
 
 var _decamelize = require('decamelize'); var _decamelize2 = _interopRequireDefault(_decamelize);
-var defaultOptions10 = [];
+var defaultOptions12 = [];
 var noUnsafeSwitchmapRule = ruleCreator({
-  defaultOptions: defaultOptions10,
+  defaultOptions: defaultOptions12,
   meta: {
     docs: {
       description: "Disallow unsafe `switchMap` usage in effects and epics.",
@@ -2849,7 +3319,7 @@ var noUnsafeSwitchmapRule = ruleCreator({
 
 // src/rules/no-unsafe-takeuntil.ts
 
-var defaultOptions11 = [];
+var defaultOptions13 = [];
 var allowedOperators = [
   "count",
   "defaultIfEmpty",
@@ -2874,7 +3344,7 @@ var allowedOperators = [
   "toArray"
 ];
 var noUnsafeTakeuntilRule = ruleCreator({
-  defaultOptions: defaultOptions11,
+  defaultOptions: defaultOptions13,
   meta: {
     docs: {
       description: "Disallow applying operators after `takeUntil`.",
@@ -2953,13 +3423,13 @@ var noUnsafeTakeuntilRule = ruleCreator({
 });
 
 // src/rules/prefer-observer.ts
-var defaultOptions12 = [];
+var defaultOptions14 = [];
 var preferObserverRule = ruleCreator({
-  defaultOptions: defaultOptions12,
+  defaultOptions: defaultOptions14,
   meta: {
     docs: {
       description: "Disallow passing separate handlers to `subscribe` and `tap`.",
-      recommended: "strict",
+      recommended: "recommended",
       requiresTypeChecking: true
     },
     fixable: "code",
@@ -3069,7 +3539,7 @@ var preferRootOperatorsRule = ruleCreator({
   meta: {
     docs: {
       description: "Disallow importing operators from `rxjs/operators`.",
-      recommended: "strict"
+      recommended: "recommended"
     },
     fixable: "code",
     hasSuggestions: true,
@@ -3191,9 +3661,9 @@ var preferRootOperatorsRule = ruleCreator({
 
 // src/rules/suffix-subjects.ts
 
-var defaultOptions13 = [];
+var defaultOptions15 = [];
 var suffixSubjectsRule = ruleCreator({
-  defaultOptions: defaultOptions13,
+  defaultOptions: defaultOptions15,
   meta: {
     docs: {
       description: "Enforce the use of a suffix in subject identifiers.",
@@ -3390,13 +3860,14 @@ var suffixSubjectsRule = ruleCreator({
 // src/rules/throw-error.ts
 
 
-var defaultOptions14 = [];
+var defaultOptions16 = [];
 var throwErrorRule = ruleCreator({
-  defaultOptions: defaultOptions14,
+  defaultOptions: defaultOptions16,
   meta: {
     docs: {
       description: "Enforce passing only `Error` values to `throwError`.",
       recommended: {
+        recommended: true,
         strict: [{ allowThrowingAny: false, allowThrowingUnknown: false }]
       },
       requiresTypeChecking: true
@@ -3432,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$/)) {
@@ -3482,10 +3953,10 @@ var plugin = {
     "no-explicit-generics": noExplicitGenericsRule,
     "no-exposed-subjects": noExposedSubjectsRule,
     "no-finnish": noFinnishRule,
+    "no-floating-observables": noFloatingObservablesRule,
     "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,
@@ -3493,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,