eslint-plugin-rxjs-x 0.7.1 → 0.7.3

package/dist/index.mjs

@@ -1,6 +1,6 @@
 // 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) => ({
@@ -74,11 +74,10 @@ var createStrictConfig = (plugin2) => ({
 });
 
 // src/rules/ban-observables.ts
-import { AST_NODE_TYPES } from "@typescript-eslint/utils";
+import { AST_NODE_TYPES as AST_NODE_TYPES3 } from "@typescript-eslint/utils";
 import { stripIndent } from "common-tags";
 
-// src/utils.ts
-import { ESLintUtils } from "@typescript-eslint/utils";
+// 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 = 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: 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 === AST_NODE_TYPES.Identifier ? identifier.name : identifier.value;
-        const failure = getFailure(name2);
-        if (failure) {
-          context.report({
-            ...failure,
-            node: identifier
-          });
-        }
-      }
-    };
-  }
-});
-
-// src/rules/ban-operators.ts
-import { stripIndent as stripIndent2 } from "common-tags";
 
 // src/etc/could-be-function.ts
 import ts2 from "typescript";
@@ -281,84 +210,84 @@ function getLoc(node) {
 }
 
 // src/etc/get-type-services.ts
-import { ESLintUtils as ESLintUtils2 } from "@typescript-eslint/utils";
+import { ESLintUtils } from "@typescript-eslint/utils";
 import ts4 from "typescript";
 
 // src/etc/is.ts
