eslint-plugin-rxjs-x 0.8.5 → 0.9.1

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.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) => ({
@@ -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 tsutils5 = _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)) {
@@ -291,17 +298,26 @@ function isPropertyDefinition(node) {
 function isSpreadElement(node) {
   return node.type === _utils.AST_NODE_TYPES.SpreadElement;
 }
+function isTSAsExpression(node) {
+  return node.type === _utils.AST_NODE_TYPES.TSAsExpression;
+}
+function isTSSatisfiesExpression(node) {
+  return node.type === _utils.AST_NODE_TYPES.TSSatisfiesExpression;
+}
 function isUnaryExpression(node) {
   return node.type === _utils.AST_NODE_TYPES.UnaryExpression;
 }
 function isUnionType(node) {
   return node.type === _utils.AST_NODE_TYPES.TSUnionType;
 }
+function isVariableDeclarator(node) {
+  return node.type === _utils.AST_NODE_TYPES.VariableDeclarator;
+}
 
 // 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 +328,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"),
@@ -588,6 +592,7 @@ var banOperatorsRule = ruleCreator({
 // src/rules/finnish.ts
 
 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 === _utils.AST_NODE_TYPES.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 === _utils.AST_NODE_TYPES.VariableDeclarator) {
+        if (!validate.variables && isVariableDeclarator(found)) {
           return;
         }
         if (!validate.parameters) {
@@ -1235,7 +1269,7 @@ var noExplicitGenericsRule = ruleCreator({
       }
       const { getTypeAtLocation } = _utils.ESLintUtils.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: [],
@@ -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;
@@ -2075,61 +2157,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)
           });
         }
       }
@@ -2566,7 +2638,7 @@ function voidFunctionArguments(checker, tsNode) {
   }
   const voidReturnIndices = /* @__PURE__ */ new Set();
   const type = checker.getTypeAtLocation(tsNode.expression);
-  for (const subType of tsutils3.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()) {
@@ -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, _typescript2.default.TypeFlags.Void));
+      hasVoidReturn || (hasVoidReturn = tsutils4.isTypeFlagSet(returnType, _typescript2.default.TypeFlags.Void));
     }
   }
   return hasVoidReturn;
@@ -2600,7 +2672,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 : tsutils3.getPropertyOfType(type, escapedMemberName);
+  return symbolMemberMatch != null ? symbolMemberMatch : tsutils4.getPropertyOfType(type, escapedMemberName);
 }
 function isStaticMember(node) {
   return (isMethodDefinition(node) || isPropertyDefinition(node) || isAccessorProperty(node)) && node.static;
@@ -2622,7 +2694,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;
     }
@@ -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."
     },
@@ -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, _typescript2.default.TypeFlags.Any)) {
+            if (tsutils5.isTypeFlagSet(typeArg, _typescript2.default.TypeFlags.Any)) {
               return;
             }
-            if (tsutils4.isTypeFlagSet(typeArg, _typescript2.default.TypeFlags.Unknown)) {
+            if (tsutils5.isTypeFlagSet(typeArg, _typescript2.default.TypeFlags.Unknown)) {
               return;
             }
-            if (tsutils4.isTypeFlagSet(typeArg, _typescript2.default.TypeFlags.Void)) {
+            if (tsutils5.isTypeFlagSet(typeArg, _typescript2.default.TypeFlags.Void)) {
               return;
             }
-            if (tsutils4.isUnionType(typeArg) && typeArg.types.some(
-              (t) => tsutils4.isTypeFlagSet(t, _typescript2.default.TypeFlags.Void)
+            if (tsutils5.isUnionType(typeArg) && typeArg.types.some(
+              (t) => tsutils5.isTypeFlagSet(t, _typescript2.default.TypeFlags.Void)
             )) {
               return;
             }
@@ -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;