eslint-plugin-rxjs-x 0.3.0 → 0.3.2

package/README.md

@@ -72,7 +72,7 @@ The package includes the following rules.
 | [just](docs/rules/just.md)                                             | Require the use of `just` instead of `of`.                                                                |    | 🔧 |    |    |    |
 | [macro](docs/rules/macro.md)                                           | Require the use of the RxJS Tools Babel macro.                                                            |    | 🔧 |    |    | ❌  |
 | [no-async-subscribe](docs/rules/no-async-subscribe.md)                 | Disallow passing `async` functions to `subscribe`.                                                        | ✅  |    |    | 💭 |    |
-| [no-compat](docs/rules/no-compat.md)                                   | Disallow the `rxjs-compat` package.                                                                       |    |    |    |    |    |
+| [no-compat](docs/rules/no-compat.md)                                   | Disallow the `rxjs-compat` package.                                                                       |    |    |    |    | ❌  |
 | [no-connectable](docs/rules/no-connectable.md)                         | Disallow operators that return connectable observables.                                                   |    |    |    | 💭 |    |
 | [no-create](docs/rules/no-create.md)                                   | Disallow the static `Observable.create` function.                                                         | ✅  |    |    | 💭 |    |
 | [no-cyclic-action](docs/rules/no-cyclic-action.md)                     | Disallow cyclic actions in effects and epics.                                                             |    |    |    | 💭 |    |
@@ -98,7 +98,7 @@ The package includes the following rules.
 | [no-subject-value](docs/rules/no-subject-value.md)                     | Disallow accessing the `value` property of a `BehaviorSubject` instance.                                  |    |    |    | 💭 |    |
 | [no-subscribe-handlers](docs/rules/no-subscribe-handlers.md)           | Disallow passing handlers to `subscribe`.                                                                 |    |    |    | 💭 |    |
 | [no-tap](docs/rules/no-tap.md)                                         | Disallow the `tap` operator.                                                                              |    |    |    |    | ❌  |
-| [no-topromise](docs/rules/no-topromise.md)                             | Disallow use of the `toPromise` method.                                                                   |    |    |    | 💭 |    |
+| [no-topromise](docs/rules/no-topromise.md)                             | Disallow use of the `toPromise` method.                                                                   |    |    | 💡 | 💭 |    |
 | [no-unbound-methods](docs/rules/no-unbound-methods.md)                 | Disallow passing unbound methods.                                                                         | ✅  |    |    | 💭 |    |
 | [no-unsafe-catch](docs/rules/no-unsafe-catch.md)                       | Disallow unsafe `catchError` usage in effects and epics.                                                  |    |    |    | 💭 |    |
 | [no-unsafe-first](docs/rules/no-unsafe-first.md)                       | Disallow unsafe `first`/`take` usage in effects and epics.                                                |    |    |    | 💭 |    |
@@ -106,6 +106,7 @@ The package includes the following rules.
 | [no-unsafe-switchmap](docs/rules/no-unsafe-switchmap.md)               | Disallow unsafe `switchMap` usage in effects and epics.                                                   |    |    |    | 💭 |    |
 | [no-unsafe-takeuntil](docs/rules/no-unsafe-takeuntil.md)               | Disallow applying operators after `takeUntil`.                                                            | ✅  |    |    | 💭 |    |
 | [prefer-observer](docs/rules/prefer-observer.md)                       | Disallow passing separate handlers to `subscribe` and `tap`.                                              |    | 🔧 | 💡 | 💭 |    |
+| [prefer-root-operators](docs/rules/prefer-root-operators.md)           | Disallow importing operators from `rxjs/operators`.                                                       |    | 🔧 | 💡 |    |    |
 | [suffix-subjects](docs/rules/suffix-subjects.md)                       | Enforce the use of a suffix in subject identifiers.                                                       |    |    |    | 💭 |    |
 | [throw-error](docs/rules/throw-error.md)                               | Enforce passing only `Error` values to `throwError`.                                                      |    |    |    | 💭 |    |
 

package/dist/index.d.mts