-import { AST_NODE_TYPES as AST_NODE_TYPES2 } from "@typescript-eslint/utils";
+import { AST_NODE_TYPES } from "@typescript-eslint/utils";
 function hasTypeAnnotation(node) {
   return "typeAnnotation" in node && !!node.typeAnnotation;
 }
 function isArrayExpression(node) {
-  return node.type === AST_NODE_TYPES2.ArrayExpression;
+  return node.type === AST_NODE_TYPES.ArrayExpression;
 }
 function isArrayPattern(node) {
-  return node.type === AST_NODE_TYPES2.ArrayPattern;
+  return node.type === AST_NODE_TYPES.ArrayPattern;
 }
 function isArrowFunctionExpression(node) {
-  return node.type === AST_NODE_TYPES2.ArrowFunctionExpression;
+  return node.type === AST_NODE_TYPES.ArrowFunctionExpression;
 }
 function isBlockStatement(node) {
-  return node.type === AST_NODE_TYPES2.BlockStatement;
+  return node.type === AST_NODE_TYPES.BlockStatement;
 }
 function isCallExpression(node) {
-  return node.type === AST_NODE_TYPES2.CallExpression;
+  return node.type === AST_NODE_TYPES.CallExpression;
 }
 function isChainExpression(node) {
-  return node.type === AST_NODE_TYPES2.ChainExpression;
+  return node.type === AST_NODE_TYPES.ChainExpression;
 }
 function isFunctionDeclaration(node) {
-  return node.type === AST_NODE_TYPES2.FunctionDeclaration;
+  return node.type === AST_NODE_TYPES.FunctionDeclaration;
 }
 function isFunctionExpression(node) {
-  return node.type === AST_NODE_TYPES2.FunctionExpression;
+  return node.type === AST_NODE_TYPES.FunctionExpression;
 }
 function isIdentifier(node) {
-  return node.type === AST_NODE_TYPES2.Identifier;
+  return node.type === AST_NODE_TYPES.Identifier;
 }
 function isImportDeclaration(node) {
-  return node.type === AST_NODE_TYPES2.ImportDeclaration;
+  return node.type === AST_NODE_TYPES.ImportDeclaration;
 }
 function isImportNamespaceSpecifier(node) {
-  return node.type === AST_NODE_TYPES2.ImportNamespaceSpecifier;
+  return node.type === AST_NODE_TYPES.ImportNamespaceSpecifier;
 }
 function isImportSpecifier(node) {
-  return node.type === AST_NODE_TYPES2.ImportSpecifier;
+  return node.type === AST_NODE_TYPES.ImportSpecifier;
 }
 function isJSXExpressionContainer(node) {
-  return node.type === AST_NODE_TYPES2.JSXExpressionContainer;
+  return node.type === AST_NODE_TYPES.JSXExpressionContainer;
 }
 function isLiteral(node) {
-  return node.type === AST_NODE_TYPES2.Literal;
+  return node.type === AST_NODE_TYPES.Literal;
 }
 function isMemberExpression(node) {
-  return node.type === AST_NODE_TYPES2.MemberExpression;
+  return node.type === AST_NODE_TYPES.MemberExpression;
 }
 function isMethodDefinition(node) {
-  return node.type === AST_NODE_TYPES2.MethodDefinition;
+  return node.type === AST_NODE_TYPES.MethodDefinition;
 }
 function isObjectExpression(node) {
-  return node.type === AST_NODE_TYPES2.ObjectExpression;
+  return node.type === AST_NODE_TYPES.ObjectExpression;
 }
 function isObjectPattern(node) {
-  return node.type === AST_NODE_TYPES2.ObjectPattern;
+  return node.type === AST_NODE_TYPES.ObjectPattern;
 }
 function isProgram(node) {
-  return node.type === AST_NODE_TYPES2.Program;
+  return node.type === AST_NODE_TYPES.Program;
 }
 function isProperty(node) {
-  return node.type === AST_NODE_TYPES2.Property;
+  return node.type === AST_NODE_TYPES.Property;
 }
 function isPropertyDefinition(node) {
-  return node.type === AST_NODE_TYPES2.PropertyDefinition;
+  return node.type === AST_NODE_TYPES.PropertyDefinition;
 }
 function isUnaryExpression(node) {
-  return node.type === AST_NODE_TYPES2.UnaryExpression;
+  return node.type === AST_NODE_TYPES.UnaryExpression;
 }
 
 // src/etc/get-type-services.ts
 function getTypeServices(context) {
-  const services = ESLintUtils2.getParserServices(context);
+  const services = ESLintUtils.getParserServices(context);
   const { esTreeNodeToTSNodeMap, program, getTypeAtLocation } = services;
   const typeChecker = program.getTypeChecker();
   const couldBeType2 = (node, name2, qualified) => {
@@ -370,11 +299,19 @@ function getTypeServices(context) {
     );
   };
   const couldReturnType = (node, name2, qualified) => {
-    var _a;
     let tsTypeNode;
     const tsNode = esTreeNodeToTSNodeMap.get(node);
     if (ts4.isArrowFunction(tsNode) || ts4.isFunctionDeclaration(tsNode) || ts4.isMethodDeclaration(tsNode) || ts4.isFunctionExpression(tsNode)) {
-      tsTypeNode = (_a = tsNode.type) != null ? _a : tsNode.body;
+      if (tsNode.type) {
+        tsTypeNode = tsNode.type;
+      } else if (tsNode.body && ts4.isBlock(tsNode.body)) {
+        const returnStatement = tsNode.body.statements.find(ts4.isReturnStatement);
+        if (returnStatement == null ? void 0 : returnStatement.expression) {
+          tsTypeNode = returnStatement.expression;
+        }
+      } else {
+        tsTypeNode = tsNode.body;
+      }
     } else if (ts4.isCallSignatureDeclaration(tsNode) || ts4.isMethodSignature(tsNode)) {
       tsTypeNode = tsNode.type;
     } else if (ts4.isPropertySignature(tsNode)) {
@@ -407,18 +344,125 @@ function getTypeServices(context) {
 
 // src/etc/is-import.ts
 import { DefinitionType } from "@typescript-eslint/scope-manager";
-import { AST_NODE_TYPES as AST_NODE_TYPES3 } from "@typescript-eslint/utils";
+import { AST_NODE_TYPES as AST_NODE_TYPES2 } from "@typescript-eslint/utils";
 function isImport(scope, name2, source) {
   const variable = scope.variables.find((variable2) => variable2.name === name2);
   if (variable) {
     return variable.defs.some(
-      (def) => def.type === DefinitionType.ImportBinding && def.parent.type === AST_NODE_TYPES3.ImportDeclaration && (typeof source === "string" ? def.parent.source.value === source : source.test(def.parent.source.value))
+      (def) => def.type === DefinitionType.ImportBinding && def.parent.type === AST_NODE_TYPES2.ImportDeclaration && (typeof source === "string" ? def.parent.source.value === source : source.test(def.parent.source.value))
     );
   }
   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
+import { ESLintUtils as ESLintUtils2 } from "@typescript-eslint/utils";
+var REPO_URL = "https://github.com/JasonWeinzierl/eslint-plugin-rxjs-x";
+var ruleCreator = ESLintUtils2.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: 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 === AST_NODE_TYPES3.Identifier ? identifier.name : identifier.value;
+        const failure = getFailure(name2);
+        if (failure) {
+          context.report({
+            ...failure,
+            node: identifier
+          });
+        }
+      }
+    };
+  }
+});
+
 // src/rules/ban-operators.ts
