eslint-plugin-rxjs-x 0.7.1 → 0.7.3

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

@@ -1,68 +0,0 @@
-# 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 -->
-
-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 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-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.
-
-## Rule details
-
-Examples of **incorrect** code for this rule:
-
-```ts
-import { of } from "rxjs";
-of(42, 54);
-```
-
-Examples of **correct** code for this rule:
-
-```ts
-import { of } from "rxjs";
-const answers = of(42, 54);
-```
-
-## Options
-
-<!-- begin auto-generated rule options list -->
-
-| Name         | Description                           | Type    | Default |
-| :----------- | :------------------------------------ | :------ | :------ |
-| `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

@@ -1,43 +0,0 @@
-# Disallow using `firstValueFrom`, `lastValueFrom`, `first`, and `last` without specifying a default value (`rxjs-x/no-ignored-default-value`)
-
-💼 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 -->
-
-This rule prevents `EmptyError` rejections if there were no emissions from `firstValueFrom`, `lastValueFrom`, `first`, or `last` by requiring `defaultValue`.
-
-## Rule details
-
-Examples of **incorrect** code for this rule:
-
-```ts
-import { Subject, firstValueFrom } from "rxjs";
-
-const sub = new Subject();
-const result = firstValueFrom(sub);
-sub.complete();
-```
-
-Examples of **correct** code for this rule:
-
-```ts
-import { Subject, firstValueFrom } from "rxjs";
-
-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

@@ -1,53 +0,0 @@
-# Disallow calling `subscribe` without specifying an error handler (`rxjs-x/no-ignored-error`)
-
-💼 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 -->
-
-This rule enforces the passing of an error handler to `subscribe` calls.
-
-## Rule details
-
-Examples of **incorrect** code for this rule:
-
-```ts
-source.subscribe((value) => console.log(value));
-```
-
-```ts
-source.subscribe({
-  next: (value) => console.log(value)
-});
-```
-
-Examples of **correct** code for this rule:
-
-```ts
-source.subscribe(
-  (value) => console.log(value),
-  (error) => console.error(error)
-);
-```
-
-```ts
-source.subscribe({
-  next: (value) => console.log(value),
-  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

@@ -1,47 +0,0 @@
-# Disallow observables not composed from the `repeatWhen` or `retryWhen` notifier (`rxjs-x/no-ignored-notifier`)
-
-💼 This rule is enabled in the following configs: ✅ `recommended`, 🔒 `strict`.
-
-💭 This rule requires [type information](https://typescript-eslint.io/linting/typed-linting).
-
-<!-- end auto-generated rule header -->
-
-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:
-
-```ts
-import { range } from "rxjs";
-import { repeatWhen, take } from "rxjs/operators";
-
-const repeating = source.pipe(
-  repeatWhen(notifications => range(0, 3))
-);
-```
-
-Examples of **correct** code for this rule:
-
-```ts
-import { repeatWhen, take } from "rxjs/operators";
-
-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

@@ -1,47 +0,0 @@
-# Disallow using `ReplaySubject`, `publishReplay` or `shareReplay` without specifying the buffer size (`rxjs-x/no-ignored-replay-buffer`)
-
-💼 This rule is enabled in the following configs: ✅ `recommended`, 🔒 `strict`.
-
-<!-- end auto-generated rule header -->
-
-This rule effects failures if the buffer size of a replay buffer is not explicitly specified.
-
-## Rule details
-
-Examples of **incorrect** code for this rule:
-
-```ts
-import { ReplaySubject } from "rxjs";
-const subject = new ReplaySubject<number>();
-```
-
-```ts
-import { of, shareReplay } from "rxjs";
-of(42).pipe(shareReplay({ refCount: true }));
-```
-
-Examples of **correct** code for this rule:
-
-```ts
-import { ReplaySubject } from "rxjs";
-const subject = new ReplaySubject<number>(1);
-```
-
-```ts
-import { ReplaySubject } from "rxjs";
-const subject = new ReplaySubject<number>(Infinity);
-```
-
-```ts
-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

@@ -1,46 +0,0 @@
-# Disallow calling `subscribe` without specifying arguments (`rxjs-x/no-ignored-subscribe`)
-
-💭 This rule requires [type information](https://typescript-eslint.io/linting/typed-linting).
-
-<!-- end auto-generated rule header -->
-
-This rule effects failures whenever `subscribe` is called without handlers.
-
-## Rule details
-
-Examples of **incorrect** code for this rule:
-
-```ts
-import { of } from "rxjs";
-import { tap } from "rxjs/operators";
-
-of(42, 54).pipe(
-  tap((value) => console.log(value))
-).subscribe();
-```
-
-Examples of **correct** code for this rule:
-
-```ts
-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

