eslint-plugin-rxjs-x 0.6.0 → 0.6.2

package/LICENSE

@@ -1,6 +1,7 @@
 MIT License
 
-Copyright (c) 2019 Nicholas Jamieson and contributors, 2024-PRESENT Jason Weinzierl <https://github.com/JasonWeinzierl>
+Copyright (c) 2019 Nicholas Jamieson and contributors
+Copyright (c) 2024-2025 Jason Weinzierl and contributors
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

package/README.md

@@ -86,7 +86,7 @@ The package includes the following rules.
 | [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.                                                             |      |    |    | 💭 |    |
-| [no-explicit-generics](docs/rules/no-explicit-generics.md)             | Disallow unnecessary explicit generic type arguments.                                                     | 🔒   |    |    |    |    |
+| [no-explicit-generics](docs/rules/no-explicit-generics.md)             | Disallow unnecessary explicit generic type arguments.                                                     |      |    |    |    |    |
 | [no-exposed-subjects](docs/rules/no-exposed-subjects.md)               | Disallow public and protected subjects.                                                                   | 🔒   |    |    | 💭 |    |
 | [no-finnish](docs/rules/no-finnish.md)                                 | Disallow Finnish notation.                                                                                |      |    |    | 💭 |    |
 | [no-floating-observables](docs/rules/no-floating-observables.md)       | Require Observables to be handled appropriately.                                                          | 🔒   |    |    | 💭 |    |

package/dist/index.d.mts

@@ -53,7 +53,6 @@ declare const rxjsX: {
             rules: {
                 'rxjs-x/no-async-subscribe': "error";
                 'rxjs-x/no-create': "error";
-                'rxjs-x/no-explicit-generics': "error";
                 'rxjs-x/no-exposed-subjects': "error";
                 'rxjs-x/no-floating-observables': "error";
                 'rxjs-x/no-ignored-default-value': "error";

package/dist/index.d.ts

@@ -53,7 +53,6 @@ declare const rxjsX: {
             rules: {
                 'rxjs-x/no-async-subscribe': "error";
                 'rxjs-x/no-create': "error";
-                'rxjs-x/no-explicit-generics': "error";
                 'rxjs-x/no-exposed-subjects': "error";
                 'rxjs-x/no-floating-observables': "error";
                 'rxjs-x/no-ignored-default-value': "error";

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.6.0";
+var version = "0.6.2";
 
 // src/configs/recommended.ts
 var createRecommendedConfig = (plugin2) => ({
@@ -41,7 +41,6 @@ var createStrictConfig = (plugin2) => ({
   rules: {
     "rxjs-x/no-async-subscribe": "error",
     "rxjs-x/no-create": "error",
-    "rxjs-x/no-explicit-generics": "error",
     "rxjs-x/no-exposed-subjects": "error",
     "rxjs-x/no-floating-observables": "error",
     "rxjs-x/no-ignored-default-value": "error",
@@ -1096,8 +1095,7 @@ var noExplicitGenericsRule = ruleCreator({
   defaultOptions: [],
   meta: {
     docs: {
-      description: "Disallow unnecessary explicit generic type arguments.",
-      recommended: "strict"
+      description: "Disallow unnecessary explicit generic type arguments."
     },
     messages: {
       forbidden: "Explicit generic type arguments are forbidden."
@@ -2562,7 +2560,7 @@ var noRedundantNotifyRule = ruleCreator({
     const sourceCode = context.sourceCode;
     const { couldBeType: couldBeType2 } = getTypeServices(context);
     return {
-      "ExpressionStatement[expression.callee.property.name=/^(complete|error)$/] + ExpressionStatement[expression.callee.property.name=/^(next|complete|error)$/]": (node) => {
+      "ExpressionStatement[expression.callee.property.name=/^(complete|error|unsubscribe)$/] + ExpressionStatement[expression.callee.property.name=/^(next|complete|error|unsubscribe)$/]": (node) => {
         const parent = node.parent;
         if (!parent) {
           return;

package/dist/index.mjs

@@ -1,6 +1,6 @@
 // package.json
 var name = "eslint-plugin-rxjs-x";
-var version = "0.6.0";
+var version = "0.6.2";
 
 // src/configs/recommended.ts
 var createRecommendedConfig = (plugin2) => ({
@@ -41,7 +41,6 @@ var createStrictConfig = (plugin2) => ({
   rules: {
     "rxjs-x/no-async-subscribe": "error",
     "rxjs-x/no-create": "error",
-    "rxjs-x/no-explicit-generics": "error",
     "rxjs-x/no-exposed-subjects": "error",
     "rxjs-x/no-floating-observables": "error",
     "rxjs-x/no-ignored-default-value": "error",
@@ -1096,8 +1095,7 @@ var noExplicitGenericsRule = ruleCreator({
   defaultOptions: [],
   meta: {
     docs: {
-      description: "Disallow unnecessary explicit generic type arguments.",
-      recommended: "strict"
+      description: "Disallow unnecessary explicit generic type arguments."
     },
     messages: {
       forbidden: "Explicit generic type arguments are forbidden."
@@ -2562,7 +2560,7 @@ var noRedundantNotifyRule = ruleCreator({
     const sourceCode = context.sourceCode;
     const { couldBeType: couldBeType2 } = getTypeServices(context);
     return {
-      "ExpressionStatement[expression.callee.property.name=/^(complete|error)$/] + ExpressionStatement[expression.callee.property.name=/^(next|complete|error)$/]": (node) => {
+      "ExpressionStatement[expression.callee.property.name=/^(complete|error|unsubscribe)$/] + ExpressionStatement[expression.callee.property.name=/^(next|complete|error|unsubscribe)$/]": (node) => {
         const parent = node.parent;
         if (!parent) {
           return;

package/docs/rules/ban-observables.md

@@ -2,11 +2,16 @@
 
 <!-- end auto-generated rule header -->
 
-This rule can be configured so that developers can ban any observable creators they want to avoid in their project.
+It can sometimes be useful to ban specific `rxjs` imports.
+This rule can be configured to ban a list of specific `rxjs` imports developers want to avoid in their project.
+
+> [!TIP]
+> `ban-observables` only bans at the _import_ site. (In fact, it can ban anything imported from `rxjs`.)
+> See [`ban-operators`](./ban-operators.md) for banning operators at their _usage_.
 
 ## Options
 
-This rule accepts a single option which is an object the keys of which are the names of observable factory functions and the values are either booleans or strings containing the explanation for the ban.
+This rule accepts a single option which is an object the keys of which are the names of anything in `rxjs` and the values are either booleans or strings containing the explanation for the ban.
 
 The following configuration bans `partition` and `onErrorResumeNext`:
 
@@ -22,3 +27,16 @@ The following configuration bans `partition` and `onErrorResumeNext`:
   ]
 }
 ```
+
+## When Not To Use It
+
+If you have no need to ban importing anything from `rxjs`, you don't need this rule.
+
+## Related To
+
+- [`ban-operators`](./ban-operators.md)
+
+## Resources
+
+- [Rule source](https://github.com/JasonWeinzierl/eslint-plugin-rxjs-x/blob/main/src/rules/ban-observables.ts)
+- [Test source](https://github.com/JasonWeinzierl/eslint-plugin-rxjs-x/blob/main/tests/rules/ban-observables.test.ts)

package/docs/rules/ban-operators.md

@@ -4,7 +4,10 @@
 
 <!-- end auto-generated rule header -->
 
-This rule can be configured so that developers can ban any operators they want to avoid in their project.
+This rule can be configured so that developers can ban `rxjs` operators they want to avoid in their project.
+
+> [!NOTE]
+> Operators outside of a `pipe` or not directly exported by `rxjs` are ignored.
 
 ## Options
 
@@ -23,3 +26,19 @@ The following configuration bans `partition` and `onErrorResumeNext`:
     }
   ]
 }
+```
+
+## When Not To Use It
+
+If you have no need to ban `rxjs` operators, you don't need this rule.
+
+Type checked lint rules are more powerful than traditional lint rules, but also require configuring type checked linting.
+
+## Related To
+
+- [`ban-observables`](./ban-observables.md)
+
+## Resources
+
+- [Rule source](https://github.com/JasonWeinzierl/eslint-plugin-rxjs-x/blob/main/src/rules/ban-operators.ts)
+- [Test source](https://github.com/JasonWeinzierl/eslint-plugin-rxjs-x/blob/main/tests/rules/ban-operators.test.ts)

package/docs/rules/finnish.md

@@ -68,6 +68,24 @@ The default (Angular-friendly) configuration looks like this:
 
 The properties in the options object are themselves optional; they do not all have to be specified.
 
+## When Not To Use It
+
+If you don't use Finnish notation in your project or don't care about enforcing Finnish notation in your project, you don't need this rule.
+However, keep in mind that inconsistent style can harm readability in a project;
+consider using [`no-finnish`](./no-finnish.md) to ban Finnish notation if you don't use it in your project.
+
+Type checked lint rules are more powerful than traditional lint rules, but also require configuring type checked linting.
+
 ## Further reading
 
 - [Observables and Finnish Notation](https://medium.com/@benlesh/observables-and-finnish-notation-df8356ed1c9b)
+
+## Related To
+
+- [`no-finnish`](./no-finnish.md)
+- [`suffix-subjects`](./suffix-subjects.md)
+
+## Resources
+
+- [Rule source](https://github.com/JasonWeinzierl/eslint-plugin-rxjs-x/blob/main/src/rules/finnish.ts)
+- [Test source](https://github.com/JasonWeinzierl/eslint-plugin-rxjs-x/blob/main/tests/rules/finnish.test.ts)

package/docs/rules/just.md

@@ -6,6 +6,15 @@
 
 This rule enforces the use of `just` instead of `of`. Some other languages with Rx implementations use the former and this rule is for developers who have that preference.
 
+## When Not To Use It
+
+If you prefer `of` in your project, you will want to avoid this rule.
+
 ## Further reading
 
 - [Rename `of` to `just`](https://github.com/ReactiveX/rxjs/issues/3747)
+
+## Resources
+
+- [Rule source](https://github.com/JasonWeinzierl/eslint-plugin-rxjs-x/blob/main/src/rules/just.ts)
+- [Test source](https://github.com/JasonWeinzierl/eslint-plugin-rxjs-x/blob/main/tests/rules/just.test.ts)

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

@@ -36,7 +36,19 @@ of(42).pipe(
 ).subscribe(data2 => console.log(data2));
 ```
 
+## When Not To Use It
+
+If you don't care about avoiding `.subscribe(async...`, then you will not need this rule.
+However, keep in mind that features of observables like cancellation or retrying will not work, and race conditions may occur.
+
+Type checked lint rules are more powerful than traditional lint rules, but also require configuring type checked linting.
+
 ## Further reading
 
 - [Why does this rule exist?](https://stackoverflow.com/q/71559135)
 - [Higher-order Observables](https://rxjs.dev/guide/higher-order-observables)
+
+## Resources
+
+- [Rule source](https://github.com/JasonWeinzierl/eslint-plugin-rxjs-x/blob/main/src/rules/no-async-subscribe.ts)
+- [Test source](https://github.com/JasonWeinzierl/eslint-plugin-rxjs-x/blob/main/tests/rules/no-async-subscribe.test.ts)

package/docs/rules/no-connectable.md

@@ -4,4 +4,30 @@
 
 <!-- end auto-generated rule header -->
 
-This rule prevents the use of connectable observables.
+This rule prevents the use of operators that return connectable observables.
+
+> [!NOTE]
+> All operators banned by this rule are also deprecated by RxJS,
+> so this rule may be removed in a future major version.
+
+## Rule details
+
+Examples of **incorrect** code for this rule:
+
+```ts
+import { of, publish } from "rxjs";
+
+const result = of(42).pipe(publish());
+```
+
+## When Not To Use It
+
+If you use operators that return connectable observables in your project, you may not need this rule.
+Or you may rely on RxJS's deprecation of those operators and don't need to double-flag the operators as banned.
+
+Type checked lint rules are more powerful than traditional lint rules, but also require configuring type checked linting.
+
+## Resources
+
+- [Rule source](https://github.com/JasonWeinzierl/eslint-plugin-rxjs-x/blob/main/src/rules/no-connectable.ts)
+- [Test source](https://github.com/JasonWeinzierl/eslint-plugin-rxjs-x/blob/main/tests/rules/no-connectable.test.ts)

package/docs/rules/no-create.md

@@ -29,3 +29,15 @@ const answers = new Observable<number>(subscriber => {
   subscriber.complete();
 });
 ```
+
+## When Not To Use It
+
+If you rely on RxJS's deprecation of `Observable.create` and don't need to double-flag usage,
+then you don't need this rule.
+
+Type checked lint rules are more powerful than traditional lint rules, but also require configuring type checked linting.
+
+## Resources
+
+- [Rule source](https://github.com/JasonWeinzierl/eslint-plugin-rxjs-x/blob/main/src/rules/no-create.ts)
+- [Test source](https://github.com/JasonWeinzierl/eslint-plugin-rxjs-x/blob/main/tests/rules/no-create.test.ts)

package/docs/rules/no-cyclic-action.md

@@ -72,3 +72,17 @@ This rule accepts a single option which is an object with an `observable` proper
   ]
 }
 ```
+
+## When Not To Use It
+
+If you don't use a library with effects and epics (e.g. NgRx or redux-observable),
+then you don't need this rule.
+Alternatively, if you use NgRx's own [`avoid-cyclic-effects`](https://ngrx.io/guide/eslint-plugin/rules/avoid-cyclic-effects) rule,
+then you don't need this rule.
+
+Type checked lint rules are more powerful than traditional lint rules, but also require configuring type checked linting.
+
+## Resources
+
+- [Rule source](https://github.com/JasonWeinzierl/eslint-plugin-rxjs-x/blob/main/src/rules/no-cyclic-action.ts)
+- [Test source](https://github.com/JasonWeinzierl/eslint-plugin-rxjs-x/blob/main/tests/rules/no-cyclic-action.test.ts)

package/docs/rules/no-explicit-generics.md

@@ -1,7 +1,5 @@
 # Disallow unnecessary explicit generic type arguments (`rxjs-x/no-explicit-generics`)
 
-💼 This rule is enabled in the 🔒 `strict` config.
-
 <!-- end auto-generated rule header -->
 
 This rule prevents the use of explicit type arguments when the type arguments can be inferred.
@@ -21,3 +19,14 @@ Examples of **correct** code for this rule:
 import { BehaviorSubject } from "rxjs";
 const subject = new BehaviorSubject(42);
 ```
+
+## When Not To Use It
+
+This rule has known problems in the latest release:
+
+- ([#77](https://github.com/JasonWeinzierl/eslint-plugin-rxjs-x/issues/77)) Type unions cause false positives e.g. `new BehaviorSubject<number | null>(null)` will be incorrectly caught by this rule.
+
+## Resources
+
+- [Rule source](https://github.com/JasonWeinzierl/eslint-plugin-rxjs-x/blob/main/src/rules/no-explicit-generics.ts)
+- [Test source](https://github.com/JasonWeinzierl/eslint-plugin-rxjs-x/blob/main/tests/rules/no-explicit-generics.test.ts)

package/docs/rules/no-exposed-subjects.md

@@ -23,10 +23,13 @@ Examples of **correct** code for this rule:
 
 ```ts
 import { Subject } from "rxjs";
+
 class Answers {
-  private _answers: Subject<string>;
-  get answers() {
-    return this._answers.asObservable();
+  private answersSubject$ = new Subject<string>();
+  public answers$ = this.answersSubject$.asObservable();
+
+  public nextAnswer(a: string) {
+    this.answersSubject$.next(a);
   }
 }
 ```
@@ -51,3 +54,15 @@ This rule accepts a single option which is an object with an `allowProtected` pr
   ]
 }
 ```
+
+## When Not To Use It
+
+If you don't care about encapsulating subjects in your project, then you don't need this rule.
+However, be aware that anyone can call `next()` or `complete()` on the exposed subject, which may cause bugs or less readable code.
+
+Type checked lint rules are more powerful than traditional lint rules, but also require configuring type checked linting.
+
+## Resources
+
+- [Rule source](https://github.com/JasonWeinzierl/eslint-plugin-rxjs-x/blob/main/src/rules/no-exposed-subjects.ts)
+- [Test source](https://github.com/JasonWeinzierl/eslint-plugin-rxjs-x/blob/main/tests/rules/no-exposed-subjects.test.ts)

package/docs/rules/no-finnish.md

@@ -20,6 +20,23 @@ Examples of **correct** code for this rule:
 const answers = of(42, 54);
 ```
 
+## When Not To Use It
+
+If you use Finnish notation in your project, you should avoid this rule.
+Or if you don't care if Finnish notation is used in your project, then you don't need this rule.
+However, keep in mind that inconsistent style can harm readability in a project.
+
+Type checked lint rules are more powerful than traditional lint rules, but also require configuring type checked linting.
+
 ## Further reading
 
 - [Observables and Finnish Notation](https://medium.com/@benlesh/observables-and-finnish-notation-df8356ed1c9b)
+
+## Related To
+
+- [`finnish`](./finnish.md)
+
+## Resources
+
+- [Rule source](https://github.com/JasonWeinzierl/eslint-plugin-rxjs-x/blob/main/src/rules/no-finnish.ts)
+- [Test source](https://github.com/JasonWeinzierl/eslint-plugin-rxjs-x/blob/main/tests/rules/no-finnish.test.ts)

package/docs/rules/no-floating-observables.md

@@ -19,7 +19,7 @@ This rule will report observable-valued statements that are not treated in one o
 
 > [!TIP]
 > `no-floating-observables` only detects apparently unhandled observable _statements_.
-> See [`no-misused-observables`](./no-misused-observables.md) for detecting code that provides observables to _logical_ locations
+> See [`no-misused-observables`](./no-misused-observables.md) for detecting code that provides observables to _logical_ locations.
 
 ## Rule details
 
@@ -46,3 +46,23 @@ const answers = of(42, 54);
 | `ignoreVoid` | Whether to ignore `void` expressions. | Boolean | `true`  |
 
 <!-- end auto-generated rule options list -->
+
+## When Not To Use It
+
+Like `@typescript-eslint/no-floating-promises`,
+this rule can be difficult to enable on large existing projects that set up many floating observables.
+Alternatively, if you're not worried about ignored errors or unhandled cold observables,
+then in some cases it may be safe to not use this rule.
+You might consider using `void`s and/or ESLint disable comments for those specific situations
+instead of completely disabling this rule.
+
+Type checked lint rules are more powerful than traditional lint rules, but also require configuring type checked linting.
+
+## Related To
+
+- [`no-misused-observables`](./no-misused-observables.md)
+
+## Resources
+
+- [Rule source](https://github.com/JasonWeinzierl/eslint-plugin-rxjs-x/blob/main/src/rules/no-floating-observables.ts)
+- [Test source](https://github.com/JasonWeinzierl/eslint-plugin-rxjs-x/blob/main/tests/rules/no-floating-observables.test.ts)

package/docs/rules/no-ignored-default-value.md

@@ -29,3 +29,15 @@ const sub = new Subject();
 const result = firstValueFrom(sub, { defaultValue: null });
 sub.complete();
 ```
+
+## When Not To Use It
+
+If you intentionally want `EmptyError` rejections when the observable completes, then you may not need this rule.
+You might consider using ESLint disable comments for specific situations instead of completely disabling this rule.
+
+Type checked lint rules are more powerful than traditional lint rules, but also require configuring type checked linting.
+
+## Resources
+
+- [Rule source](https://github.com/JasonWeinzierl/eslint-plugin-rxjs-x/blob/main/src/rules/no-ignored-default-value.ts)
+- [Test source](https://github.com/JasonWeinzierl/eslint-plugin-rxjs-x/blob/main/tests/rules/no-ignored-default-value.test.ts)

package/docs/rules/no-ignored-error.md

@@ -37,3 +37,17 @@ source.subscribe({
   error: (error) => console.error(error)
 });
 ```
+
+## When Not To Use It
+
+If you're not worried about ignored errors, then in some cases it may be safe to not use this rule.
+Or if you use operators like `catchError` to handle all errors, then in some cases it may be safe to not use this rule.
+You might consider using ESLint disable comments for those specific situations
+instead of completely disabling this rule.
+
+Type checked lint rules are more powerful than traditional lint rules, but also require configuring type checked linting.
+
+## Resources
+
+- [Rule source](https://github.com/JasonWeinzierl/eslint-plugin-rxjs-x/blob/main/src/rules/no-ignored-error.ts)
+- [Test source](https://github.com/JasonWeinzierl/eslint-plugin-rxjs-x/blob/main/tests/rules/no-ignored-error.test.ts)

package/docs/rules/no-ignored-notifier.md

@@ -8,6 +8,10 @@
 
 This rule effects failures if the notifier passed to a `repeatWhen` or `retryWhen` callback is not used.
 
+> [!NOTE]
+> Both `repeatWhen` and `retryWhen` are deprecated by RxJS,
+> so this rule may be removed in a future major version.
+
 ## Rule details
 
 Examples of **incorrect** code for this rule:
@@ -30,3 +34,14 @@ const repeating = source.pipe(
   repeatWhen(notifications => notifications.pipe(take(3)))
 );
 ```
+
+## When Not To Use It
+
+If you don't use `repeatWhen` or `retryWhen` in your project, then you don't need this rule.
+
+Type checked lint rules are more powerful than traditional lint rules, but also require configuring type checked linting.
+
+## Resources
+
+- [Rule source](https://github.com/JasonWeinzierl/eslint-plugin-rxjs-x/blob/main/src/rules/no-ignored-notifier.ts)
+- [Test source](https://github.com/JasonWeinzierl/eslint-plugin-rxjs-x/blob/main/tests/rules/no-ignored-notifier.test.ts)

package/docs/rules/no-ignored-replay-buffer.md

@@ -36,3 +36,12 @@ const subject = new ReplaySubject<number>(Infinity);
 import { of, shareReplay } from "rxjs";
 of(42).pipe(shareReplay({ refCount: true, bufferSize: 1 }));
 ```
+
+## When Not To Use It
+
+If you don't care about implicitly defaulting to `Infinity` in your replay buffers, then you don't need this rule.
+
+## Resources
+
+- [Rule source](https://github.com/JasonWeinzierl/eslint-plugin-rxjs-x/blob/main/src/rules/no-ignored-replay-buffer.ts)
+- [Test source](https://github.com/JasonWeinzierl/eslint-plugin-rxjs-x/blob/main/tests/rules/no-ignored-replay-buffer.test.ts)

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

@@ -26,3 +26,21 @@ import { of } from "rxjs";
 
 of(42, 54).subscribe((value) => console.log(value));
 ```
+
+## When Not To Use It
+
+If you don't care about errors or output of some observables in your project, you may not need this rule.
+Alternatively, you may require all logic to go in the `pipe` section of your observables.
+In that case, you should not use this rule and should enable [`no-subscribe-handlers`](./no-subscribe-handlers.md) instead,
+which is the opposite of this rule.
+
+Type checked lint rules are more powerful than traditional lint rules, but also require configuring type checked linting.
+
+## Related To
+
+- [`no-subscribe-handlers`](./no-subscribe-handlers.md)
+
+## Resources
+
+- [Rule source](https://github.com/JasonWeinzierl/eslint-plugin-rxjs-x/blob/main/src/rules/no-ignored-subscribe.ts)
+- [Test source](https://github.com/JasonWeinzierl/eslint-plugin-rxjs-x/blob/main/tests/rules/no-ignored-subscribe.test.ts)

package/docs/rules/no-ignored-subscription.md

@@ -31,3 +31,16 @@ const numbers = new Observable<number>(subscriber => {
   interval(1e3).subscribe(subscriber);
 });
 ```
+
+## When Not To Use It
+
+If you don't care about unsubscribing from all observables in your project, then you may not need this rule.
+Alternatively, your project might use operators like `take`, `takeUntil`, `takeWhile`, etc.
+or Angular's `takeUntilDestroyed` to automatically handle subscriptions.
+
+Type checked lint rules are more powerful than traditional lint rules, but also require configuring type checked linting.
+
+## Resources
+
+- [Rule source](https://github.com/JasonWeinzierl/eslint-plugin-rxjs-x/blob/main/src/rules/no-ignored-subscription.ts)
+- [Test source](https://github.com/JasonWeinzierl/eslint-plugin-rxjs-x/blob/main/tests/rules/no-ignored-subscription.test.ts)

package/docs/rules/no-ignored-takewhile-value.md

@@ -24,3 +24,12 @@ import { takeWhile } from "rxjs/operators";
 
 const whilst = source.pipe(takeWhile(value => value));
 ```
+
+## When Not To Use It
+
+If you don't care about using the given value in a `takeWhile` callback, then you don't need this rule.
+
+## Resources
+
+- [Rule source](https://github.com/JasonWeinzierl/eslint-plugin-rxjs-x/blob/main/src/rules/no-ignored-takewhile-value.ts)
+- [Test source](https://github.com/JasonWeinzierl/eslint-plugin-rxjs-x/blob/main/tests/rules/no-ignored-takewhile-value.test.ts)

package/docs/rules/no-implicit-any-catch.md

@@ -8,7 +8,10 @@
 
 <!-- end auto-generated rule header -->
 
-This rule requires an explicit type annotation for error parameters in error handlers. It's similar to the typescript-eslint [`use-unknown-in-catch-callback-variable`](https://typescript-eslint.io/rules/use-unknown-in-catch-callback-variable/) rule or the TSConfig [`useUnknownInCatchVariables`](https://www.typescriptlang.org/tsconfig/#useUnknownInCatchVariables) option, but is for observables - not `try`/`catch` statements.
+This rule requires an explicit type annotation for error parameters in error handlers.
+It's similar to the typescript-eslint [`use-unknown-in-catch-callback-variable`](https://typescript-eslint.io/rules/use-unknown-in-catch-callback-variable/) rule
+or the TSConfig [`useUnknownInCatchVariables`](https://www.typescriptlang.org/tsconfig/#useUnknownInCatchVariables) option,
+but is for observables - not `try`/`catch` statements.
 
 ## Rule details
 
@@ -89,6 +92,18 @@ This rule accepts a single option which is an object with an `allowExplicitAny`
 }
 ```
 
+## When Not To Use It
+
+If your codebase is not yet able to enable `useUnknownInCatchVariables`,
+it likely would be similarly difficult to enable this rule.
+
+Type checked lint rules are more powerful than traditional lint rules, but also require configuring type checked linting.
+
 ## Further reading
 
 - [Catching Unknowns](https://ncjamieson.com/catching-unknowns/)
+
+## Resources
+
+- [Rule source](https://github.com/JasonWeinzierl/eslint-plugin-rxjs-x/blob/main/src/rules/no-implicit-any-catch.ts)
+- [Test source](https://github.com/JasonWeinzierl/eslint-plugin-rxjs-x/blob/main/tests/rules/no-implicit-any-catch.test.ts)

package/docs/rules/no-index.md

@@ -19,3 +19,16 @@ Examples of **correct** code for this rule:
 ```ts
 import { of } from "rxjs";
 ```
+
+## When Not To Use It
+
+If you don't care about unnecessary import path segments, then you don't need this rule.
+
+## Further reading
+
+- [Importing instructions](https://rxjs.dev/guide/importing)
+
+## Resources
+
+- [Rule source](https://github.com/JasonWeinzierl/eslint-plugin-rxjs-x/blob/main/src/rules/no-index.ts)
+- [Test source](https://github.com/JasonWeinzierl/eslint-plugin-rxjs-x/blob/main/tests/rules/no-index.test.ts)

package/docs/rules/no-internal.md

@@ -21,3 +21,18 @@ Examples of **correct** code for this rule:
 ```ts
 import { of } from "rxjs";
 ```
+
+## When Not To Use It
+
+If you need to import internal modules that are not covered by the public API,
+then you don't need this rule.
+However, keep in mind that internal modules may change without notice.
+
+## Further reading
+
+- [Importing instructions](https://rxjs.dev/guide/importing)
+
+## Resources
+
+- [Rule source](https://github.com/JasonWeinzierl/eslint-plugin-rxjs-x/blob/main/src/rules/no-internal.ts)
+- [Test source](https://github.com/JasonWeinzierl/eslint-plugin-rxjs-x/blob/main/tests/rules/no-internal.test.ts)

package/docs/rules/no-misused-observables.md

@@ -80,6 +80,22 @@ You can disable selective parts of the `checksVoidReturn` option. The following
 | `returns`          | Disallow returning an Observable-returning function where a function that returns `void` is expected.                                    | Boolean | `true`  |
 | `variables`        | Disallow assigning or declaring an Observable-returning function where a function that returns `void` is expected.                       | Boolean | `true`  |
 
+## When Not To Use It
+
+Like `@typescript-eslint/no-misused-promises`,
+this rule can be difficult to enable on large existing projects that set up many misused observables.
+
+Type checked lint rules are more powerful than traditional lint rules, but also require configuring type checked linting.
+
 ## Further reading
 
 - [TypeScript void function assignability](https://github.com/Microsoft/TypeScript/wiki/FAQ#why-are-functions-returning-non-void-assignable-to-function-returning-void)
+
+## Related To
+
+- [`no-floating-observables`](./no-floating-observables.md)
+
+## Resources
+
+- [Rule source](https://github.com/JasonWeinzierl/eslint-plugin-rxjs-x/blob/main/src/rules/no-misused-observables.ts)
+- [Test source](https://github.com/JasonWeinzierl/eslint-plugin-rxjs-x/blob/main/tests/rules/no-misused-observables.test.ts)

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

@@ -30,3 +30,17 @@ of(42, 54).pipe(
   mergeMap((value) => timer(1e3).pipe(map(() => value)))
 ).subscribe((value) => console.log(value));
 ```
+
+## When Not To Use It
+
+If you need nested subscriptions and are aware of the potential issues,
+then you might not need this rule.
+However, you should typically prefer to use higher-order mapping operators
+like `mergeMap`, `switchMap`, or `concatMap` to handle nested observables.
+
+Type checked lint rules are more powerful than traditional lint rules, but also require configuring type checked linting.
+
+## Resources
+
+- [Rule source](https://github.com/JasonWeinzierl/eslint-plugin-rxjs-x/blob/main/src/rules/no-nested-subscribe.ts)
+- [Test source](https://github.com/JasonWeinzierl/eslint-plugin-rxjs-x/blob/main/tests/rules/no-nested-subscribe.test.ts)

package/docs/rules/no-redundant-notify.md

@@ -6,7 +6,8 @@
 
 <!-- end auto-generated rule header -->
 
-This rule effects failures if an attempt is made to send a notification to an observer after a `complete` or `error` notification has already been sent.
+This rule effects failures if an attempt is made to send a notification to an observer after a `complete` or `error` notification has already been sent,
+or if `unsubscribe` has been called.
 
 Note that the rule _does not perform extensive analysis_. It uses a straightforward and limited approach to catch obviously redundant notifications.
 
@@ -32,3 +33,18 @@ const subject = new Subject<number>();
 subject.next(42);
 subject.error(new Error("Kaboom!"));
 ```
+
+## When Not To Use It
+
+If you don't care about redundant notifications, then you don't need this rule.
+
+Type checked lint rules are more powerful than traditional lint rules, but also require configuring type checked linting.
+
+## Related To
+
+- [`no-subject-unsubscribe`](./no-subject-unsubscribe.md)
+
+## Resources
+
+- [Rule source](https://github.com/JasonWeinzierl/eslint-plugin-rxjs-x/blob/main/src/rules/no-redundant-notify.ts)
+- [Test source](https://github.com/JasonWeinzierl/eslint-plugin-rxjs-x/blob/main/tests/rules/no-redundant-notify.test.ts)

package/docs/rules/no-sharereplay.md

@@ -29,6 +29,21 @@ This rule accepts a single option which is an object with an `allowConfig` prope
 }
 ```
 
+## When Not To Use It
+
+If you are confident that `shareReplay` is used properly your project,
+then you may not need this rule.
+However, keep in mind that it's recommended to always provide a config object
+that explicitly specifies `refCount` (see linked blog post);
+by default, `shareReplay` without any config defaults to `refCount: false`,
+which means the source observable will never be unsubscribed from,
+potentially leading to unexpected behavior and memory leaks.
+
 ## Further reading
 
 - [What's changed with shareReplay](https://ncjamieson.com/whats-changed-with-sharereplay/)
+
+## Resources
+
+- [Rule source](https://github.com/JasonWeinzierl/eslint-plugin-rxjs-x/blob/main/src/rules/no-sharereplay.ts)
+- [Test source](https://github.com/JasonWeinzierl/eslint-plugin-rxjs-x/blob/main/tests/rules/no-sharereplay.test.ts)

package/docs/rules/no-subclass.md

@@ -7,3 +7,17 @@
 <!-- end auto-generated rule header -->
 
 This rule effects failures if an RxJS class is subclassed. Developers are encouraged to avoid subclassing RxJS classes, as some public and protected implementation details might change in the future.
+
+## When Not To Use It
+
+If you need to subclass RxJS classes in your project, then don't use this rule.
+However, keep in mind that implementation details may change in the future;
+You might consider using ESLint disable comments for specific situations
+instead of completely disabling this rule.
+
+Type checked lint rules are more powerful than traditional lint rules, but also require configuring type checked linting.
+
+## Resources
+
+- [Rule source](https://github.com/JasonWeinzierl/eslint-plugin-rxjs-x/blob/main/src/rules/no-subclass.ts)
+- [Test source](https://github.com/JasonWeinzierl/eslint-plugin-rxjs-x/blob/main/tests/rules/no-subclass.test.ts)

package/docs/rules/no-subject-unsubscribe.md

@@ -6,8 +6,58 @@
 
 <!-- end auto-generated rule header -->
 
-This rule effects failures if the `unsubscribe` method is called on subjects. The method behaves differently to the `unsubscribe` method on subscriptions and is often an error.
+This rule effects failures if the `unsubscribe` method is called on subjects.
+The method behaves differently to the `unsubscribe` method on subscriptions and is often an error.
+
+This rule also effects failures if a subject is passed to a subscription's `add` method.
+Adding a subject to a subscription will cause the subject's `unsubscribe` method to get called
+when the subscription is unsubscribed.
+
+## Rule details
+
+Examples of **incorrect** code for this rule:
+
+```ts
+import { Subject } from "rxjs";
+
+const subject = new Subject<number>();
+subject.unsubscribe();
+```
+
+```ts
+import { Subject, Subscription } from "rxjs";
+
+const subject = new Subject<number>();
+const subscription = new Subscription();
+subscription.add(subject);
+```
+
+Examples of **correct** code for this rule:
+
+```ts
+import { Subject } from "rxjs";
+
+const subject = new Subject<number>();
+subject.complete();
+```
+
+## When Not To Use It
+
+If you intentionally use `unsubscribe` to cause errors when subjects are `next`-ed after closing,
+then you don't need this rule.
+
+Type checked lint rules are more powerful than traditional lint rules, but also require configuring type checked linting.
 
 ## Further reading
 
 - [Closed Subjects](https://ncjamieson.com/closed-subjects/)
+- [Composing Subscription](https://ncjamieson.com/composing-subscriptions/)
+
+## Related To
+
+- [`no-redundant-notify`](./no-redundant-notify.md)
+
+## Resources
+
+- [Rule source](https://github.com/JasonWeinzierl/eslint-plugin-rxjs-x/blob/main/src/rules/no-subject-unsubscribe.ts)
+- [Test source](https://github.com/JasonWeinzierl/eslint-plugin-rxjs-x/blob/main/tests/rules/no-subject-unsubscribe.test.ts)

package/docs/rules/no-subject-value.md

@@ -5,3 +5,15 @@
 <!-- end auto-generated rule header -->
 
 This rule effects an error if the `value` property - or `getValue` method - of a `BehaviorSubject` is used.
+
+## When Not To Use It
+
+If your code uses the `value` property or the `getValue` method of `BehaviorSubject`,
+then don't enable this rule.
+
+Type checked lint rules are more powerful than traditional lint rules, but also require configuring type checked linting.
+
+## Resources
+
+- [Rule source](https://github.com/JasonWeinzierl/eslint-plugin-rxjs-x/blob/main/src/rules/no-subject-value.ts)
+- [Test source](https://github.com/JasonWeinzierl/eslint-plugin-rxjs-x/blob/main/tests/rules/no-subject-value.test.ts)

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

@@ -35,3 +35,19 @@ of(42, 54)
   .pipe(tap((value) => console.log(value)))
   .subscribe();
 ```
+
+## When Not To Use It
+
+If you don't require all logic to go in the `pipe` section of your observables, then you don't need this rule.
+Also, if your project uses `no-ignored-subscribe`, which is the opposite of this rule, then you should not use this rule.
+
+Type checked lint rules are more powerful than traditional lint rules, but also require configuring type checked linting.
+
+## Related To
+
+- [`no-ignored-subscribe`](./no-ignored-subscribe.md)
+
+## Resources
+
+- [Rule source](https://github.com/JasonWeinzierl/eslint-plugin-rxjs-x/blob/main/src/rules/no-subscribe-handlers.ts)
+- [Test source](https://github.com/JasonWeinzierl/eslint-plugin-rxjs-x/blob/main/tests/rules/no-subscribe-handlers.test.ts)

package/docs/rules/no-subscribe-in-pipe.md

@@ -18,7 +18,7 @@ import { map } from "rxjs/operators";
 
 of(42, 54).pipe(
   map(value => {
-    of(value).subscribe(console.log); // This will trigger the rule
+    of(value).subscribe(console.log);
     return value * 2;
   })
 ).subscribe(result => console.log(result));
@@ -35,3 +35,21 @@ of(42, 54).pipe(
   map(value => value * 2)
 ).subscribe(result => console.log(result));
 ```
+
+## When Not To Use It
+
+If you need to subscribe within `pipe` and are aware of the potential issues,
+then you might not need this rule.
+However, you should typically prefer to use higher-order mapping operators
+like `mergeMap`, `switchMap`, or `concatMap` to handle nested observables.
+
+Type checked lint rules are more powerful than traditional lint rules, but also require configuring type checked linting.
+
+## Related To
+
+- [`no-nested-subscribe`](./no-nested-subscribe.md)
+
+## Resources
+
+- [Rule source](https://github.com/JasonWeinzierl/eslint-plugin-rxjs-x/blob/main/src/rules/no-subscribe-in-pipe.ts)
+- [Test source](https://github.com/JasonWeinzierl/eslint-plugin-rxjs-x/blob/main/tests/rules/no-subscribe-in-pipe.test.ts)

package/docs/rules/no-topromise.md

@@ -10,6 +10,23 @@
 
 This rule effects failures if the `toPromise` method is used.
 
+This rule provides two editor suggestions which replace `toPromise` with either:
+
+- `lastValueFrom(...)`, which behaves closest to the behavior of `toPromise`,
+- or `firstValueFrom(...)`.
+
+## When Not To Use It
+
+If you rely on RxJS's deprecation of `toPromise` and don't need to double-flag usage,
+then you don't need this rule.
+
+Type checked lint rules are more powerful than traditional lint rules, but also require configuring type checked linting.
+
 ## Further reading
 
 - [Conversion to Promises](https://rxjs.dev/deprecations/to-promise)
+
+## Resources
+
+- [Rule source](https://github.com/JasonWeinzierl/eslint-plugin-rxjs-x/blob/main/src/rules/no-topromise.ts)
+- [Test source](https://github.com/JasonWeinzierl/eslint-plugin-rxjs-x/blob/main/tests/rules/no-topromise.test.ts)

package/docs/rules/no-unbound-methods.md

@@ -41,6 +41,21 @@ return this.http
   );
 ```
 
+## When Not To Use It
+
+If every handler in your project does not depend on the `this` context in their implementations,
+then in some cases it may be safe to not use this rule.
+However, keep in mind that future changes may introduce bugs
+by changing their implementations to depend on the `this` context;
+see the linked blog post for best practice explanation.
+
+Type checked lint rules are more powerful than traditional lint rules, but also require configuring type checked linting.
+
 ## Further reading
 
 - [Avoiding unbound methods](https://ncjamieson.com/avoiding-unbound-methods/)
+
+## Resources
+
+- [Rule source](https://github.com/JasonWeinzierl/eslint-plugin-rxjs-x/blob/main/src/rules/no-unbound-methods.ts)
+- [Test source](https://github.com/JasonWeinzierl/eslint-plugin-rxjs-x/blob/main/tests/rules/no-unbound-methods.test.ts)

package/docs/rules/no-unsafe-catch.md

@@ -60,3 +60,15 @@ This rule accepts a single option which is an object with an `observable` proper
   ]
 }
 ```
+
+## When Not To Use It
+
+If you don't use a library with effects and epics (e.g. NgRx or redux-observable),
+then you don't need this rule.
+
+Type checked lint rules are more powerful than traditional lint rules, but also require configuring type checked linting.
+
+## Resources
+
+- [Rule source](https://github.com/JasonWeinzierl/eslint-plugin-rxjs-x/blob/main/src/rules/no-unsafe-catch.ts)
+- [Test source](https://github.com/JasonWeinzierl/eslint-plugin-rxjs-x/blob/main/tests/rules/no-unsafe-catch.test.ts)

package/docs/rules/no-unsafe-first.md

@@ -26,3 +26,15 @@ This rule accepts a single option which is an object with an `observable` proper
   ]
 }
 ```
+
+## When Not To Use It
+
+If you don't use a library with effects and epics (e.g. NgRx or redux-observable),
+then you don't need this rule.
+
+Type checked lint rules are more powerful than traditional lint rules, but also require configuring type checked linting.
+
+## Resources
+
+- [Rule source](https://github.com/JasonWeinzierl/eslint-plugin-rxjs-x/blob/main/src/rules/no-unsafe-first.ts)
+- [Test source](https://github.com/JasonWeinzierl/eslint-plugin-rxjs-x/blob/main/tests/rules/no-unsafe-first.test.ts)

package/docs/rules/no-unsafe-subject-next.md

@@ -8,7 +8,8 @@
 
 This rule effects failures if `next` is called without an argument and the subject's value type is not `void`.
 
-In RxJS version 6, the `next` method's `value` parameter is optional, but a value should always be specified for subjects with non-`void` element types.
+In RxJS version 6, the `next` method's `value` parameter was optional, but a value should always be specified for subjects with non-`void` element types.
+RxJS version 7 changed the `value` parameter to mandatory.
 
 ## Rule details
 
@@ -30,3 +31,16 @@ subject.next();
 const subject = new Subject<number>();
 subject.next(0);
 ```
+
+## When Not To Use It
+
+If you don't care about sending `undefined` to subjects, then you don't need this rule.
+Alternatively, you may rely on TypeScript to enforce the `value` parameter,
+which was made mandatory in RxJS version 7.
+
+Type checked lint rules are more powerful than traditional lint rules, but also require configuring type checked linting.
+
+## Resources
+
+- [Rule source](https://github.com/JasonWeinzierl/eslint-plugin-rxjs-x/blob/main/src/rules/no-unsafe-subject-next.ts)
+- [Test source](https://github.com/JasonWeinzierl/eslint-plugin-rxjs-x/blob/main/tests/rules/no-unsafe-subject-next.test.ts)

package/docs/rules/no-unsafe-switchmap.md

@@ -47,6 +47,18 @@ The `allow` or `disallow` properties are mutually exclusive. Whether or not `swi
 
 The properties in the options object are themselves optional; they do not all have to be specified.
 
+## When Not To Use It
+
+If you don't use a library with effects and epics (e.g. NgRx or redux-observable),
+then you don't need this rule.
+
+Type checked lint rules are more powerful than traditional lint rules, but also require configuring type checked linting.
+
 ## Further reading
 
 - [Avoiding switchMap-related bugs](https://ncjamieson.com/avoiding-switchmap-related-bugs/)
+
+## Resources
+
+- [Rule source](https://github.com/JasonWeinzierl/eslint-plugin-rxjs-x/blob/main/src/rules/no-unsafe-switchmap.ts)
+- [Test source](https://github.com/JasonWeinzierl/eslint-plugin-rxjs-x/blob/main/tests/rules/no-unsafe-switchmap.test.ts)

package/docs/rules/no-unsafe-takeuntil.md

@@ -56,6 +56,17 @@ By default, the `allow` property contains all of the built-in operators that are
 
 The properties in the options object are themselves optional; they do not all have to be specified.
 
+## When Not To Use It
+
+If you are confident your project uses `takeUntil` correctly, then you may not need this rule.
+
+Type checked lint rules are more powerful than traditional lint rules, but also require configuring type checked linting.
+
 ## Further reading
 
 - [Avoiding takeUntil leaks](https://ncjamieson.com/avoiding-takeuntil-leaks/)
+
+## Resources
+
+- [Rule source](https://github.com/JasonWeinzierl/eslint-plugin-rxjs-x/blob/main/src/rules/no-unsafe-takeuntil.ts)
+- [Test source](https://github.com/JasonWeinzierl/eslint-plugin-rxjs-x/blob/main/tests/rules/no-unsafe-takeuntil.test.ts)

package/docs/rules/prefer-observer.md

@@ -49,6 +49,18 @@ This rule accepts a single option which is an object with an `allowNext` propert
 }
 ```
 
+## When Not To Use It
+
+If you rely on RxJS's deprecation of separate handlers and don't need to double-flag usage,
+then you don't need this rule.
+
+Type checked lint rules are more powerful than traditional lint rules, but also require configuring type checked linting.
+
 ## Further reading
 
 - [Subscribe Arguments](https://rxjs.dev/deprecations/subscribe-arguments)
+
+## Resources
+
+- [Rule source](https://github.com/JasonWeinzierl/eslint-plugin-rxjs-x/blob/main/src/rules/prefer-observer.ts)
+- [Test source](https://github.com/JasonWeinzierl/eslint-plugin-rxjs-x/blob/main/tests/rules/prefer-observer.test.ts)

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

@@ -29,6 +29,17 @@ Examples of **correct** code for this rule:
 import { map } from 'rxjs';
 ```
 
+## When Not To Use It
+
+If you don't care about importing from the deprecated site, then you don't need this rule.
+
+Type checked lint rules are more powerful than traditional lint rules, but also require configuring type checked linting.
+
 ## Further reading
 
 - [Importing instructions](https://rxjs.dev/guide/importing)
+
+## Resources
+
+- [Rule source](https://github.com/JasonWeinzierl/eslint-plugin-rxjs-x/blob/main/src/rules/prefer-root-operators.ts)
+- [Test source](https://github.com/JasonWeinzierl/eslint-plugin-rxjs-x/blob/main/tests/rules/prefer-root-operators.test.ts)

package/docs/rules/suffix-subjects.md

@@ -6,6 +6,10 @@
 
 This rule effects failures if subject variables, properties and parameters don't conform to a naming scheme that identifies them as subjects.
 
+> [!NOTE]
+> This rule is designed to be optionally compatible with [`finnish`](./finnish.md).
+> Using Finnish notation (adding a `$` suffix) your subject names will _not_ cause a failure of this rule.
+
 ## Rule details
 
 Examples of **incorrect** code for this rule:
@@ -18,6 +22,7 @@ Examples of **correct** code for this rule:
 
 ```ts
 const answersSubject = new Subject<number>();
+const answersSubject$ = new Subject<number>();
 ```
 
 ## Options
@@ -34,7 +39,9 @@ const answersSubject = new Subject<number>();
 
 <!-- end auto-generated rule options list -->
 
-This rule accepts a single option which is an object with properties that determine whether Finnish notation is enforced for `parameters`, `properties` and `variables`. It also contains a `types` property that determine whether of not the naming convention is to be enforced for specific types and a `suffix` property.
+This rule accepts a single option which is an object with properties that determine whether subject suffixes are enforced for `parameters`, `properties` and `variables`.
+It also contains a `types` property that determine whether or not the naming convention is to be enforced for specific types
+and a `suffix` property.
 
 The default (Angular-friendly) configuration looks like this:
 
@@ -56,3 +63,19 @@ The default (Angular-friendly) configuration looks like this:
 ```
 
 The properties in the options object are themselves optional; they do not all have to be specified.
+
+## When Not To Use It
+
+If you don't use suffixes on your project's subjects, then you don't need this rule.
+However, keep in mind that inconsistent style can harm readability in a project.
+
+Type checked lint rules are more powerful than traditional lint rules, but also require configuring type checked linting.
+
+## Related To
+
+- [`finnish`](./finnish.md)
+
+## Resources
+
+- [Rule source](https://github.com/JasonWeinzierl/eslint-plugin-rxjs-x/blob/main/src/rules/suffix-subjects.ts)
+- [Test source](https://github.com/JasonWeinzierl/eslint-plugin-rxjs-x/blob/main/tests/rules/suffix-subjects.test.ts)

package/docs/rules/throw-error.md

@@ -38,3 +38,16 @@ throwError(() => new Error("Kaboom!"));
 | `allowThrowingUnknown` | Whether to always allow throwing values typed as `unknown`. | Boolean | `true`  |
 
 <!-- end auto-generated rule options list -->
+
+## When Not To Use It
+
+If you don't care about throwing values that are not `Error` objects, then you don't need this rule.
+However, keep in mind that, while JavaScript _allows_ throwing any value,
+most developer may find this behavior surprising or inconvenient to handle.
+
+Type checked lint rules are more powerful than traditional lint rules, but also require configuring type checked linting.
+
+## Resources
+
+- [Rule source](https://github.com/JasonWeinzierl/eslint-plugin-rxjs-x/blob/main/src/rules/throw-error.ts)
+- [Test source](https://github.com/JasonWeinzierl/eslint-plugin-rxjs-x/blob/main/tests/rules/throw-error.test.ts)

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "eslint-plugin-rxjs-x",
   "type": "commonjs",
-  "version": "0.6.0",
-  "packageManager": "yarn@4.5.3+sha512.3003a14012e2987072d244c720506549c1aab73ee728208f1b2580a9fd67b92d61ba6b08fe93f6dce68fd771e3af1e59a0afa28dd242dd0940d73b95fedd4e90",
+  "version": "0.6.2",
+  "packageManager": "yarn@4.6.0+sha512.5383cc12567a95f1d668fbe762dfe0075c595b4bfff433be478dbbe24e05251a8e8c3eb992a986667c1d53b6c3a9c85b8398c35a960587fbd9fa3a0915406728",
   "description": "ESLint v9+ plugin for RxJS",
   "author": "Jason Weinzierl <weinzierljason@gmail.com>",
   "license": "MIT",
@@ -73,27 +73,27 @@
     }
   },
   "devDependencies": {
-    "@eslint/js": "^9.16.0",
-    "@stylistic/eslint-plugin": "^2.11.0",
+    "@eslint/js": "^9.17.0",
+    "@stylistic/eslint-plugin": "^2.12.1",
     "@types/common-tags": "^1.8.4",
     "@types/node": "~18.18.0",
-    "@typescript-eslint/rule-tester": "^8.17.0",
+    "@typescript-eslint/rule-tester": "^8.19.1",
     "@typescript/vfs": "^1.6.0",
     "@vitest/coverage-v8": "^2.1.8",
-    "@vitest/eslint-plugin": "^1.1.14",
-    "bumpp": "^9.8.1",
-    "eslint": "^9.16.0",
+    "@vitest/eslint-plugin": "^1.1.24",
+    "bumpp": "^9.9.3",
+    "eslint": "^9.17.0",
     "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.2",
-    "eslint-plugin-import-x": "^4.4.2",
-    "eslint-plugin-n": "^17.14.0",
-    "markdownlint-cli2": "^0.15.0",
+    "eslint-doc-generator": "^2.0.2",
+    "eslint-import-resolver-typescript": "^3.7.0",
+    "eslint-plugin-eslint-plugin": "^6.4.0",
+    "eslint-plugin-import-x": "^4.6.1",
+    "eslint-plugin-n": "^17.15.1",
+    "markdownlint-cli2": "^0.17.1",
     "rxjs": "^7.8.1",
     "tsup": "^8.3.5",
     "typescript": "~5.7.2",
-    "typescript-eslint": "^8.17.0",
+    "typescript-eslint": "^8.19.1",
     "vitest": "^2.1.8"
   },
   "engines": {