+import { stripIndent as stripIndent2 } from "common-tags";
 var defaultOptions2 = [];
 var banOperatorsRule = ruleCreator({
   defaultOptions: defaultOptions2,
@@ -987,6 +1031,29 @@ import ts5 from "typescript";
 
 // 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
+import { stripIndent as stripIndent4 } from "common-tags";
+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: stripIndent4`
+          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
 import { AST_NODE_TYPES as AST_NODE_TYPES7 } from "@typescript-eslint/utils";
-var defaultOptions9 = [];
+var defaultOptions10 = [];
 var noSharereplayRule = ruleCreator({
-  defaultOptions: defaultOptions9,
+  defaultOptions: defaultOptions10,
   meta: {
     docs: {
       description: "Disallow unsafe `shareReplay` usage.",
@@ -3061,10 +3165,10 @@ var noUnboundMethodsRule = ruleCreator({
 });
 
 // src/rules/no-unsafe-catch.ts
-import { stripIndent as stripIndent4 } from "common-tags";
-var defaultOptions10 = [];
+import { stripIndent as stripIndent5 } from "common-tags";
+var defaultOptions11 = [];
 var noUnsafeCatchRule = ruleCreator({
-  defaultOptions: defaultOptions10,
+  defaultOptions: defaultOptions11,
   meta: {
     docs: {
       description: "Disallow unsafe `catchError` usage in effects and epics.",
@@ -3079,7 +3183,7 @@ var noUnsafeCatchRule = ruleCreator({
           observable: { type: "string", description: "A RegExp that matches an effect or epic's actions observable.", default: defaultObservable }
         },
         type: "object",
-        description: stripIndent4`
+        description: stripIndent5`
           An optional object with an optional \`observable\` property.
           The property can be specified as a regular expression string and is used to identify the action observables from which effects and epics are composed.`
       }
@@ -3122,10 +3226,10 @@ var noUnsafeCatchRule = ruleCreator({
 });
 
 // src/rules/no-unsafe-first.ts
-import { stripIndent as stripIndent5 } from "common-tags";
-var defaultOptions11 = [];
+import { stripIndent as stripIndent6 } from "common-tags";
+var defaultOptions12 = [];
 var noUnsafeFirstRule = ruleCreator({
-  defaultOptions: defaultOptions11,
+  defaultOptions: defaultOptions12,
   meta: {
     docs: {
       description: "Disallow unsafe `first`/`take` usage in effects and epics.",
@@ -3140,7 +3244,7 @@ var noUnsafeFirstRule = ruleCreator({
           observable: { type: "string", description: "A RegExp that matches an effect or epic's actions observable.", default: defaultObservable }
         },
         type: "object",
-        description: stripIndent5`
+        description: stripIndent6`
           An optional object with an optional \`observable\` property.
           The property can be specified as a regular expression string and is used to identify the action observables from which effects and epics are composed.`
       }
@@ -3245,11 +3349,11 @@ var noUnsafeSubjectNext = ruleCreator({
 });
 
 // src/rules/no-unsafe-switchmap.ts
-import { stripIndent as stripIndent6 } from "common-tags";
+import { stripIndent as stripIndent7 } from "common-tags";
 import decamelize from "decamelize";
-var defaultOptions12 = [];
+var defaultOptions13 = [];
 var noUnsafeSwitchmapRule = ruleCreator({
-  defaultOptions: defaultOptions12,
+  defaultOptions: defaultOptions13,
   meta: {
     docs: {
       description: "Disallow unsafe `switchMap` usage in effects and epics.",
@@ -3282,7 +3386,7 @@ var noUnsafeSwitchmapRule = ruleCreator({
           }
         },
         type: "object",
-        description: stripIndent6`
+        description: stripIndent7`
           An optional object with optional \`allow\`, \`disallow\` and \`observable\` properties.
           The properties can be specified as regular expression strings or as arrays of words.
           The \`allow\` or \`disallow\` properties are mutually exclusive. Whether or not
@@ -3371,33 +3475,10 @@ var noUnsafeSwitchmapRule = ruleCreator({
 });
 
 // src/rules/no-unsafe-takeuntil.ts
-import { stripIndent as stripIndent7 } from "common-tags";
-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"
-];
+import { stripIndent as stripIndent8 } from "common-tags";
+var defaultOptions14 = [];
 var noUnsafeTakeuntilRule = ruleCreator({
-  defaultOptions: defaultOptions13,
+  defaultOptions: defaultOptions14,
   meta: {
     docs: {
       description: "Disallow applying operators after `takeUntil`.",
@@ -3411,10 +3492,10 @@ 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: stripIndent7`
+        description: stripIndent8`
           An optional object with optional \`alias\` and \`allow\` properties.
           The \`alias\` property is an array containing the names of operators that aliases for \`takeUntil\`.
           The \`allow\` property is an array containing the names of the operators that are allowed to follow \`takeUntil\`.`
@@ -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
 import { AST_NODE_TYPES as AST_NODE_TYPES9, ESLintUtils as ESLintUtils11 } from "@typescript-eslint/utils";
-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
 import { ESLintUtils as ESLintUtils12 } from "@typescript-eslint/utils";
 import * as tsutils4 from "ts-api-utils";
-var defaultOptions16 = [];
+var defaultOptions17 = [];
 var throwErrorRule = ruleCreator({
-  defaultOptions: defaultOptions16,
+  defaultOptions: defaultOptions17,
   meta: {
     docs: {
       description: "Enforce passing only `Error` values to `throwError`.",