eslint-plugin-rxjs-x 0.7.1 → 0.7.3

package/dist/index.d.mts

@@ -124,7 +124,10 @@ declare const rxjsX: {
         'no-ignored-notifier': TSESLint.RuleModule<"forbidden", [], RxjsXRuleDocs, TSESLint.RuleListener>;
         'no-ignored-replay-buffer': TSESLint.RuleModule<"forbidden", [], RxjsXRuleDocs, TSESLint.RuleListener>;
         'no-ignored-subscribe': TSESLint.RuleModule<"forbidden", [], RxjsXRuleDocs, TSESLint.RuleListener>;
-        'no-ignored-subscription': TSESLint.RuleModule<"forbidden", [], RxjsXRuleDocs, TSESLint.RuleListener>;
+        'no-ignored-subscription': TSESLint.RuleModule<"forbidden", readonly {
+            completers?: string[];
+            postCompleters?: string[];
+        }[], RxjsXRuleDocs, TSESLint.RuleListener>;
         'no-ignored-takewhile-value': TSESLint.RuleModule<"forbidden", [], RxjsXRuleDocs, TSESLint.RuleListener>;
         'no-implicit-any-catch': TSESLint.RuleModule<"explicitAny" | "implicitAny" | "narrowed" | "suggestExplicitUnknown", readonly {
             allowExplicitAny?: boolean;

package/dist/index.d.ts

@@ -124,7 +124,10 @@ declare const rxjsX: {
         'no-ignored-notifier': TSESLint.RuleModule<"forbidden", [], RxjsXRuleDocs, TSESLint.RuleListener>;
         'no-ignored-replay-buffer': TSESLint.RuleModule<"forbidden", [], RxjsXRuleDocs, TSESLint.RuleListener>;
         'no-ignored-subscribe': TSESLint.RuleModule<"forbidden", [], RxjsXRuleDocs, TSESLint.RuleListener>;
-        'no-ignored-subscription': TSESLint.RuleModule<"forbidden", [], RxjsXRuleDocs, TSESLint.RuleListener>;
+        'no-ignored-subscription': TSESLint.RuleModule<"forbidden", readonly {
+            completers?: string[];
+            postCompleters?: string[];
+        }[], RxjsXRuleDocs, TSESLint.RuleListener>;
         'no-ignored-takewhile-value': TSESLint.RuleModule<"forbidden", [], RxjsXRuleDocs, TSESLint.RuleListener>;
         'no-implicit-any-catch': TSESLint.RuleModule<"explicitAny" | "implicitAny" | "narrowed" | "suggestExplicitUnknown", readonly {
             allowExplicitAny?: boolean;

package/dist/index.js

@@ -1,6 +1,6 @@
 "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.7.1";
+var version = "0.7.3";
 
 // src/configs/recommended.ts
 var createRecommendedConfig = (plugin2) => ({
@@ -77,8 +77,7 @@ var createStrictConfig = (plugin2) => ({
 var _utils = require('@typescript-eslint/utils');
 var _commontags = require('common-tags');
 
-// src/utils.ts
-
+// src/utils/create-regexp-for-words.ts
 function createRegExpForWords(config) {
   if (!(config == null ? void 0 : config.length)) {
     return void 0;
@@ -91,81 +90,11 @@ function createRegExpForWords(config) {
   const joined = words.map((word) => String.raw`(\b|_)${word}(\b|_)`).join("|");
   return new RegExp(`(${joined})`, flags);
 }
+
+// src/utils/escape-regexp.ts
 function escapeRegExp(text) {
   return text.replace(/[-/\\^$*+?.()|[\]{}]/g, "\\$&");
 }
-var REPO_URL = "https://github.com/JasonWeinzierl/eslint-plugin-rxjs-x";
-var ruleCreator = _utils.ESLintUtils.RuleCreator(
-  (name2) => `${REPO_URL}/blob/v${version}/docs/rules/${name2}.md`
-);
-
-// src/rules/ban-observables.ts
-var defaultOptions = [];
-var banObservablesRule = ruleCreator({
-  defaultOptions,
-  meta: {
-    docs: {
-      description: "Disallow banned observable creators."
-    },
-    messages: {
-      forbidden: "RxJS observable is banned: {{name}}{{explanation}}."
-    },
-    schema: [
-      {
-        type: "object",
-        description: _commontags.stripIndent`
-          An object containing keys that are names of observable factory functions
-          and values that are either booleans or strings containing the explanation for the ban.`
-      }
-    ],
-    type: "problem"
-  },
-  name: "ban-observables",
-  create: (context) => {
-    const bans = [];
-    const [config] = context.options;
-    if (!config) {
-      return {};
-    }
-    Object.entries(config).forEach(([key, value]) => {
-      if (value !== false) {
-        bans.push({
-          explanation: typeof value === "string" ? value : "",
-          regExp: new RegExp(`^${key}$`)
-        });
-      }
-    });
-    function getFailure(name2) {
-      for (let b = 0, length = bans.length; b < length; ++b) {
-        const ban = bans[b];
-        if (ban.regExp.test(name2)) {
-          const explanation = ban.explanation ? `: ${ban.explanation}` : "";
-          return {
-            messageId: "forbidden",
-            data: { name: name2, explanation }
-          };
-        }
-      }
-      return void 0;
-    }
-    return {
-      "ImportDeclaration[source.value='rxjs'] > ImportSpecifier": (node) => {
-        const identifier = node.imported;
-        const name2 = identifier.type === _utils.AST_NODE_TYPES.Identifier ? identifier.name : identifier.value;
-        const failure = getFailure(name2);
-        if (failure) {
-          context.report({
-            ...failure,
-            node: identifier
-          });
-        }
-      }
-    };
-  }
-});
-
-// src/rules/ban-operators.ts
-
 
 // src/etc/could-be-function.ts
 var _typescript = require('typescript'); var _typescript2 = _interopRequireDefault(_typescript);
@@ -370,11 +299,19 @@ function getTypeServices(context) {
     );
   };
   const couldReturnType = (node, name2, qualified) => {
-    var _a;
     let tsTypeNode;
     const tsNode = esTreeNodeToTSNodeMap.get(node);
     if (_typescript2.default.isArrowFunction(tsNode) || _typescript2.default.isFunctionDeclaration(tsNode) || _typescript2.default.isMethodDeclaration(tsNode) || _typescript2.default.isFunctionExpression(tsNode)) {
-      tsTypeNode = (_a = tsNode.type) != null ? _a : tsNode.body;
+      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)) {
@@ -418,7 +355,114 @@ function isImport(scope, name2, source) {
   return scope.upper ? isImport(scope.upper, name2, source) : false;
 }
 
+// src/utils/find-is-last-operator-order-valid.ts
+function findIsLastOperatorOrderValid(pipeCallExpression, operatorsRegExp, allow) {
+  let isOrderValid = true;
+  let operatorNode;
+  for (let i = pipeCallExpression.arguments.length - 1; i >= 0; i--) {
+    const arg = pipeCallExpression.arguments[i];
+    if (operatorNode) {
+      break;
+    }
+    if (!isCallExpression(arg)) {
+      isOrderValid = false;
+      continue;
+    }
+    let operatorName;
+    if (isIdentifier(arg.callee)) {
+      operatorName = arg.callee.name;
+    } else if (isMemberExpression(arg.callee) && isIdentifier(arg.callee.property)) {
+      operatorName = arg.callee.property.name;
+    } else {
+      isOrderValid = false;
+      continue;
+    }
+    if (operatorsRegExp.test(operatorName)) {
+      operatorNode = arg.callee;
+      break;
+    }
+    if (!allow.includes(operatorName)) {
+      isOrderValid = false;
+      continue;
+    }
+  }
+  return { isOrderValid, operatorNode };
+}
+
+// src/utils/rule-creator.ts
+
+var REPO_URL = "https://github.com/JasonWeinzierl/eslint-plugin-rxjs-x";
+var ruleCreator = _utils.ESLintUtils.RuleCreator(
+  (name2) => `${REPO_URL}/blob/v${version}/docs/rules/${name2}.md`
+);
+
+// src/rules/ban-observables.ts
+var defaultOptions = [];
+var banObservablesRule = ruleCreator({
+  defaultOptions,
+  meta: {
+    docs: {
+      description: "Disallow banned observable creators."
+    },
+    messages: {
+      forbidden: "RxJS observable is banned: {{name}}{{explanation}}."
+    },
+    schema: [
+      {
+        type: "object",
+        description: _commontags.stripIndent`
+          An object containing keys that are names of observable factory functions
+          and values that are either booleans or strings containing the explanation for the ban.`
+      }
+    ],
+    type: "problem"
+  },
+  name: "ban-observables",
+  create: (context) => {
+    const bans = [];
+    const [config] = context.options;
+    if (!config) {
+      return {};
+    }
+    Object.entries(config).forEach(([key, value]) => {
+      if (value !== false) {
+        bans.push({
+          explanation: typeof value === "string" ? value : "",
+          regExp: new RegExp(`^${key}$`)
+        });
+      }
+    });
+    function getFailure(name2) {
+      for (let b = 0, length = bans.length; b < length; ++b) {
+        const ban = bans[b];
+        if (ban.regExp.test(name2)) {
+          const explanation = ban.explanation ? `: ${ban.explanation}` : "";
+          return {
+            messageId: "forbidden",
+            data: { name: name2, explanation }
+          };
+        }
+      }
+      return void 0;
+    }
+    return {
+      "ImportDeclaration[source.value='rxjs'] > ImportSpecifier": (node) => {
+        const identifier = node.imported;
+        const name2 = identifier.type === _utils.AST_NODE_TYPES.Identifier ? identifier.name : identifier.value;
+        const failure = getFailure(name2);
+        if (failure) {
+          context.report({
+            ...failure,
+            node: identifier
+          });
+        }
+      }
+    };
+  }
+});
+
 // src/rules/ban-operators.ts
+
 var defaultOptions2 = [];
 var banOperatorsRule = ruleCreator({
   defaultOptions: defaultOptions2,
@@ -987,6 +1031,29 @@ var noCreateRule = ruleCreator({
 
 // src/constants.ts
 var defaultObservable = String.raw`[Aa]ction(s|s\$|\$)$`;
+var DEFAULT_VALID_POST_COMPLETION_OPERATORS = [
+  "count",
+  "defaultIfEmpty",
+  "endWith",
+  "every",
+  "finalize",
+  "finally",
+  "isEmpty",
+  "last",
+  "max",
+  "min",
+  "publish",
+  "publishBehavior",
+  "publishLast",
+  "publishReplay",
+  "reduce",
+  "share",
+  "shareReplay",
+  "skipLast",
+  "takeLast",
+  "throwIfEmpty",
+  "toArray"
+];
 
 // src/rules/no-cyclic-action.ts
 function isTypeReference2(type) {
@@ -1757,8 +1824,10 @@ var noIgnoredSubscribeRule = ruleCreator({
 });
 
 // src/rules/no-ignored-subscription.ts
+
+var defaultOptions7 = [];
 var noIgnoredSubscriptionRule = ruleCreator({
-  defaultOptions: [],
+  defaultOptions: defaultOptions7,
   meta: {
     docs: {
       description: "Disallow ignoring the subscription returned by `subscribe`.",
@@ -1767,12 +1836,44 @@ var noIgnoredSubscriptionRule = ruleCreator({
     messages: {
       forbidden: "Ignoring returned subscriptions is forbidden."
     },
-    schema: [],
+    schema: [
+      {
+        properties: {
+          completers: { type: "array", items: { type: "string" }, description: "An array of operator names that will complete the observable and silence this rule.", default: ["takeUntil", "takeWhile", "take", "first", "last", "takeUntilDestroyed"] },
+          postCompleters: { type: "array", items: { type: "string" }, description: "An array of operator names that are allowed to follow the completion operators.", default: DEFAULT_VALID_POST_COMPLETION_OPERATORS }
+        },
+        type: "object",
+        description: _commontags.stripIndent`
+          An object with optional \`completers\` and \`postCompleters\` properties.
+          The \`completers\` property is an array containing the names of operators that will complete the observable and silence this rule.
+          The \`postCompleters\` property is an array containing the names of the operators that are allowed to follow the completion operators.
+        `
+      }
+    ],
     type: "problem"
   },
   name: "no-ignored-subscription",
   create: (context) => {
+    const [config = {}] = context.options;
+    const {
+      completers = ["takeUntil", "takeWhile", "take", "first", "last", "takeUntilDestroyed"],
+      postCompleters = DEFAULT_VALID_POST_COMPLETION_OPERATORS
+    } = config;
+    const checkedOperatorsRegExp = new RegExp(
+      `^(${completers.join("|")})$`
+    );
     const { couldBeObservable, couldBeType: couldBeType2 } = getTypeServices(context);
+    function hasAllowedOperator(node) {
+      if (isCallExpression(node) && isMemberExpression(node.callee) && isIdentifier(node.callee.property) && node.callee.property.name === "pipe") {
+        const { isOrderValid, operatorNode } = findIsLastOperatorOrderValid(
+          node,
+          checkedOperatorsRegExp,
+          postCompleters
+        );
+        return isOrderValid && !!operatorNode;
+      }
+      return false;
+    }
     return {
       "ExpressionStatement > CallExpression > MemberExpression[property.name='subscribe']": (node) => {
         if (couldBeObservable(node.object)) {
@@ -1780,6 +1881,9 @@ var noIgnoredSubscriptionRule = ruleCreator({
           if (callExpression.arguments.length === 1 && couldBeType2(callExpression.arguments[0], "Subscriber")) {
             return;
           }
+          if (hasAllowedOperator(node.object)) {
+            return;
+          }
           context.report({
             messageId: "forbidden",
             node: node.property
@@ -1854,9 +1958,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 defaultOptions7 = [];
+var defaultOptions8 = [];
 var noImplicitAnyCatchRule = ruleCreator({
-  defaultOptions: defaultOptions7,
+  defaultOptions: defaultOptions8,
   meta: {
     docs: {
       description: "Disallow implicit `any` error parameters in `catchError` operators.",
@@ -2130,9 +2234,9 @@ function parseChecksVoidReturn(checksVoidReturn) {
       };
   }
 }
-var defaultOptions8 = [];
+var defaultOptions9 = [];
 var noMisusedObservablesRule = ruleCreator({
-  defaultOptions: defaultOptions8,
+  defaultOptions: defaultOptions9,
   meta: {
     docs: {
       description: "Disallow Observables in places not designed to handle them.",
@@ -2620,9 +2724,9 @@ function isExpressionObserver(expressionStatement, couldBeType2) {
 
 // src/rules/no-sharereplay.ts
 
-var defaultOptions9 = [];
+var defaultOptions10 = [];
 var noSharereplayRule = ruleCreator({
-  defaultOptions: defaultOptions9,
+  defaultOptions: defaultOptions10,
   meta: {
     docs: {
       description: "Disallow unsafe `shareReplay` usage.",
@@ -3062,9 +3166,9 @@ var noUnboundMethodsRule = ruleCreator({
 
 // src/rules/no-unsafe-catch.ts
 
-var defaultOptions10 = [];
+var defaultOptions11 = [];
 var noUnsafeCatchRule = ruleCreator({
-  defaultOptions: defaultOptions10,
+  defaultOptions: defaultOptions11,
   meta: {
     docs: {
       description: "Disallow unsafe `catchError` usage in effects and epics.",
@@ -3123,9 +3227,9 @@ var noUnsafeCatchRule = ruleCreator({
 
 // src/rules/no-unsafe-first.ts
 
-var defaultOptions11 = [];
+var defaultOptions12 = [];
 var noUnsafeFirstRule = ruleCreator({
-  defaultOptions: defaultOptions11,
+  defaultOptions: defaultOptions12,
   meta: {
     docs: {
       description: "Disallow unsafe `first`/`take` usage in effects and epics.",
@@ -3247,9 +3351,9 @@ var noUnsafeSubjectNext = ruleCreator({
 // src/rules/no-unsafe-switchmap.ts
 
 var _decamelize = require('decamelize'); var _decamelize2 = _interopRequireDefault(_decamelize);
-var defaultOptions12 = [];
+var defaultOptions13 = [];
 var noUnsafeSwitchmapRule = ruleCreator({
-  defaultOptions: defaultOptions12,
+  defaultOptions: defaultOptions13,
   meta: {
     docs: {
       description: "Disallow unsafe `switchMap` usage in effects and epics.",
@@ -3372,32 +3476,9 @@ var noUnsafeSwitchmapRule = ruleCreator({
 
 // src/rules/no-unsafe-takeuntil.ts
 
-var defaultOptions13 = [];
-var allowedOperators = [
-  "count",
-  "defaultIfEmpty",
-  "endWith",
-  "every",
-  "finalize",
-  "finally",
-  "isEmpty",
-  "last",
-  "max",
-  "min",
-  "publish",
-  "publishBehavior",
-  "publishLast",
-  "publishReplay",
-  "reduce",
-  "share",
-  "shareReplay",
-  "skipLast",
-  "takeLast",
-  "throwIfEmpty",
-  "toArray"
-];
+var defaultOptions14 = [];
 var noUnsafeTakeuntilRule = ruleCreator({
-  defaultOptions: defaultOptions13,
+  defaultOptions: defaultOptions14,
   meta: {
     docs: {
       description: "Disallow applying operators after `takeUntil`.",
@@ -3411,7 +3492,7 @@ var noUnsafeTakeuntilRule = ruleCreator({
       {
         properties: {
           alias: { type: "array", items: { type: "string" }, description: "An array of operator names that should be treated similarly to `takeUntil`." },
-          allow: { type: "array", items: { type: "string" }, description: "An array of operator names that are allowed to follow `takeUntil`.", default: allowedOperators }
+          allow: { type: "array", items: { type: "string" }, description: "An array of operator names that are allowed to follow `takeUntil`.", default: DEFAULT_VALID_POST_COMPLETION_OPERATORS }
         },
         type: "object",
         description: _commontags.stripIndent`
@@ -3426,7 +3507,7 @@ var noUnsafeTakeuntilRule = ruleCreator({
   create: (context) => {
     let checkedOperatorsRegExp = /^takeUntil$/;
     const [config = {}] = context.options;
-    const { alias, allow = allowedOperators } = config;
+    const { alias, allow = DEFAULT_VALID_POST_COMPLETION_OPERATORS } = config;
     if (alias) {
       checkedOperatorsRegExp = new RegExp(
         `^(${alias.concat("takeUntil").join("|")})$`
@@ -3438,35 +3519,17 @@ var noUnsafeTakeuntilRule = ruleCreator({
       if (!pipeCallExpression.arguments || !couldBeObservable(pipeCallExpression)) {
         return;
       }
-      pipeCallExpression.arguments.reduceRight((state, arg) => {
-        if (state === "taken") {
-          return state;
-        }
-        if (!isCallExpression(arg)) {
-          return "disallowed";
-        }
-        let operatorName;
-        if (isIdentifier(arg.callee)) {
-          operatorName = arg.callee.name;
-        } else if (isMemberExpression(arg.callee) && isIdentifier(arg.callee.property)) {
-          operatorName = arg.callee.property.name;
-        } else {
-          return "disallowed";
-        }
-        if (checkedOperatorsRegExp.test(operatorName)) {
-          if (state === "disallowed") {
-            context.report({
-              messageId: "forbidden",
-              node: arg.callee
-            });
-          }
-          return "taken";
-        }
-        if (!allow.includes(operatorName)) {
-          return "disallowed";
-        }
-        return state;
-      }, "allowed");
+      const { isOrderValid, operatorNode } = findIsLastOperatorOrderValid(
+        pipeCallExpression,
+        checkedOperatorsRegExp,
+        allow
+      );
+      if (!isOrderValid && operatorNode) {
+        context.report({
+          messageId: "forbidden",
+          node: operatorNode
+        });
+      }
     }
     return {
       [`CallExpression[callee.property.name='pipe'] > CallExpression[callee.name=${checkedOperatorsRegExp}]`]: checkNode,
@@ -3476,9 +3539,9 @@ var noUnsafeTakeuntilRule = ruleCreator({
 });
 
 // src/rules/prefer-observer.ts
-var defaultOptions14 = [];
+var defaultOptions15 = [];
 var preferObserverRule = ruleCreator({
-  defaultOptions: defaultOptions14,
+  defaultOptions: defaultOptions15,
   meta: {
     docs: {
       description: "Disallow passing separate handlers to `subscribe` and `tap`.",
@@ -3714,9 +3777,9 @@ var preferRootOperatorsRule = ruleCreator({
 
 // src/rules/suffix-subjects.ts
 
-var defaultOptions15 = [];
+var defaultOptions16 = [];
 var suffixSubjectsRule = ruleCreator({
-  defaultOptions: defaultOptions15,
+  defaultOptions: defaultOptions16,
   meta: {
     docs: {
       description: "Enforce the use of a suffix in subject identifiers.",
@@ -3913,9 +3976,9 @@ var suffixSubjectsRule = ruleCreator({
 // src/rules/throw-error.ts
 
 
-var defaultOptions16 = [];
+var defaultOptions17 = [];
 var throwErrorRule = ruleCreator({
-  defaultOptions: defaultOptions16,
+  defaultOptions: defaultOptions17,
   meta: {
     docs: {
       description: "Enforce passing only `Error` values to `throwError`.",