feat(no-floating-observables)!: rename rule

Author: JasonWeinzierl

README.md

@@ -88,10 +88,10 @@ The package includes the following rules.
 | [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.                                                          | 🔒   |    |    | 💭 |    |
 | [no-ignored-default-value](docs/rules/no-ignored-default-value.md)     | Disallow using `firstValueFrom`, `lastValueFrom`, `first`, and `last` without specifying a default value. | 🔒   |    |    | 💭 |    |
 | [no-ignored-error](docs/rules/no-ignored-error.md)                     | Disallow calling `subscribe` without specifying an error handler.                                         | 🔒   |    |    | 💭 |    |
 | [no-ignored-notifier](docs/rules/no-ignored-notifier.md)               | Disallow observables not composed from the `repeatWhen` or `retryWhen` notifier.                          | ✅ 🔒 |    |    | 💭 |    |
-| [no-ignored-observable](docs/rules/no-ignored-observable.md)           | Disallow ignoring observables returned by functions.                                                      | 🔒   |    |    | 💭 |    |
 | [no-ignored-replay-buffer](docs/rules/no-ignored-replay-buffer.md)     | Disallow using `ReplaySubject`, `publishReplay` or `shareReplay` without specifying the buffer size.      | ✅ 🔒 |    |    |    |    |
 | [no-ignored-subscribe](docs/rules/no-ignored-subscribe.md)             | Disallow calling `subscribe` without specifying arguments.                                                |      |    |    | 💭 |    |
 | [no-ignored-subscription](docs/rules/no-ignored-subscription.md)       | Disallow ignoring the subscription returned by `subscribe`.                                               |      |    |    | 💭 |    |

docs/rules/no-ignored-observable.md renamed to docs/rules/no-floating-observables.md

@@ -1,23 +1,24 @@
-# Disallow ignoring observables returned by functions (`rxjs-x/no-ignored-observable`)
+# Require Observables to be handled appropriately (`rxjs-x/no-floating-observables`)
 
 💼 This rule is enabled in the 🔒 `strict` config.
 
 💭 This rule requires [type information](https://typescript-eslint.io/linting/typed-linting).
 
 <!-- end auto-generated rule header -->
 
-The effects failures if an observable returned by a function is neither assigned to a variable or property or passed to a function.
-This rule is like [no-floating-promises](https://typescript-eslint.io/rules/no-floating-promises/) but for Observables.
+A "floating" observable is one that is created without any code set up to handle any errors it might emit.
+Like a floating Promise, floating observables can cause several issues, such as ignored errors, unhandled cold observables, and more.
 
-This rule will report Observable-valued statements that are not treated in one of the following ways:
+This rule is like [no-floating-promises](https://typescript-eslint.io/rules/no-floating-promises/) but for Observables.
+This rule will report observable-valued statements that are not treated in one of the following ways:
 
 - Calling its `.subscribe()`
 - `return`ing it
 - Wrapping it in `lastValueFrom` or `firstValueFrom` and `await`ing it
 - [`void`ing it](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/void)
 
 > [!TIP]
-> `no-ignored-observable` only detects apparently unhandled Observable _statements_.
+> `no-ignored-observable` only detects apparently unhandled observable _statements_.
 
 ## Rule details
 

src/configs/strict.ts

@@ -11,10 +11,10 @@ export const createStrictConfig = (
     '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',
     'rxjs-x/no-ignored-error': 'error',
     'rxjs-x/no-ignored-notifier': 'error',
-    'rxjs-x/no-ignored-observable': 'error',
     'rxjs-x/no-ignored-replay-buffer': 'error',
     'rxjs-x/no-ignored-takewhile-value': 'error',
     'rxjs-x/no-implicit-any-catch': ['error', {

src/index.ts

@@ -16,10 +16,10 @@ import { noCyclicActionRule } from './rules/no-cyclic-action';
 import { noExplicitGenericsRule } from './rules/no-explicit-generics';
 import { noExposedSubjectsRule } from './rules/no-exposed-subjects';
 import { noFinnishRule } from './rules/no-finnish';
+import { noFloatingObservablesRule } from './rules/no-floating-observables';
 import { noIgnoredDefaultValueRule } from './rules/no-ignored-default-value';
 import { noIgnoredErrorRule } from './rules/no-ignored-error';
 import { noIgnoredNotifierRule } from './rules/no-ignored-notifier';
-import { noIgnoredObservableRule } from './rules/no-ignored-observable';
 import { noIgnoredReplayBufferRule } from './rules/no-ignored-replay-buffer';
 import { noIgnoredSubscribeRule } from './rules/no-ignored-subscribe';
 import { noIgnoredSubscriptionRule } from './rules/no-ignored-subscription';
@@ -63,10 +63,10 @@ const plugin = {
     'no-explicit-generics': noExplicitGenericsRule,
     'no-exposed-subjects': noExposedSubjectsRule,
     'no-finnish': noFinnishRule,
+    'no-floating-observables': noFloatingObservablesRule,
     'no-ignored-default-value': noIgnoredDefaultValueRule,
     'no-ignored-error': noIgnoredErrorRule,
     'no-ignored-notifier': noIgnoredNotifierRule,
-    'no-ignored-observable': noIgnoredObservableRule,
     'no-ignored-replay-buffer': noIgnoredReplayBufferRule,
     'no-ignored-subscribe': noIgnoredSubscribeRule,
     'no-ignored-subscription': noIgnoredSubscriptionRule,

src/rules/no-ignored-observable.ts renamed to src/rules/no-floating-observables.ts

@@ -2,21 +2,23 @@ import { TSESTree as es } from '@typescript-eslint/utils';
 import { getTypeServices } from '../etc';
 import { ruleCreator } from '../utils';
 
-export const noIgnoredObservableRule = ruleCreator({
+export const noFloatingObservablesRule = ruleCreator({
   defaultOptions: [],
   meta: {
     docs: {
-      description: 'Disallow ignoring observables returned by functions.',
+      description: 'Require Observables to be handled appropriately.',
       recommended: 'strict',
       requiresTypeChecking: true,
     },
     messages: {
-      forbidden: 'Ignoring a returned Observable is forbidden.',
+      forbidden:
+        'Observables must be subscribed to, returned, converted to a promise and awaited, '
+        + 'or be explicitly marked as ignored with the `void` operator.',
     },
     schema: [],
     type: 'problem',
   },
-  name: 'no-ignored-observable',
+  name: 'no-floating-observables',
   create: (context) => {
     const { couldBeObservable } = getTypeServices(context);
 

tests/rules/no-ignored-observable.test.ts renamed to tests/rules/no-floating-observables.test.ts

@@ -1,9 +1,9 @@
 import { stripIndent } from 'common-tags';
-import { noIgnoredObservableRule } from '../../src/rules/no-ignored-observable';
+import { noFloatingObservablesRule } from '../../src/rules/no-floating-observables';
 import { fromFixture } from '../etc';
 import { ruleTester } from '../rule-tester';
 
-ruleTester({ types: true }).run('no-ignored-observable', noIgnoredObservableRule, {
+ruleTester({ types: true }).run('no-floating-observables', noFloatingObservablesRule, {
   valid: [
     stripIndent`
       // not ignored