eslint-plugin-rxjs-x 0.0.1

package/docs/rules/ban-observables.md

@@ -0,0 +1,22 @@
+# Avoid banned observable creators (`ban-observables`)
+
+This rule can be configured so that developers can ban any observable creators they want to avoid in their project.
+
+## 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.
+
+The following configuration bans `partition` and `onErrorResumeNext`:
+
+```json
+{
+  "rxjs-x/ban-observables": [
+    "error",
+    {
+      "partition": true,
+      "of": false,
+      "onErrorResumeNext": "What is this? Visual Basic?"
+    }
+  ]
+}
+```

package/docs/rules/ban-operators.md

@@ -0,0 +1,21 @@
+# Avoid banned operators (`ban-operators`)
+
+This rule can be configured so that developers can ban any operators they want to avoid in their project.
+
+## Options
+
+This rule accepts a single option which is an object the keys of which are the names of operators and the values are either booleans or strings containing the explanation for the ban.
+
+The following configuration bans `partition` and `onErrorResumeNext`:
+
+```json
+{
+  "rxjs-x/ban-operators": [
+    "error",
+    {
+      "partition": true,
+      "map": false,
+      "onErrorResumeNext": "What is this? Visual Basic?"
+    }
+  ]
+}

package/docs/rules/finnish.md

@@ -0,0 +1,54 @@
+# Use Finnish notation (`finnish`)
+
+This rule enforces the use of Finnish notation - i.e. the `$` suffix.
+
+## Rule details
+
+Examples of **incorrect** code for this rule:
+
+```ts
+const answers = of(42, 54);
+```
+
+Examples of **correct** code for this rule:
+
+```ts
+const answer$ = of(42, 54);
+```
+
+## Options
+
+This rule accepts a single option which is an object with properties that determine whether Finnish notation is enforced for `functions`, `methods`, `parameters`, `properties` and `variables`. It also contains:
+
+- `names` and `types` properties that determine whether of not Finnish notation is to be enforced for specific names or types.
+- a `strict` property that, if `true`, allows the `$` suffix to be used _only_ with identifiers that have an `Observable` type.
+
+The default (Angular-friendly) configuration looks like this:
+
+```json
+{
+    "rxjs-x/finnish": [
+        "error",
+        {
+            "functions": true,
+            "methods": true,
+            "names": {
+                "^(canActivate|canActivateChild|canDeactivate|canLoad|intercept|resolve|validate)$": false
+            },
+            "parameters": true,
+            "properties": true,
+            "strict": false,
+            "types": {
+                "^EventEmitter$": false
+            },
+            "variables": true
+        }
+    ]
+}
+```
+
+The properties in the options object are themselves optional; they do not all have to be specified.
+
+## Further reading
+
+- [Observables and Finnish Notation](https://medium.com/@benlesh/observables-and-finnish-notation-df8356ed1c9b)

package/docs/rules/just.md

@@ -0,0 +1,11 @@
+# Use `just` instead of `of` (`just`)
+
+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.
+
+## Options
+
+This rule has no options.
+
+## Further reading
+
+- [Rename `of` to `just`](https://github.com/ReactiveX/rxjs/issues/3747)

package/docs/rules/macro.md

@@ -0,0 +1,7 @@
+# Use the RxJS Tools macro (`macro`)
+
+This rule ensures that modules that import `rxjs` also import the Babel macro for [RxJS Tools](https://rxjs.tools).
+
+## Options
+
+This rule has no options.

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

@@ -0,0 +1,27 @@
+# Avoid passing async functions to `subscribe` (`no-async-subscribe`)
+
+This rule effects failures if async functions are passed to `subscribe`.
+
+## Rule details
+
+Examples of **incorrect** code for this rule:
+
+```ts
+import { of } from "rxjs";
+of(42).subscribe(async () => console.log(value));
+```
+
+Examples of **correct** code for this rule:
+
+```ts
+import { of } from "rxjs";
+of(42).subscribe(() => console.log(value));
+```
+
+## Options
+
+This rule has no options.
+
+## Further reading
+
+- [Why does this rule exist?](https://stackoverflow.com/q/71559135)

package/docs/rules/no-compat.md

@@ -0,0 +1,11 @@
+# Avoid the `rxjs-compat` package (`no-compat`)
+
+This rule prevents the use of `rxjs-compat`.
+
+## Options
+
+This rule has no options.
+
+## Further reading
+
+- [Backwards compatibility](https://github.com/ReactiveX/rxjs/blob/a6590e971969c736a15b77154dabbc22275aa0d5/docs_app/content/guide/v6/migration.md#backwards-compatibility)

package/docs/rules/no-connectable.md

@@ -0,0 +1,7 @@
+# Avoid connectable observables (`no-connectable`)
+
+This rule prevents the use of connectable observables.
+
+## Options
+
+This rule has no options.

package/docs/rules/no-create.md

@@ -0,0 +1,29 @@
+# Avoid the static `create` function (`no-create`)
+
+This rule prevents the use of the static `create` function in `Observable`. Developers should use `new` and the constructor instead.
+
+## Rule details
+
+Examples of **incorrect** code for this rule:
+
+```ts
+const answers = Observable.create(subscriber => {
+  subscriber.next(42);
+  subscriber.next(54);
+  subscriber.complete();
+});
+```
+
+Examples of **correct** code for this rule:
+
+```ts
+const answers = new Observable<number>(subscriber => {
+  subscriber.next(42);
+  subscriber.next(54);
+  subscriber.complete();
+});
+```
+
+## Options
+
+This rule has no options.

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

@@ -0,0 +1,62 @@
+# Avoid cyclic actions in effects and epics (`no-cyclic-action`)
+
+This rule effects failures for effects and epics that emit actions that would pass their `ofType` filter. Such actions are cyclic and, upon emission, immediately re-trigger the effect or epic.
+
+## Rule details
+
+Examples of **incorrect** code for this rule:
+
+```ts
+actions.pipe(
+  ofType("SOMETHING"),
+  map(() => ({ type: "SOMETHING" }))
+);
+```
+
+Examples of **correct** code for this rule:
+
+```ts
+actions.pipe(
+  ofType("SOMETHING"),
+  map(() => ({ type: "SOMETHING_ELSE" }))
+);
+```
+
+This rule can be used with effects _and epics_, so it makes __no attempt__ to discern whether or not dispatching is disabled for an NgRx effect. That is, code like this will effect (🙈) a failure:
+
+```ts
+someEffect = createEffect(() =>
+  this.actions$.pipe(
+    ofType("SOMETHING"),
+    tap(() => console.log("do something")),
+  ),
+  { dispatch: false }
+);
+```
+
+Instead, you can use the the RxJS [`ignoreElements`](https://rxjs.dev/api/operators/ignoreElements) operator:
+
+```ts
+someEffect = createEffect(() =>
+  this.actions$.pipe(
+    ofType("SOMETHING"),
+    tap(() => console.log("do something")),
+    ignoreElements()
+  )
+);
+```
+
+Or you can use an ESLint [inline comment](https://eslint.org/docs/user-guide/configuring#disabling-rules-with-inline-comments) to disable the rule for a specific effect.
+
+## Options
+
+This rule accepts a single option which is an object with an `observable` property that is a regular expression used to match an effect or epic's actions observable. The default `observable` regular expression should match most effect and epic action sources.
+
+```json
+{
+  "rxjs-x/no-cyclic-action": [
+    "error",
+    { "observable": "[Aa]ction(s|s\\$|\\$)$" }
+  ]
+}
+```

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

@@ -0,0 +1,23 @@
+# Avoid unnecessary explicit type arguments (`no-explicit-generics`)
+
+This rule prevents the use of explicit type arguments when the type arguments can be inferred.
+
+## Rule details
+
+Examples of **incorrect** code for this rule:
+
+```ts
+import { BehaviorSubject } from "rxjs";
+const subject = new BehaviorSubject<number>(42);
+```
+
+Examples of **correct** code for this rule:
+
+```ts
+import { BehaviorSubject } from "rxjs";
+const subject = new BehaviorSubject(42);
+```
+
+## Options
+
+This rule has no options.

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

@@ -0,0 +1,39 @@
+# Avoid public and protected subjects (`no-exposed-subjects`)
+
+This rule prevents the public or protected subjects. Developers should instead expose observables via the subjects' `toObservable` method.
+
+## Rule details
+
+Examples of **incorrect** code for this rule:
+
+```ts
+import { Subject } from "rxjs";
+class Answers {
+  public answers: Subject<number>;
+}
+```
+
+Examples of **correct** code for this rule:
+
+```ts
+import { Subject } from "rxjs";
+class Answers {
+  private _answers: Subject<string>;
+  get answers() {
+    return this._answers.toObservable();
+  }
+}
+```
+
+## Options
+
+This rule accepts a single option which is an object with an `allowProtected` property that determines whether or not protected subjects are allowed. By default, they are not.
+
+```json
+{
+  "rxjs-x/no-exposed-subjects": [
+    "error",
+    { "allowProtected": true }
+  ]
+}
+```

package/docs/rules/no-finnish.md

@@ -0,0 +1,25 @@
+# Avoid Finnish notation (`no-finnish`)
+
+This rule prevents the use of Finnish notation.
+
+## Rule details
+
+Examples of **incorrect** code for this rule:
+
+```ts
+const answer$ = of(42, 54);
+```
+
+Examples of **correct** code for this rule:
+
+```ts
+const answers = of(42, 54);
+```
+
+## Options
+
+This rule has no options.
+
+## Further reading
+
+- [Observables and Finnish Notation](https://medium.com/@benlesh/observables-and-finnish-notation-df8356ed1c9b)

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

@@ -0,0 +1,37 @@
+# Enforce the passing of error handlers (`no-ignored-error`)
+
+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)
+});
+```
+
+## Options
+
+This rule has no options.

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