@@ -87,7 +87,7 @@ declare const rxjsX: {
         'no-subject-value': TSESLint.RuleModule<"forbidden", [], RxjsXRuleDocs, TSESLint.RuleListener>;
         'no-subscribe-handlers': TSESLint.RuleModule<"forbidden", [], RxjsXRuleDocs, TSESLint.RuleListener>;
         'no-tap': TSESLint.RuleModule<"forbidden", [], RxjsXRuleDocs, TSESLint.RuleListener>;
-        'no-topromise': TSESLint.RuleModule<"forbidden", [], RxjsXRuleDocs, TSESLint.RuleListener>;
+        'no-topromise': TSESLint.RuleModule<"forbidden" | "suggestLastValueFrom" | "suggestFirstValueFrom", [], RxjsXRuleDocs, TSESLint.RuleListener>;
         'no-unbound-methods': TSESLint.RuleModule<"forbidden", [], RxjsXRuleDocs, TSESLint.RuleListener>;
         'no-unsafe-catch': TSESLint.RuleModule<"forbidden", readonly {
             observable?: string;
@@ -108,6 +108,7 @@ declare const rxjsX: {
         'prefer-observer': TSESLint.RuleModule<"forbidden", readonly {
             allowNext?: boolean;
         }[], RxjsXRuleDocs, TSESLint.RuleListener>;
+        'prefer-root-operators': TSESLint.RuleModule<"forbidden" | "suggest" | "forbiddenWithoutFix", [], RxjsXRuleDocs, TSESLint.RuleListener>;
         'suffix-subjects': TSESLint.RuleModule<"forbidden", readonly {
             parameters?: boolean;
             properties?: boolean;

package/dist/index.d.ts

@@ -87,7 +87,7 @@ declare const rxjsX: {
         'no-subject-value': TSESLint.RuleModule<"forbidden", [], RxjsXRuleDocs, TSESLint.RuleListener>;
         'no-subscribe-handlers': TSESLint.RuleModule<"forbidden", [], RxjsXRuleDocs, TSESLint.RuleListener>;
         'no-tap': TSESLint.RuleModule<"forbidden", [], RxjsXRuleDocs, TSESLint.RuleListener>;
-        'no-topromise': TSESLint.RuleModule<"forbidden", [], RxjsXRuleDocs, TSESLint.RuleListener>;
+        'no-topromise': TSESLint.RuleModule<"forbidden" | "suggestLastValueFrom" | "suggestFirstValueFrom", [], RxjsXRuleDocs, TSESLint.RuleListener>;
         'no-unbound-methods': TSESLint.RuleModule<"forbidden", [], RxjsXRuleDocs, TSESLint.RuleListener>;
         'no-unsafe-catch': TSESLint.RuleModule<"forbidden", readonly {
             observable?: string;
@@ -108,6 +108,7 @@ declare const rxjsX: {
         'prefer-observer': TSESLint.RuleModule<"forbidden", readonly {
             allowNext?: boolean;
         }[], RxjsXRuleDocs, TSESLint.RuleListener>;
+        'prefer-root-operators': TSESLint.RuleModule<"forbidden" | "suggest" | "forbiddenWithoutFix", [], RxjsXRuleDocs, TSESLint.RuleListener>;
         'suffix-subjects': TSESLint.RuleModule<"forbidden", readonly {
             parameters?: boolean;
             properties?: 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.3.0";
+var version = "0.3.2";
 
 // src/configs/recommended.ts
 var createRecommendedConfig = (plugin2) => ({
@@ -265,6 +265,15 @@ function isFunctionExpression(node) {
 function isIdentifier(node) {
   return node.type === _utils.AST_NODE_TYPES.Identifier;
 }
+function isImportDeclaration(node) {
+  return node.type === _utils.AST_NODE_TYPES.ImportDeclaration;
+}
+function isImportNamespaceSpecifier(node) {
+  return node.type === _utils.AST_NODE_TYPES.ImportNamespaceSpecifier;
+}
+function isImportSpecifier(node) {
+  return node.type === _utils.AST_NODE_TYPES.ImportSpecifier;
+}
 function isLiteral(node) {
   return node.type === _utils.AST_NODE_TYPES.Literal;
 }
@@ -814,6 +823,7 @@ var noAsyncSubscribeRule = ruleCreator({
 var noCompatRule = ruleCreator({
   defaultOptions: [],
   meta: {
+    deprecated: true,
     docs: {
       description: "Disallow the `rxjs-compat` package."
     },
@@ -1370,6 +1380,7 @@ var noIgnoredDefaultValueRule = ruleCreator({
 });
 
 // src/rules/no-ignored-error.ts
+
 var noIgnoredErrorRule = ruleCreator({
   defaultOptions: [],
   meta: {
@@ -1385,12 +1396,44 @@ var noIgnoredErrorRule = ruleCreator({
   },
   name: "no-ignored-error",
   create: (context) => {
+    const { getTypeAtLocation } = _utils.ESLintUtils.getParserServices(context);
     const { couldBeObservable, couldBeFunction: couldBeFunction2 } = getTypeServices(context);
+    function isMissingErrorCallback(callExpression) {
+      if (callExpression.arguments.length >= 2) {
+        return false;
+      }
+      return couldBeFunction2(callExpression.arguments[0]);
+    }
+    function isObjMissingError(arg) {
+      return !arg.properties.some(
+        (property) => isProperty(property) && isIdentifier(property.key) && property.key.name === "error"
+      );
+    }
+    function isTypeMissingError(arg) {
+      const argType = getTypeAtLocation(arg);
+      return !(argType == null ? void 0 : argType.getProperties().some((p) => p.name === "error"));
+    }
+    function isMissingErrorProperty(callExpression) {
+      if (callExpression.arguments.length !== 1) {
+        return false;
+      }
+      const [arg] = callExpression.arguments;
+      if (isObjectExpression(arg)) {
+        return isObjMissingError(arg);
+      }
+      if (isIdentifier(arg)) {
+        return isTypeMissingError(arg);
+      }
+      if (isMemberExpression(arg) && isIdentifier(arg.property)) {
+        return isTypeMissingError(arg.property);
+      }
+      return false;
+    }
     return {
       "CallExpression[arguments.length > 0] > MemberExpression > Identifier[name='subscribe']": (node) => {
         const memberExpression = node.parent;
         const callExpression = memberExpression.parent;
-        if (callExpression.arguments.length < 2 && couldBeObservable(memberExpression.object) && couldBeFunction2(callExpression.arguments[0])) {
+        if ((isMissingErrorCallback(callExpression) || isMissingErrorProperty(callExpression)) && couldBeObservable(memberExpression.object)) {
           context.report({
             messageId: "forbidden",
             node
@@ -2294,8 +2337,11 @@ var noTopromiseRule = ruleCreator({
       description: "Disallow use of the `toPromise` method.",
       requiresTypeChecking: true
     },
+    hasSuggestions: true,
     messages: {
-      forbidden: "The toPromise method is forbidden."
+      forbidden: "The toPromise method is forbidden.",
+      suggestLastValueFrom: "Use lastValueFrom instead.",
+      suggestFirstValueFrom: "Use firstValueFrom instead."
     },
     schema: [],
     type: "problem"
@@ -2303,14 +2349,74 @@ var noTopromiseRule = ruleCreator({
   name: "no-topromise",
   create: (context) => {
     const { couldBeObservable } = getTypeServices(context);
+    function getQuote(raw) {
+      const match = /^\s*('|")/.exec(raw);
+      if (!match) {
+        return void 0;
+      }
+      const [, quote] = match;
+      return quote;
+    }
+    function createFix(conversion, callExpression, observableNode, importDeclarations) {
+      return function* fix(fixer) {
+        var _a, _b, _c;
+        let namespace = "";
+        let functionName = conversion;
+        const rxjsImportDeclaration = importDeclarations.find((node) => node.source.value === "rxjs");
+        if ((_a = rxjsImportDeclaration == null ? void 0 : rxjsImportDeclaration.specifiers) == null ? void 0 : _a.every(isImportNamespaceSpecifier)) {
+          namespace = rxjsImportDeclaration.specifiers[0].local.name + ".";
+        } else if ((_b = rxjsImportDeclaration == null ? void 0 : rxjsImportDeclaration.specifiers) == null ? void 0 : _b.every(isImportSpecifier)) {
+          const { specifiers } = rxjsImportDeclaration;
+          const existingSpecifier = specifiers.find((node) => (isIdentifier(node.imported) ? node.imported.name : node.imported.value) === functionName);
+          if (existingSpecifier) {
+            functionName = existingSpecifier.local.name;
+          } else {
+            const lastSpecifier = specifiers[specifiers.length - 1];
+            yield fixer.insertTextAfter(lastSpecifier, `, ${functionName}`);
+          }
+        } else if (importDeclarations.length) {
+          const lastImport = importDeclarations[importDeclarations.length - 1];
+          const quote = (_c = getQuote(lastImport.source.raw)) != null ? _c : '"';
+          yield fixer.insertTextAfter(
+            importDeclarations[importDeclarations.length - 1],
+            `
+import { ${functionName} } from ${quote}rxjs${quote};`
+          );
+        } else {
+          console.warn("No import declarations found. Unable to suggest a fix.");
+          return;
+        }
+        yield fixer.replaceText(
+          callExpression,
+          `${namespace}${functionName}(${context.sourceCode.getText(observableNode)})`
+        );
+      };
+    }
     return {
-      [`MemberExpression[property.name="toPromise"]`]: (node) => {
-        if (couldBeObservable(node.object)) {
-          context.report({
-            messageId: "forbidden",
-            node: node.property
-          });
+      [`CallExpression[callee.property.name="toPromise"]`]: (node) => {
+        const memberExpression = node.callee;
+        if (!couldBeObservable(memberExpression.object)) {
+          return;
+        }
+        const { body } = context.sourceCode.ast;
+        const importDeclarations = body.filter(isImportDeclaration);
+        if (!importDeclarations.length) {
+          return;
         }
+        context.report({
+          messageId: "forbidden",
+          node: memberExpression.property,
+          suggest: [
+            {
+              messageId: "suggestLastValueFrom",
+              fix: createFix("lastValueFrom", node, memberExpression.object, importDeclarations)
+            },
+            {
+              messageId: "suggestFirstValueFrom",
+              fix: createFix("firstValueFrom", node, memberExpression.object, importDeclarations)
+            }
+          ]
+        });
       }
     };
   }
@@ -2894,6 +3000,142 @@ function isValidArgText(argText) {
   return argText && argText !== "undefined" && argText !== "null";
 }
 
+// src/rules/prefer-root-operators.ts
+var RENAMED_OPERATORS = {
+  combineLatest: "combineLatestWith",
+  concat: "concatWith",
+  merge: "mergeWith",
+  onErrorResumeNext: "onErrorResumeNextWith",
+  race: "raceWith",
+  zip: "zipWith"
+};
+var DEPRECATED_OPERATORS = [
+  "partition"
+];
+var preferRootOperatorsRule = ruleCreator({
+  defaultOptions: [],
+  meta: {
+    docs: {
+      description: "Disallow importing operators from `rxjs/operators`."
+    },
+    fixable: "code",
+    hasSuggestions: true,
+    messages: {
+      forbidden: "RxJS imports from `rxjs/operators` are forbidden; import from `rxjs` instead.",
+      forbiddenWithoutFix: "RxJS imports from `rxjs/operators` are forbidden; import from `rxjs` instead. Note some operators may have been renamed or deprecated.",
+      suggest: "Replace with import from `rxjs`."
+    },
+    schema: [],
+    type: "suggestion"
+  },
+  name: "prefer-root-operators",
+  create: (context) => {
+    function getQuote(raw) {
+      const match = /^\s*('|")/.exec(raw);
+      if (!match) {
+        return void 0;
+      }
+      const [, quote] = match;
+      return quote;
+    }
+    function getSourceReplacement(rawLocation) {
+      const quote = getQuote(rawLocation);
+      if (!quote) {
+        return void 0;
+      }
+      if (/^['"]rxjs\/operators/.test(rawLocation)) {
+        return `${quote}rxjs${quote}`;
+      }
+      return void 0;
+    }
+    function hasDeprecatedOperators(specifiers) {
+      return !!(specifiers == null ? void 0 : specifiers.some((s) => DEPRECATED_OPERATORS.includes(getName(getOperatorNode(s)))));
+    }
+    function getName(node) {
+      return isIdentifier(node) ? node.name : node.value;
+    }
+    function getOperatorNode(node) {
+      return isImportSpecifier(node) ? node.imported : node.local;
+    }
+    function getAliasNode(node) {
+      return isImportSpecifier(node) ? node.local : node.exported;
+    }
+    function getOperatorReplacement(name2) {
+      return RENAMED_OPERATORS[name2];
+    }
+    function isNodesEqual(a, b) {
+      return a.range[0] === b.range[0] && a.range[1] === b.range[1];
+    }
+    function createFix(source, replacement, specifiers) {
+      return function* fix(fixer) {
+        yield fixer.replaceText(source, replacement);
+        for (const specifier of specifiers) {
+          const operatorNode = getOperatorNode(specifier);
+          const operatorName = getName(operatorNode);
+          const operatorReplacement = getOperatorReplacement(operatorName);
+          if (!operatorReplacement) {
+            continue;
+          }
+          const aliasNode = getAliasNode(specifier);
+          if (isNodesEqual(aliasNode, operatorNode)) {
+            yield fixer.insertTextBefore(operatorNode, operatorReplacement + " as ");
+          } else if (isIdentifier(operatorNode)) {
+            yield fixer.replaceText(operatorNode, operatorReplacement);
+          } else {
+            const quote = getQuote(operatorNode.raw);
+            if (!quote) {
+              continue;
+            }
+            yield fixer.replaceText(operatorNode, quote + operatorReplacement + quote);
+          }
+        }
+      };
+    }
+    function reportNode(source, specifiers) {
+      const replacement = getSourceReplacement(source.raw);
+      if (!replacement || hasDeprecatedOperators(specifiers)) {
+        context.report({
+          messageId: "forbiddenWithoutFix",
+          node: source
+        });
+        return;
+      }
+      if (!specifiers) {
+        context.report({
+          messageId: "forbiddenWithoutFix",
+          node: source,
+          suggest: [{ messageId: "suggest", fix: (fixer) => fixer.replaceText(source, replacement) }]
+        });
+        return;
+      }
+      const fix = createFix(source, replacement, specifiers);
+      context.report({
+        fix,
+        messageId: "forbidden",
+        node: source,
+        suggest: [{ messageId: "suggest", fix }]
+      });
+    }
+    return {
+      'ImportDeclaration[source.value="rxjs/operators"]': (node) => {
+        const specifiers = node.specifiers.length && node.specifiers.every((importClause) => isImportSpecifier(importClause)) ? node.specifiers : void 0;
+        reportNode(node.source, specifiers);
+      },
+      'ImportExpression[source.value="rxjs/operators"]': (node) => {
+        if (isLiteral(node.source)) {
+          reportNode(node.source);
+        }
+      },
+      'ExportNamedDeclaration[source.value="rxjs/operators"]': (node) => {
+        reportNode(node.source, node.specifiers);
+      },
+      'ExportAllDeclaration[source.value="rxjs/operators"]': (node) => {
+        reportNode(node.source);
+      }
+    };
+  }
+});
+
 // src/rules/suffix-subjects.ts
 
 var defaultOptions13 = [];
@@ -3211,6 +3453,7 @@ var plugin = {
     "no-unsafe-switchmap": noUnsafeSwitchmapRule,
     "no-unsafe-takeuntil": noUnsafeTakeuntilRule,
     "prefer-observer": preferObserverRule,
+    "prefer-root-operators": preferRootOperatorsRule,
     "suffix-subjects": suffixSubjectsRule,
     "throw-error": throwErrorRule
   }

package/dist/index.mjs

@@ -1,6 +1,6 @@
 // package.json
 var name = "eslint-plugin-rxjs-x";
-var version = "0.3.0";
+var version = "0.3.2";
 
 // src/configs/recommended.ts
 var createRecommendedConfig = (plugin2) => ({
@@ -265,6 +265,15 @@ function isFunctionExpression(node) {
 function isIdentifier(node) {
   return node.type === AST_NODE_TYPES2.Identifier;
 }
+function isImportDeclaration(node) {
+  return node.type === AST_NODE_TYPES2.ImportDeclaration;
+}
+function isImportNamespaceSpecifier(node) {
+  return node.type === AST_NODE_TYPES2.ImportNamespaceSpecifier;
+}
+function isImportSpecifier(node) {
+  return node.type === AST_NODE_TYPES2.ImportSpecifier;
+}
 function isLiteral(node) {
   return node.type === AST_NODE_TYPES2.Literal;
 }
@@ -814,6 +823,7 @@ var noAsyncSubscribeRule = ruleCreator({
 var noCompatRule = ruleCreator({
   defaultOptions: [],
   meta: {
+    deprecated: true,
     docs: {
       description: "Disallow the `rxjs-compat` package."
     },
@@ -1370,6 +1380,7 @@ var noIgnoredDefaultValueRule = ruleCreator({
 });
 
 // src/rules/no-ignored-error.ts
+import { ESLintUtils as ESLintUtils7 } from "@typescript-eslint/utils";
 var noIgnoredErrorRule = ruleCreator({
   defaultOptions: [],
   meta: {
@@ -1385,12 +1396,44 @@ var noIgnoredErrorRule = ruleCreator({
   },
   name: "no-ignored-error",
   create: (context) => {
+    const { getTypeAtLocation } = ESLintUtils7.getParserServices(context);
     const { couldBeObservable, couldBeFunction: couldBeFunction2 } = getTypeServices(context);
+    function isMissingErrorCallback(callExpression) {
+      if (callExpression.arguments.length >= 2) {
+        return false;
+      }
+      return couldBeFunction2(callExpression.arguments[0]);
+    }
+    function isObjMissingError(arg) {
+      return !arg.properties.some(
+        (property) => isProperty(property) && isIdentifier(property.key) && property.key.name === "error"
+      );
+    }
+    function isTypeMissingError(arg) {
+      const argType = getTypeAtLocation(arg);
+      return !(argType == null ? void 0 : argType.getProperties().some((p) => p.name === "error"));
+    }
+    function isMissingErrorProperty(callExpression) {
+      if (callExpression.arguments.length !== 1) {
+        return false;
+      }
+      const [arg] = callExpression.arguments;
+      if (isObjectExpression(arg)) {
+        return isObjMissingError(arg);
+      }
+      if (isIdentifier(arg)) {
+        return isTypeMissingError(arg);
+      }
+      if (isMemberExpression(arg) && isIdentifier(arg.property)) {
+        return isTypeMissingError(arg.property);
+      }
+      return false;
+    }
     return {
       "CallExpression[arguments.length > 0] > MemberExpression > Identifier[name='subscribe']": (node) => {
         const memberExpression = node.parent;
         const callExpression = memberExpression.parent;
-        if (callExpression.arguments.length < 2 && couldBeObservable(memberExpression.object) && couldBeFunction2(callExpression.arguments[0])) {
+        if ((isMissingErrorCallback(callExpression) || isMissingErrorProperty(callExpression)) && couldBeObservable(memberExpression.object)) {
           context.report({
             messageId: "forbidden",
             node
@@ -2294,8 +2337,11 @@ var noTopromiseRule = ruleCreator({
       description: "Disallow use of the `toPromise` method.",
       requiresTypeChecking: true
     },
+    hasSuggestions: true,
     messages: {
-      forbidden: "The toPromise method is forbidden."
+      forbidden: "The toPromise method is forbidden.",
+      suggestLastValueFrom: "Use lastValueFrom instead.",
+      suggestFirstValueFrom: "Use firstValueFrom instead."
     },
     schema: [],
     type: "problem"
@@ -2303,21 +2349,81 @@ var noTopromiseRule = ruleCreator({
   name: "no-topromise",
   create: (context) => {
     const { couldBeObservable } = getTypeServices(context);
+    function getQuote(raw) {
+      const match = /^\s*('|")/.exec(raw);
+      if (!match) {
+        return void 0;
+      }
+      const [, quote] = match;
+      return quote;
+    }
+    function createFix(conversion, callExpression, observableNode, importDeclarations) {
+      return function* fix(fixer) {
+        var _a, _b, _c;
+        let namespace = "";
+        let functionName = conversion;
+        const rxjsImportDeclaration = importDeclarations.find((node) => node.source.value === "rxjs");
+        if ((_a = rxjsImportDeclaration == null ? void 0 : rxjsImportDeclaration.specifiers) == null ? void 0 : _a.every(isImportNamespaceSpecifier)) {
+          namespace = rxjsImportDeclaration.specifiers[0].local.name + ".";
+        } else if ((_b = rxjsImportDeclaration == null ? void 0 : rxjsImportDeclaration.specifiers) == null ? void 0 : _b.every(isImportSpecifier)) {
+          const { specifiers } = rxjsImportDeclaration;
+          const existingSpecifier = specifiers.find((node) => (isIdentifier(node.imported) ? node.imported.name : node.imported.value) === functionName);
+          if (existingSpecifier) {
+            functionName = existingSpecifier.local.name;
+          } else {
+            const lastSpecifier = specifiers[specifiers.length - 1];
+            yield fixer.insertTextAfter(lastSpecifier, `, ${functionName}`);
+          }
+        } else if (importDeclarations.length) {
+          const lastImport = importDeclarations[importDeclarations.length - 1];
+          const quote = (_c = getQuote(lastImport.source.raw)) != null ? _c : '"';
+          yield fixer.insertTextAfter(
+            importDeclarations[importDeclarations.length - 1],
+            `
+import { ${functionName} } from ${quote}rxjs${quote};`
+          );
+        } else {
+          console.warn("No import declarations found. Unable to suggest a fix.");
+          return;
+        }
+        yield fixer.replaceText(
+          callExpression,
+          `${namespace}${functionName}(${context.sourceCode.getText(observableNode)})`
+        );
+      };
+    }
     return {
-      [`MemberExpression[property.name="toPromise"]`]: (node) => {
-        if (couldBeObservable(node.object)) {
-          context.report({
-            messageId: "forbidden",
-            node: node.property
-          });
+      [`CallExpression[callee.property.name="toPromise"]`]: (node) => {
+        const memberExpression = node.callee;
+        if (!couldBeObservable(memberExpression.object)) {
+          return;
         }
+        const { body } = context.sourceCode.ast;
+        const importDeclarations = body.filter(isImportDeclaration);
+        if (!importDeclarations.length) {
+          return;
+        }
+        context.report({
+          messageId: "forbidden",
+          node: memberExpression.property,
+          suggest: [
+            {
+              messageId: "suggestLastValueFrom",
+              fix: createFix("lastValueFrom", node, memberExpression.object, importDeclarations)
+            },
+            {
+              messageId: "suggestFirstValueFrom",
+              fix: createFix("firstValueFrom", node, memberExpression.object, importDeclarations)
+            }
+          ]
+        });
       }
     };
   }
 });
 
 // src/rules/no-unbound-methods.ts
-import { ESLintUtils as ESLintUtils7 } from "@typescript-eslint/utils";
+import { ESLintUtils as ESLintUtils8 } from "@typescript-eslint/utils";
 var noUnboundMethodsRule = ruleCreator({
   defaultOptions: [],
   meta: {
@@ -2334,7 +2440,7 @@ var noUnboundMethodsRule = ruleCreator({
   },
   name: "no-unbound-methods",
   create: (context) => {
-    const { getTypeAtLocation } = ESLintUtils7.getParserServices(context);
+    const { getTypeAtLocation } = ESLintUtils8.getParserServices(context);
     const { couldBeObservable, couldBeSubscription } = getTypeServices(context);
     const nodeMap = /* @__PURE__ */ new WeakMap();
     function mapArguments(node) {
@@ -2512,7 +2618,7 @@ var noUnsafeFirstRule = ruleCreator({
 });
 
 // src/rules/no-unsafe-subject-next.ts
-import { ESLintUtils as ESLintUtils8 } from "@typescript-eslint/utils";
+import { ESLintUtils as ESLintUtils9 } from "@typescript-eslint/utils";
 import * as tsutils2 from "ts-api-utils";
 import ts6 from "typescript";
 var noUnsafeSubjectNext = ruleCreator({
@@ -2531,7 +2637,7 @@ var noUnsafeSubjectNext = ruleCreator({
   },
   name: "no-unsafe-subject-next",
   create: (context) => {
-    const { getTypeAtLocation, program } = ESLintUtils8.getParserServices(context);
+    const { getTypeAtLocation, program } = ESLintUtils9.getParserServices(context);
     const typeChecker = program.getTypeChecker();
     return {
       [`CallExpression[callee.property.name='next']`]: (node) => {
@@ -2894,8 +3000,144 @@ function isValidArgText(argText) {
   return argText && argText !== "undefined" && argText !== "null";
 }
 
+// src/rules/prefer-root-operators.ts
+var RENAMED_OPERATORS = {
+  combineLatest: "combineLatestWith",
+  concat: "concatWith",
+  merge: "mergeWith",
+  onErrorResumeNext: "onErrorResumeNextWith",
+  race: "raceWith",
+  zip: "zipWith"
+};
+var DEPRECATED_OPERATORS = [
+  "partition"
+];
+var preferRootOperatorsRule = ruleCreator({
+  defaultOptions: [],
+  meta: {
+    docs: {
+      description: "Disallow importing operators from `rxjs/operators`."
+    },
+    fixable: "code",
+    hasSuggestions: true,
+    messages: {
+      forbidden: "RxJS imports from `rxjs/operators` are forbidden; import from `rxjs` instead.",
+      forbiddenWithoutFix: "RxJS imports from `rxjs/operators` are forbidden; import from `rxjs` instead. Note some operators may have been renamed or deprecated.",
+      suggest: "Replace with import from `rxjs`."
+    },
+    schema: [],
+    type: "suggestion"
+  },
+  name: "prefer-root-operators",
+  create: (context) => {
+    function getQuote(raw) {
+      const match = /^\s*('|")/.exec(raw);
+      if (!match) {
+        return void 0;
+      }
+      const [, quote] = match;
+      return quote;
+    }
+    function getSourceReplacement(rawLocation) {
+      const quote = getQuote(rawLocation);
+      if (!quote) {
+        return void 0;
+      }
+      if (/^['"]rxjs\/operators/.test(rawLocation)) {
+        return `${quote}rxjs${quote}`;
+      }
+      return void 0;
+    }
+    function hasDeprecatedOperators(specifiers) {
+      return !!(specifiers == null ? void 0 : specifiers.some((s) => DEPRECATED_OPERATORS.includes(getName(getOperatorNode(s)))));
+    }
+    function getName(node) {
+      return isIdentifier(node) ? node.name : node.value;
+    }
+    function getOperatorNode(node) {
+      return isImportSpecifier(node) ? node.imported : node.local;
+    }
+    function getAliasNode(node) {
+      return isImportSpecifier(node) ? node.local : node.exported;
+    }
+    function getOperatorReplacement(name2) {
+      return RENAMED_OPERATORS[name2];
+    }
+    function isNodesEqual(a, b) {
+      return a.range[0] === b.range[0] && a.range[1] === b.range[1];
+    }
+    function createFix(source, replacement, specifiers) {
+      return function* fix(fixer) {
+        yield fixer.replaceText(source, replacement);
+        for (const specifier of specifiers) {
+          const operatorNode = getOperatorNode(specifier);
+          const operatorName = getName(operatorNode);
+          const operatorReplacement = getOperatorReplacement(operatorName);
+          if (!operatorReplacement) {
+            continue;
+          }
+          const aliasNode = getAliasNode(specifier);
+          if (isNodesEqual(aliasNode, operatorNode)) {
+            yield fixer.insertTextBefore(operatorNode, operatorReplacement + " as ");
+          } else if (isIdentifier(operatorNode)) {
+            yield fixer.replaceText(operatorNode, operatorReplacement);
+          } else {
+            const quote = getQuote(operatorNode.raw);
+            if (!quote) {
+              continue;
+            }
+            yield fixer.replaceText(operatorNode, quote + operatorReplacement + quote);
+          }
+        }
+      };
+    }
+    function reportNode(source, specifiers) {
+      const replacement = getSourceReplacement(source.raw);
+      if (!replacement || hasDeprecatedOperators(specifiers)) {
+        context.report({
+          messageId: "forbiddenWithoutFix",
+          node: source
+        });
+        return;
+      }
+      if (!specifiers) {
+        context.report({
+          messageId: "forbiddenWithoutFix",
+          node: source,
+          suggest: [{ messageId: "suggest", fix: (fixer) => fixer.replaceText(source, replacement) }]
+        });
+        return;
+      }
+      const fix = createFix(source, replacement, specifiers);
+      context.report({
+        fix,
+        messageId: "forbidden",
+        node: source,
+        suggest: [{ messageId: "suggest", fix }]
+      });
+    }
+    return {
+      'ImportDeclaration[source.value="rxjs/operators"]': (node) => {
+        const specifiers = node.specifiers.length && node.specifiers.every((importClause) => isImportSpecifier(importClause)) ? node.specifiers : void 0;
+        reportNode(node.source, specifiers);
+      },
+      'ImportExpression[source.value="rxjs/operators"]': (node) => {
+        if (isLiteral(node.source)) {
+          reportNode(node.source);
+        }
+      },
+      'ExportNamedDeclaration[source.value="rxjs/operators"]': (node) => {
+        reportNode(node.source, node.specifiers);
+      },
+      'ExportAllDeclaration[source.value="rxjs/operators"]': (node) => {
+        reportNode(node.source);
+      }
+    };
+  }
+});
+
 // src/rules/suffix-subjects.ts
-import { AST_NODE_TYPES as AST_NODE_TYPES7, ESLintUtils as ESLintUtils9 } from "@typescript-eslint/utils";
+import { AST_NODE_TYPES as AST_NODE_TYPES7, ESLintUtils as ESLintUtils10 } from "@typescript-eslint/utils";
 var defaultOptions13 = [];
 var suffixSubjectsRule = ruleCreator({
   defaultOptions: defaultOptions13,
@@ -2923,7 +3165,7 @@ var suffixSubjectsRule = ruleCreator({
   },
   name: "suffix-subjects",
   create: (context) => {
-    const { esTreeNodeToTSNodeMap } = ESLintUtils9.getParserServices(context);
+    const { esTreeNodeToTSNodeMap } = ESLintUtils10.getParserServices(context);
     const { couldBeType: couldBeType2 } = getTypeServices(context);
     const [config = {}] = context.options;
     const validate = {
@@ -3093,7 +3335,7 @@ var suffixSubjectsRule = ruleCreator({
 });
 
 // src/rules/throw-error.ts
-import { ESLintUtils as ESLintUtils10 } from "@typescript-eslint/utils";
+import { ESLintUtils as ESLintUtils11 } from "@typescript-eslint/utils";
 import * as tsutils3 from "ts-api-utils";
 var defaultOptions14 = [];
 var throwErrorRule = ruleCreator({
@@ -3119,7 +3361,7 @@ var throwErrorRule = ruleCreator({
   },
   name: "throw-error",
   create: (context) => {
-    const { esTreeNodeToTSNodeMap, program, getTypeAtLocation } = ESLintUtils10.getParserServices(context);
+    const { esTreeNodeToTSNodeMap, program, getTypeAtLocation } = ESLintUtils11.getParserServices(context);
     const { couldBeObservable } = getTypeServices(context);
     const [config = {}] = context.options;
     const { allowThrowingAny = true, allowThrowingUnknown = true } = config;
@@ -3211,6 +3453,7 @@ var plugin = {
     "no-unsafe-switchmap": noUnsafeSwitchmapRule,
     "no-unsafe-takeuntil": noUnsafeTakeuntilRule,
     "prefer-observer": preferObserverRule,
+    "prefer-root-operators": preferRootOperatorsRule,
     "suffix-subjects": suffixSubjectsRule,
     "throw-error": throwErrorRule
   }

package/docs/rules/no-async-subscribe.md

@@ -7,6 +7,9 @@
 <!-- end auto-generated rule header -->
 
 This rule effects failures if async functions are passed to `subscribe`.
+Developers are encouraged to avoid race conditions
+by instead using RxJS operators which can handle both Promises and Observables
+(e.g. `concatMap`, `switchMap`, `mergeMap`, `exhaustMap`).
 
 ## Rule details
 
@@ -14,16 +17,26 @@ Examples of **incorrect** code for this rule:
 
 ```ts
 import { of } from "rxjs";
-of(42).subscribe(async () => console.log(value));
+
+of(42).subscribe(async value => {
+    const data1 = await fetch(`https://api.some.com/things/${value}`);
+    const data2 = await fetch(`https://api.some.com/things/${data1.id}`);
+    console.log(data2);
+});
 ```
 
 Examples of **correct** code for this rule:
 
 ```ts
 import { of } from "rxjs";
-of(42).subscribe(() => console.log(value));
+
+of(42).pipe(
+    switchMap(value => fetch(`http://api.some.com/things/${value}`)),
+    switchMap(data1 => fetch(`http://api.some.com/things/${data1.id}`)),
+).subscribe(data2 => console.log(data2));
 ```
 
 ## Further reading
 
 - [Why does this rule exist?](https://stackoverflow.com/q/71559135)
+- [Higher-order Observables](https://rxjs.dev/guide/higher-order-observables)

package/docs/rules/no-compat.md

@@ -1,9 +1,13 @@
 # Disallow the `rxjs-compat` package (`rxjs-x/no-compat`)
 
+❌ This rule is deprecated.
+
 <!-- end auto-generated rule header -->
 
 This rule prevents importing from locations that depend upon the `rxjs-compat` package.
 
+This rule is deprecated because RxJS v7+ no longer includes `rxjs-compat`.
+
 ## Further reading
 
 - [Backwards compatibility](https://github.com/ReactiveX/rxjs/blob/a6590e971969c736a15b77154dabbc22275aa0d5/docs_app/content/guide/v6/migration.md#backwards-compatibility)

package/docs/rules/no-topromise.md

@@ -1,7 +1,13 @@
 # Disallow use of the `toPromise` method (`rxjs-x/no-topromise`)
 
+💡 This rule is manually fixable by [editor suggestions](https://eslint.org/docs/latest/use/core-concepts#rule-suggestions).
+
 💭 This rule requires [type information](https://typescript-eslint.io/linting/typed-linting).
 
 <!-- end auto-generated rule header -->
 
 This rule effects failures if the `toPromise` method is used.
+
+## Further reading
+
+- [Conversion to Promises](https://rxjs.dev/deprecations/to-promise)

package/docs/rules/prefer-root-operators.md

@@ -0,0 +1,32 @@
+# Disallow importing operators from `rxjs/operators` (`rxjs-x/prefer-root-operators`)
+
+🔧💡 This rule is automatically fixable by the [`--fix` CLI option](https://eslint.org/docs/latest/user-guide/command-line-interface#--fix) and manually fixable by [editor suggestions](https://eslint.org/docs/latest/use/core-concepts#rule-suggestions).
+
+<!-- end auto-generated rule header -->
+
+This rule prevents importing from the `rxjs/operators` export site.
+Most operators were moved to the `rxjs` export site in RxJS v7.2.0
+(excepting a few old and deprecated operators).
+The `rxjs/operators` export site has since been deprecated and will be removed in a future major version.
+
+Note that because a few operators were renamed or not migrated to the `rxjs` export site,
+this rule may not provide an automatic fixer if renaming the import path is not guaranteed to be safe.
+See the documentation linked below.
+
+## Rule details
+
+Examples of **incorrect** code for this rule:
+
+```ts
+import { map } from 'rxjs/operators';
+```
+
+Examples of **correct** code for this rule:
+
+```ts
+import { map } from 'rxjs';
+```
+
+## Further reading
+
+- [Importing instructions](https://rxjs.dev/guide/importing)

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "eslint-plugin-rxjs-x",
   "type": "commonjs",
-  "version": "0.3.0",
+  "version": "0.3.2",
   "packageManager": "yarn@4.5.1+sha512.341db9396b6e289fecc30cd7ab3af65060e05ebff4b3b47547b278b9e67b08f485ecd8c79006b405446262142c7a38154445ef7f17c1d5d1de7d90bf9ce7054d",
   "description": "ESLint v9+ plugin for RxJS",
   "author": "Jason Weinzierl <weinzierljason@gmail.com>",
@@ -84,13 +84,12 @@
     "eslint-config-flat-gitignore": "^0.3.0",
     "eslint-doc-generator": "^1.7.1",
     "eslint-import-resolver-typescript": "^3.6.3",
-    "eslint-plugin-eslint-plugin": "^6.3.1",
+    "eslint-plugin-eslint-plugin": "^6.3.2",
     "eslint-plugin-import-x": "^4.4.2",
-    "eslint-plugin-n": "^17.13.1",
+    "eslint-plugin-n": "^17.13.2",
     "markdownlint-cli2": "^0.15.0",
     "rxjs": "^7.8.1",
     "tsup": "^8.3.5",
-    "tsx": "^4.19.2",
     "typescript": "~5.6.3",
     "typescript-eslint": "^8.14.0",
     "vitest": "^2.1.5"