eslint-plugin-rxjs-x 0.8.4 → 0.9.0

package/dist/index.js

@@ -1,14 +1,21 @@
 "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.8.4";
+var version = "0.9.0";
 
 // src/configs/recommended.ts
 var createRecommendedConfig = (plugin2) => ({
+  ...baseConfig,
   name: "rxjs-x/recommended",
   plugins: {
     // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-assertion -- "A type annotation is necessary."
     "rxjs-x": plugin2
-  },
+  }
+});
+var createLegacyRecommendedConfig = () => ({
+  ...baseConfig,
+  plugins: ["rxjs-x"]
+});
+var baseConfig = {
   rules: {
     "rxjs-x/no-async-subscribe": "error",
     "rxjs-x/no-create": "error",
@@ -31,7 +38,7 @@ var createRecommendedConfig = (plugin2) => ({
     "rxjs-x/prefer-root-operators": "error",
     "rxjs-x/throw-error": "error"
   }
-});
+};
 
 // src/configs/strict.ts
 var createStrictConfig = (plugin2) => ({
@@ -104,7 +111,7 @@ function escapeRegExp(text) {
 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 tsutils4 = _interopRequireWildcard(_tsapiutils);
+var _tsapiutils = require('ts-api-utils'); var tsutils = _interopRequireWildcard(_tsapiutils); var tsutils2 = _interopRequireWildcard(_tsapiutils); var tsutils3 = _interopRequireWildcard(_tsapiutils); var tsutils4 = _interopRequireWildcard(_tsapiutils); var tsutils5 = _interopRequireWildcard(_tsapiutils); var tsutils6 = _interopRequireWildcard(_tsapiutils);
 
 function couldBeType(type, name2, qualified) {
   if (tsutils.isTypeReference(type)) {
@@ -301,7 +308,7 @@ function isUnionType(node) {
 // src/etc/get-type-services.ts
 function getTypeServices(context) {
   const services = _utils.ESLintUtils.getParserServices(context);
-  const { esTreeNodeToTSNodeMap, program, getTypeAtLocation } = services;
+  const { program, getTypeAtLocation } = services;
   const typeChecker = program.getTypeChecker();
   const couldBeType2 = (node, name2, qualified) => {
     const type = getTypeAtLocation(node);
@@ -312,30 +319,18 @@ function getTypeServices(context) {
     );
   };
   const couldReturnType = (node, name2, qualified) => {
-    let tsTypeNode;
-    const tsNode = esTreeNodeToTSNodeMap.get(node);
-    if (_typescript2.default.isArrowFunction(tsNode) || _typescript2.default.isFunctionDeclaration(tsNode) || _typescript2.default.isMethodDeclaration(tsNode) || _typescript2.default.isFunctionExpression(tsNode)) {
-      if (tsNode.type) {
-        tsTypeNode = tsNode.type;
-      } else if (tsNode.body && _typescript2.default.isBlock(tsNode.body)) {
-        const returnStatement = tsNode.body.statements.find(_typescript2.default.isReturnStatement);
-        if (returnStatement == null ? void 0 : returnStatement.expression) {
-          tsTypeNode = returnStatement.expression;
-        }
-      } else {
-        tsTypeNode = 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(
-        typeChecker.getTypeAtLocation(tsTypeNode),
+    const type = getTypeAtLocation(node);
+    for (const signature of tsutils2.getCallSignaturesOfType(type)) {
+      const returnType = signature.getReturnType();
+      if (couldBeType(
+        returnType,
         name2,
         qualified ? { ...qualified, typeChecker } : void 0
-      )
-    );
+      )) {
+        return true;
+      }
+    }
+    return false;
   };
   return {
     couldBeBehaviorSubject: (node) => couldBeType2(node, "BehaviorSubject"),
@@ -682,21 +677,30 @@ var finnishRule = ruleCreator({
         });
       } : () => {
       };
-      if (couldBeObservable(typeNode != null ? typeNode : nameNode) || couldReturnObservable(typeNode != null ? typeNode : nameNode)) {
-        for (const name2 of names) {
-          const { regExp, validate: validate2 } = name2;
-          if (regExp.test(text) && !validate2) {
+      const nameWithoutDollar = text.endsWith("$") ? text.slice(0, -1) : text;
+      for (const name2 of names) {
+        const { regExp, validate: validate2 } = name2;
+        if (regExp.test(text) || regExp.test(nameWithoutDollar)) {
+          if (validate2) {
+            shouldBeFinnish();
+          } else {
             shouldNotBeFinnish();
-            return;
           }
+          return;
         }
-        for (const type of types) {
-          const { regExp, validate: validate2 } = type;
-          if ((couldBeType2(typeNode != null ? typeNode : nameNode, regExp) || couldReturnType(typeNode != null ? typeNode : nameNode, regExp)) && !validate2) {
+      }
+      for (const type of types) {
+        const { regExp, validate: validate2 } = type;
+        if (couldBeType2(typeNode != null ? typeNode : nameNode, regExp) || couldReturnType(typeNode != null ? typeNode : nameNode, regExp)) {
+          if (validate2) {
+            shouldBeFinnish();
+          } else {
             shouldNotBeFinnish();
-            return;
           }
+          return;
         }
+      }
+      if (couldBeObservable(typeNode != null ? typeNode : nameNode) || couldReturnObservable(typeNode != null ? typeNode : nameNode)) {
         shouldBeFinnish();
       } else {
         shouldNotBeFinnish();
@@ -1203,11 +1207,14 @@ var noCyclicActionRule = ruleCreator({
 });
 
 // src/rules/no-explicit-generics.ts
+
+
 var noExplicitGenericsRule = ruleCreator({
   defaultOptions: [],
   meta: {
     docs: {
-      description: "Disallow unnecessary explicit generic type arguments."
+      description: "Disallow unnecessary explicit generic type arguments.",
+      requiresTypeChecking: true
     },
     messages: {
       forbidden: "Explicit generic type arguments are forbidden."
@@ -1223,6 +1230,17 @@ var noExplicitGenericsRule = ruleCreator({
         node
       });
     }
+    function isUnion(node) {
+      if (!node) {
+        return false;
+      }
+      if (isUnionType(node)) {
+        return true;
+      }
+      const { getTypeAtLocation } = _utils.ESLintUtils.getParserServices(context);
+      const type = getTypeAtLocation(node);
+      return tsutils3.isUnionOrIntersectionType(type);
+    }
     function checkBehaviorSubjects(node) {
       var _a;
       const parent = node.parent;
@@ -1230,7 +1248,7 @@ var noExplicitGenericsRule = ruleCreator({
         arguments: [value]
       } = parent;
       const typeArgs = (_a = parent.typeArguments) == null ? void 0 : _a.params[0];
-      if (isArrayExpression(value) || isObjectExpression(value) || typeArgs && isUnionType(typeArgs)) {
+      if (isArrayExpression(value) || isObjectExpression(value) || isUnion(typeArgs)) {
         return;
       }
       report(node);
@@ -1242,7 +1260,7 @@ var noExplicitGenericsRule = ruleCreator({
         arguments: [, value]
       } = parent;
       const typeArgs = (_a = parent.typeArguments) == null ? void 0 : _a.params[0];
-      if (isArrayExpression(value) || isObjectExpression(value) || typeArgs && isUnionType(typeArgs)) {
+      if (isArrayExpression(value) || isObjectExpression(value) || isUnion(typeArgs)) {
         return;
       }
       report(node);
@@ -1779,6 +1797,37 @@ var noIgnoredNotifierRule = ruleCreator({
   }
 });
 
+// src/rules/no-ignored-observable.ts
+var noIgnoredObservableRule = ruleCreator({
+  defaultOptions: [],
+  meta: {
+    deprecated: true,
+    docs: {
+      description: "Disallow ignoring of observables returned by functions."
+    },
+    messages: {
+      forbidden: "Ignoring a returned Observable is forbidden."
+    },
+    replacedBy: ["no-floating-observables"],
+    schema: [],
+    type: "problem"
+  },
+  name: "no-ignored-observable",
+  create: (context) => {
+    const { couldBeObservable } = getTypeServices(context);
+    return {
+      "ExpressionStatement > CallExpression": (node) => {
+        if (couldBeObservable(node)) {
+          context.report({
+            messageId: "forbidden",
+            node
+          });
+        }
+      }
+    };
+  }
+});
+
 // src/rules/no-ignored-replay-buffer.ts
 var noIgnoredReplayBufferRule = ruleCreator({
   defaultOptions: [],
@@ -2023,10 +2072,11 @@ var noImplicitAnyCatchRule = ruleCreator({
     fixable: "code",
     hasSuggestions: true,
     messages: {
-      explicitAny: "Explicit `any` in `catchError`.",
-      implicitAny: "Implicit `any` in `catchError`.",
+      explicitAny: "Explicit `any` in error callback.",
+      implicitAny: "Implicit `any` in error callback.",
       narrowed: "Error type must be `unknown` or `any`.",
-      suggestExplicitUnknown: "Use `unknown` instead, this will force you to explicitly and safely assert the type is correct."
+      suggestExplicitUnknown: "Use `unknown` instead to explicitly and safely assert the type is correct.",
+      suggestExplicitAny: "Use `any` instead to explicitly opt out of type safety."
     },
     schema: [
       {
@@ -2049,6 +2099,22 @@ var noImplicitAnyCatchRule = ruleCreator({
     const { allowExplicitAny = true } = config;
     const { couldBeObservable } = getTypeServices(context);
     const sourceCode = context.sourceCode;
+    function createReplacerFix(typeAnnotation, replaceWith) {
+      return function fix(fixer) {
+        return fixer.replaceText(typeAnnotation, `: ${replaceWith}`);
+      };
+    }
+    function createInserterFix(param, annotateWith, { hasRestParams = false } = {}) {
+      return function fix(fixer) {
+        if (hasRestParams || isParenthesised(sourceCode, param)) {
+          return fixer.insertTextAfter(param, `: ${annotateWith}`);
+        }
+        return [
+          fixer.insertTextBefore(param, "("),
+          fixer.insertTextAfter(param, `: ${annotateWith})`)
+        ];
+      };
+    }
     function checkCallback(callback) {
       if (isArrowFunctionExpression(callback) || isFunctionExpression(callback)) {
         const [param, ...restParams] = callback.params;
@@ -2061,61 +2127,51 @@ var noImplicitAnyCatchRule = ruleCreator({
             typeAnnotation: { type }
           } = typeAnnotation;
           if (type === _utils.AST_NODE_TYPES.TSAnyKeyword) {
-            let fix2 = function(fixer) {
-              return fixer.replaceText(typeAnnotation, ": unknown");
-            };
-            var fix = fix2;
             if (allowExplicitAny) {
               return;
             }
             context.report({
-              fix: fix2,
               messageId: "explicitAny",
               node: param,
               suggest: [
                 {
                   messageId: "suggestExplicitUnknown",
-                  fix: fix2
+                  fix: createReplacerFix(typeAnnotation, "unknown")
                 }
               ]
             });
           } else if (type !== _utils.AST_NODE_TYPES.TSUnknownKeyword) {
-            let fix2 = function(fixer) {
-              return fixer.replaceText(typeAnnotation, ": unknown");
-            };
-            var fix = fix2;
             context.report({
               messageId: "narrowed",
               node: param,
               suggest: [
                 {
                   messageId: "suggestExplicitUnknown",
-                  fix: fix2
-                }
-              ]
+                  fix: createReplacerFix(typeAnnotation, "unknown")
+                },
+                allowExplicitAny ? {
+                  messageId: "suggestExplicitAny",
+                  fix: createReplacerFix(typeAnnotation, "any")
+                } : null
+              ].filter((x) => !!x)
             });
           }
         } else {
-          let fix2 = function(fixer) {
-            if (isParenthesised(sourceCode, param) || restParams.length > 0) {
-              return fixer.insertTextAfter(param, ": unknown");
-            }
-            return [
-              fixer.insertTextBefore(param, "("),
-              fixer.insertTextAfter(param, ": unknown)")
-            ];
-          };
-          var fix = fix2;
+          const hasRestParams = restParams.length > 0;
           context.report({
-            fix: fix2,
+            fix: allowExplicitAny ? createInserterFix(param, "any", { hasRestParams }) : void 0,
             messageId: "implicitAny",
             node: param,
             suggest: [
               {
                 messageId: "suggestExplicitUnknown",
-                fix: fix2
-              }
-            ]
+                fix: createInserterFix(param, "unknown", { hasRestParams })
+              },
+              allowExplicitAny ? {
+                messageId: "suggestExplicitAny",
+                fix: createInserterFix(param, "any", { hasRestParams })
+              } : null
+            ].filter((x) => !!x)
           });
         }
       }
@@ -2552,7 +2608,7 @@ function voidFunctionArguments(checker, tsNode) {
   }
   const voidReturnIndices = /* @__PURE__ */ new Set();
   const type = checker.getTypeAtLocation(tsNode.expression);
-  for (const subType of tsutils2.unionTypeParts(type)) {
+  for (const subType of tsutils4.unionConstituents(type)) {
     const signatures = _typescript2.default.isCallExpression(tsNode) ? subType.getCallSignatures() : subType.getConstructSignatures();
     for (const signature of signatures) {
       for (const [index, parameter] of signature.parameters.entries()) {
@@ -2567,13 +2623,13 @@ function voidFunctionArguments(checker, tsNode) {
 }
 function isVoidReturningFunctionType(type) {
   let hasVoidReturn = false;
-  for (const subType of tsutils2.unionTypeParts(type)) {
+  for (const subType of tsutils4.unionConstituents(type)) {
     for (const signature of subType.getCallSignatures()) {
       const returnType = signature.getReturnType();
       if (couldBeType(returnType, "Observable")) {
         return false;
       }
-      hasVoidReturn || (hasVoidReturn = tsutils2.isTypeFlagSet(returnType, _typescript2.default.TypeFlags.Void));
+      hasVoidReturn || (hasVoidReturn = tsutils4.isTypeFlagSet(returnType, _typescript2.default.TypeFlags.Void));
     }
   }
   return hasVoidReturn;
@@ -2586,7 +2642,7 @@ 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);
+  return symbolMemberMatch != null ? symbolMemberMatch : tsutils4.getPropertyOfType(type, escapedMemberName);
 }
 function isStaticMember(node) {
   return (isMethodDefinition(node) || isPropertyDefinition(node) || isAccessorProperty(node)) && node.static;
@@ -2608,7 +2664,7 @@ function getPropertyContextualType(checker, tsNode) {
     if (objType == null) {
       return;
     }
-    const propertySymbol = checker.getPropertyOfType(objType, tsNode.name.text);
+    const propertySymbol = tsutils4.unionConstituents(objType).map((t) => checker.getPropertyOfType(t, tsNode.name.getText())).find((p) => p);
     if (propertySymbol == null) {
       return;
     }
@@ -3071,8 +3127,6 @@ var noSubscribeInPipeRule = ruleCreator({
       recommended: "recommended",
       requiresTypeChecking: true
     },
-    fixable: void 0,
-    hasSuggestions: false,
     messages: {
       forbidden: "Subscribe calls within pipe operators are forbidden."
     },
@@ -3564,19 +3618,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 (tsutils3.isTypeReference(type) && couldBeType(type, "Subject")) {
+          if (tsutils5.isTypeReference(type) && couldBeType(type, "Subject")) {
             const [typeArg] = typeChecker.getTypeArguments(type);
-            if (tsutils3.isTypeFlagSet(typeArg, _typescript2.default.TypeFlags.Any)) {
+            if (tsutils5.isTypeFlagSet(typeArg, _typescript2.default.TypeFlags.Any)) {
               return;
             }
-            if (tsutils3.isTypeFlagSet(typeArg, _typescript2.default.TypeFlags.Unknown)) {
+            if (tsutils5.isTypeFlagSet(typeArg, _typescript2.default.TypeFlags.Unknown)) {
               return;
             }
-            if (tsutils3.isTypeFlagSet(typeArg, _typescript2.default.TypeFlags.Void)) {
+            if (tsutils5.isTypeFlagSet(typeArg, _typescript2.default.TypeFlags.Void)) {
               return;
             }
-            if (tsutils3.isUnionType(typeArg) && typeArg.types.some(
-              (t) => tsutils3.isTypeFlagSet(t, _typescript2.default.TypeFlags.Void)
+            if (tsutils5.isUnionType(typeArg) && typeArg.types.some(
+              (t) => tsutils5.isTypeFlagSet(t, _typescript2.default.TypeFlags.Void)
             )) {
               return;
             }
@@ -3794,7 +3848,8 @@ var preferObserverRule = ruleCreator({
     fixable: "code",
     hasSuggestions: true,
     messages: {
-      forbidden: "Passing separate handlers is forbidden; pass an observer instead."
+      forbidden: "Passing separate handlers is forbidden; pass an observer instead.",
+      suggest: "Replace with observer object."
     },
     schema: [
       {
@@ -3845,7 +3900,7 @@ var preferObserverRule = ruleCreator({
           fix,
           suggest: [
             {
-              messageId: "forbidden",
+              messageId: "suggest",
               fix
             }
           ]
@@ -3859,7 +3914,7 @@ var preferObserverRule = ruleCreator({
             fix,
             suggest: [
               {
-                messageId: "forbidden",
+                messageId: "suggest",
                 fix
               }
             ]
@@ -4262,10 +4317,10 @@ var throwErrorRule = ruleCreator({
         const body = tsNode.body;
         type = program.getTypeChecker().getTypeAtLocation(annotation != null ? annotation : body);
       }
-      if (allowThrowingAny && tsutils4.isIntrinsicAnyType(type)) {
+      if (allowThrowingAny && tsutils6.isIntrinsicAnyType(type)) {
         return;
       }
-      if (allowThrowingUnknown && tsutils4.isIntrinsicUnknownType(type)) {
+      if (allowThrowingUnknown && tsutils6.isIntrinsicUnknownType(type)) {
         return;
       }
       if (couldBeType(type, /^Error$/)) {
@@ -4319,6 +4374,7 @@ var allRules = {
   "no-ignored-default-value": noIgnoredDefaultValueRule,
   "no-ignored-error": noIgnoredErrorRule,
   "no-ignored-notifier": noIgnoredNotifierRule,
+  "no-ignored-observable": noIgnoredObservableRule,
   "no-ignored-replay-buffer": noIgnoredReplayBufferRule,
   "no-ignored-subscribe": noIgnoredSubscribeRule,
   "no-ignored-subscription": noIgnoredSubscriptionRule,
@@ -4362,8 +4418,9 @@ var plugin = {
 var rxjsX = {
   ...plugin,
   configs: {
-    recommended: createRecommendedConfig(plugin),
-    strict: createStrictConfig(plugin)
+    "recommended": createRecommendedConfig(plugin),
+    "strict": createStrictConfig(plugin),
+    "recommended-legacy": createLegacyRecommendedConfig()
   }
 };
 var index_default = rxjsX;