@@ -0,0 +1,30 @@
+# Ensure `repeatWhen` or `retryWhen` notifiers are used (`no-ignored-notifier`)
+
+This rule effects failures if the notifier passed to a `repeatWhen` or `retryWhen` callback is not used.
+
+## 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)))
+);
+```
+
+## Options
+
+This rule has no options.

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

@@ -0,0 +1,23 @@
+# Use returned observables (`no-ignored-observable`)
+
+The effects failures if an observable returned by a function is neither assigned to a variable or property or passed to a function.
+
+## 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
+
+This rule has no options.

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

@@ -0,0 +1,28 @@
+# Avoid unbounded replay buffers (`no-ignored-replay-buffer`)
+
+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>();
+```
+
+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);
+```
+
+## Options
+
+This rule has no options.

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

@@ -0,0 +1,28 @@
+# Enforce the passing of handlers to `subscribe` (`no-ignored-subscribe`)
+
+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));
+```
+
+## Options
+
+This rule has no options.

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

@@ -0,0 +1,33 @@
+# Use returned subscriptions (`no-ignored-subscription`)
+
+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);
+});
+```
+
+## Options
+
+This rule has no options.

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

@@ -0,0 +1,26 @@
+# Avoid unused `takeWhile` values (`no-ignored-takewhile-value`)
+
+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));
+```
+
+## Options
+
+This rule has no options.

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

@@ -0,0 +1,78 @@
+# Use type-safe error handlers (`no-implicit-any-catch`)
+
+This rule requires an explicit type annotation for error parameters in error handlers. It's similar to the TypeScript [`no-implicit-any-catch`](https://github.com/typescript-eslint/typescript-eslint/blob/e01204931e460f5e6731abc443c88d666ca0b07a/packages/eslint-plugin/docs/rules/no-implicit-any-catch.md) rule, 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
+
+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 forbidden.
+
+```json
+{
+  "rxjs-x/no-implicit-any-catch": [
+    "error",
+    { "allowExplicitAny": true }
+  ]
+}
+```
+
+## Further reading
+
+- [Catching Unknowns](https://ncjamieson.com/catching-unknowns/)

package/docs/rules/no-index.md

@@ -0,0 +1,21 @@
+# Avoid importing index modules (`no-index`)
+
+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";
+```
+
+## Options
+
+This rule has no options.

package/docs/rules/no-internal.md

@@ -0,0 +1,21 @@
+# Avoid importing internal modules (`no-internal`)
+
+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";
+```
+
+## Options
+
+This rule has no options.