@@ -1,46 +0,0 @@
-# Disallow ignoring the subscription returned by `subscribe` (`rxjs-x/no-ignored-subscription`)
-
-💭 This rule requires [type information](https://typescript-eslint.io/linting/typed-linting).
-
-<!-- end auto-generated rule header -->
-
-The effects failures if an subscription returned by call to `subscribe` is neither assigned to a variable or property or passed to a function.
-
-## Rule details
-
-Examples of **incorrect** code for this rule:
-
-```ts
-interval(1e3).subscribe(
-  (value) => console.log(value)
-);
-```
-
-Examples of **correct** code for this rule:
-
-```ts
-const subscription = interval(1e3).subscribe(
-  (value) => console.log(value)
-);
-```
-
-When subscribers are passed to `subscribe` they are chained, so the returned subscription can be ignored:
-
-```ts
-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

@@ -1,35 +0,0 @@
-# Disallow ignoring the value within `takeWhile` (`rxjs-x/no-ignored-takewhile-value`)
-
-💼 This rule is enabled in the following configs: ✅ `recommended`, 🔒 `strict`.
-
-<!-- end auto-generated rule header -->
-
-This rule effects failures if the value received by a `takeWhile` callback is not used in an expression.
-
-## Rule details
-
-Examples of **incorrect** code for this rule:
-
-```ts
-import { takeWhile } from "rxjs/operators";
-
-let flag = true;
-const whilst = source.pipe(takeWhile(() => flag));
-```
-
-Examples of **correct** code for this rule:
-
-```ts
-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

@@ -1,109 +0,0 @@
-# Disallow implicit `any` error parameters in `catchError` operators (`rxjs-x/no-implicit-any-catch`)
-
-💼 This rule is enabled in the following configs: ✅ `recommended`, 🔒 `strict`.
-
-🔧💡 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).
-
-💭 This rule requires [type information](https://typescript-eslint.io/linting/typed-linting).
-
-<!-- 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.
-
-## Rule details
-
-Examples of **incorrect** code for this rule:
-
-```ts
-import { throwError } from "rxjs";
-import { catchError } from "rxjs/operators";
-
-throwError(() => new Error("Kaboom!")).pipe(
-  catchError((error) => console.error(error))
-);
-```
-
-```ts
-import { throwError } from "rxjs";
-
-throwError(() => new Error("Kaboom!")).subscribe({
-  error: (error) => console.error(error)
-});
-```
-
-```ts
-import { throwError } from "rxjs";
-import { tap } from "rxjs/operators";
-
-throwError(() => new Error("Kaboom!")).pipe(
-  tap(undefined, (error) => console.error(error))
-);
-```
-
-Examples of **correct** code for this rule:
-
-```ts
-import { throwError } from "rxjs";
-import { catchError } from "rxjs/operators";
-
-throwError(() => new Error("Kaboom!")).pipe(
-  catchError((error: unknown) => console.error(error))
-);
-```
-
-```ts
-import { throwError } from "rxjs";
-
-throwError(() => new Error("Kaboom!")).subscribe({
-  error: (error: unknown) => console.error(error)
-});
-```
-
-```ts
-import { throwError } from "rxjs";
-import { tap } from "rxjs/operators";
-
-throwError(() => new Error("Kaboom!")).pipe(
-  tap(undefined, (error: unknown) => console.error(error))
-);
-```
-
-## Options
-
-<!-- begin auto-generated rule options list -->
-
-| Name               | Description                                           | Type    | Default |
-| :----------------- | :---------------------------------------------------- | :------ | :------ |
-| `allowExplicitAny` | Allow error variable to be explicitly typed as `any`. | Boolean | `true`  |
-
-<!-- end auto-generated rule options list -->
-
-This rule accepts a single option which is an object with an `allowExplicitAny` property that determines whether or not the error variable can be explicitly typed as `any`. By default, the use of explicit `any` is allowed.
-
-```json
-{
-  "rxjs-x/no-implicit-any-catch": [
-    "error",
-    { "allowExplicitAny": true }
-  ]
-}
-```
-
-## 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

@@ -1,34 +0,0 @@
-# Disallow importing index modules (`rxjs-x/no-index`)
-
-💼 This rule is enabled in the following configs: ✅ `recommended`, 🔒 `strict`.
-
-<!-- end auto-generated rule header -->
-
-This rule effects failures if an index module is specified as the import location.
-
-## Rule details
-
-Examples of **incorrect** code for this rule:
-
-```ts
-import { of } from "rxjs/index";
-```
-
-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

@@ -1,38 +0,0 @@
-# Disallow importing internal modules (`rxjs-x/no-internal`)
-
-💼 This rule is enabled in the following configs: ✅ `recommended`, 🔒 `strict`.
-
-🔧💡 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 effects failures if an internal module is specified as the import location.
-
-## Rule details
-
-Examples of **incorrect** code for this rule:
-
-```ts
-import { of } from "rxjs/internal/observable/of";
-```
-
-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

@@ -1,101 +0,0 @@
-# Disallow Observables in places not designed to handle them (`rxjs-x/no-misused-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 -->
-
-This rule forbids providing observables to logical locations where the TypeScript compiler allows them but they are not handled properly.
-These situations can often arise due to a misunderstanding of the way observables are handled.
-
-> [!TIP]
-> `no-misused-observables` only detects code that provides observables to incorrect _logical_ locations.
-> See [`no-floating-observables`](./no-floating-observables.md) for detecting unhandled observable _statements_.
-
-This rule is like [no-misused-promises](https://typescript-eslint.io/rules/no-misused-promises) but for Observables.
-
-> [!NOTE]
-> Unlike `@typescript-eslint/no-misused-promises`, this rule does not check conditionals like `if` statements.
-> Use `@typescript-eslint/no-unnecessary-condition` for linting those situations.
-
-## Rule details
-
-Examples of **incorrect** code for this rule:
-
-```ts
-import { of } from "rxjs";
-
-[1, 2, 3].forEach(i => of(i));
-
-interface MySyncInterface {
-    foo(): void;
-}
-class MyRxClass implements MySyncInterface {
-    foo(): Observable<number> {
-        return of(42);
-    }
-}
-
-const a = of(42);
-const b = { ...b };
-```
-
-Examples of **correct** code for this rule:
-
-```ts
-import { of } from "rxjs";
-
-[1, 2, 3].map(i => of(i));
-
-interface MyRxInterface {
-    foo(): Observable<number>;
-}
-class MyRxClass implements MyRxInterface {
-    foo(): Observable<number> {
-        return of(42);
-    }
-}
-```
-
-## Options
-
-<!-- WARNING: not auto-generated! -->
-
-| Name               | Description                                                                 | Type    | Default |
-| :----------------- | :-------------------------------------------------------------------------- | :------ | :------ |
-| `checksSpreads`    | Disallow `...` spreading an Observable.                                     | Boolean | `true`  |
-| `checksVoidReturn` | Disallow returning an Observable from a function typed as returning `void`. | Object  | `true`  |
-
-### `checksVoidReturn`
-
-You can disable selective parts of the `checksVoidReturn` option. The following sub-options are supported:
-
-| Name               | Description                                                                                                                              | Type    | Default |
-| :----------------- | :--------------------------------------------------------------------------------------------------------------------------------------- | :------ | :------ |
-| `arguments`        | Disallow passing an Observable-returning function as an argument where the parameter type expects a function that returns `void`.        | Boolean | `true`  |
-| `attributes`       | Disallow passing an Observable-returning function as a JSX attribute expected to be a function that returns `void`.                      | Boolean | `true`  |
-| `inheritedMethods` | Disallow providing an Observable-returning function where a function that returns `void` is expected by an extended or implemented type. | Boolean | `true`  |
-| `properties`       | Disallow providing an Observable-returning function where a function that returns `void` is expected by a property.                      | Boolean | `true`  |
-| `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)