eslint-plugin-rxjs-x 0.0.1

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

@@ -0,0 +1,30 @@
+# Avoid nested `subscribe` calls (`no-nested-subscribe`)
+
+This rule effects failures if `subscribe` is called within a `subscribe` handler.
+
+## Rule details
+
+Examples of **incorrect** code for this rule:
+
+```ts
+import { of, timer } from "rxjs";
+
+of(42, 54).subscribe((value) => {
+  timer(1e3).subscribe(() => console.log(value));
+});
+```
+
+Examples of **correct** code for this rule:
+
+```ts
+import { of, timer } from "rxjs";
+import { mapTo, mergeMap } from "rxjs/operators";
+
+of(42, 54).pipe(
+  mergeMap((value) => timer(1e3).pipe(mapTo(value)))
+).subscribe((value) => console.log(value));
+```
+
+## Options
+
+This rule has no options.

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

@@ -0,0 +1,32 @@
+# Avoid sending redundant notifications (`no-redundant-notify`)
+
+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.
+
+Note that the rule _does not perform extensive analysis_. It uses a straightforward and limited approach to catch obviously redundant notifications.
+
+## Rule details
+
+Examples of **incorrect** code for this rule:
+
+```ts
+import { Subject } from "rxjs";
+
+const subject = new Subject<number>();
+subject.next(42);
+subject.error(new Error("Kaboom!"));
+subject.complete();
+```
+
+Examples of **correct** code for this rule:
+
+```ts
+import { Subject } from "rxjs";
+
+const subject = new Subject<number>();
+subject.next(42);
+subject.error(new Error("Kaboom!"));
+```
+
+## Options
+
+This rule has no options.

package/docs/rules/no-sharereplay.md

@@ -0,0 +1,22 @@
+# Avoid `shareReplay` (`no-sharereplay`)
+
+This rule effects failures if the `shareReplay` operator is used - or if it is used without specifying a `config` argument.
+
+The behaviour of `shareReplay` has changed several times - see the blog post linked below.
+
+## Options
+
+This rule accepts a single option which is an object with an `allowConfig` property that that determines whether `shareReplay` is allow if a config argument is specified. By default, `allowConfig` is `true`.
+
+```json
+{
+  "rxjs-x/no-sharereplay": [
+    "error",
+    { "allowConfig": true }
+  ]
+}
+```
+
+## Further reading
+
+- [What's changed with shareReplay](https://ncjamieson.com/whats-changed-with-sharereplay/)

package/docs/rules/no-subclass.md

@@ -0,0 +1,7 @@
+# Avoid subclassing RxJS classes (`no-subclass`)
+
+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.
+
+## Options
+
+This rule has no options.

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

@@ -0,0 +1,11 @@
+# Avoid calling `unsubscribe` on subjects (`no-subject-unsubscribe`)
+
+This rule effects failures if the `unsubscribe` method is called on subjects. The method behaves differently to the `unsubsribe` method on subscriptions and is often an error.
+
+## Options
+
+This rule has no options.
+
+## Further reading
+
+- [Closed Subjects](https://ncjamieson.com/closed-subjects/)

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

@@ -0,0 +1,7 @@
+# Avoid using a behavior subject's value (`no-subject-value`)
+
+This rule effects an error if the `value` property - or `getValue` method - of a `BehaviorSubject` is used.
+
+## Options
+
+This rule has no options.

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

@@ -0,0 +1,39 @@
+# Forbid the passing of handlers to `subscribe` (`no-subscribe-handlers`)
+
+This rule effects failures whenever `subscribe` is called with handlers.
+
+## Rule details
+
+Examples of **incorrect** code for this rule:
+
+```ts
+import { of } from "rxjs";
+import { tap } from "rxjs/operators";
+
+of(42, 54).subscribe((value) => console.log(value));
+```
+
+<!-- prettier-ignore -->
+```ts
+import { of } from "rxjs";
+import { tap } from "rxjs/operators";
+
+of(42, 54).subscribe({
+  next: (value) => console.log(value),
+});
+```
+
+Examples of **correct** code for this rule:
+
+<!-- prettier-ignore -->
+```ts
+import { of } from "rxjs";
+
+of(42, 54)
+  .pipe(tap((value) => console.log(value)))
+  .subscribe();
+```
+
+## Options
+
+This rule has no options.

package/docs/rules/no-tap.md

@@ -0,0 +1,7 @@
+# Avoid `tap` (`no-tap`)
+
+This rule effects failures if the `tap` operator is used.
+
+## Options
+
+This rule has no options.

package/docs/rules/no-topromise.md

@@ -0,0 +1,7 @@
+# Avoid `toPromise` (`no-topromise`)
+
+This rule effects failures if the `toPromise` method is used.
+
+## Options
+
+This rule has no options.

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

@@ -0,0 +1,47 @@
+# Avoid using unbound methods as callbacks (`no-unbound-methods`)
+
+This rule effects failures if unbound methods are passed as callbacks.
+
+## Rule details
+
+Examples of **incorrect** code for this rule:
+
+<!-- prettier-ignore -->
+```ts
+return this.http
+  .get<Something>("https://api.some.com/things/1")
+  .pipe(
+    map(this.extractSomeProperty),
+    catchError(this.handleError)
+  );
+```
+
+Examples of **correct** code for this rule:
+
+<!-- prettier-ignore -->
+```ts
+return this.http
+  .get<Something>("https://api.some.com/things/1")
+  .pipe(
+    map((s) => this.extractSomeProperty(s)),
+    catchError((e) => this.handleError(e))
+  );
+```
+
+<!-- prettier-ignore -->
+```ts
+return this.http
+  .get<Something>("https://api.some.com/things/1")
+  .pipe(
+    map(this.extractSomeProperty.bind(this)),
+    catchError(this.handleError.bind(this))
+  );
+```
+
+## Options
+
+This rule has no options.
+
+## Further reading
+
+- [Avoiding unbound methods](https://ncjamieson.com/avoiding-unbound-methods/)

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

@@ -0,0 +1,50 @@
+# Avoid completing effects and epics (`no-unsafe-catch`)
+
+This rule effects failures if `catchError` is used in an effect or epic in a manner that will complete the outermost observable.
+
+## Rule details
+
+Examples of **incorrect** code for this rule:
+
+```ts
+actions.pipe(
+  ofType("SOMETHING"),
+  switchMap((action) => something(action)),
+  catchError(handleError)
+);
+```
+
+Examples of **correct** code for this rule:
+
+```ts
+actions.pipe(
+  ofType("SOMETHING"),
+  switchMap((action) => something(action).pipe(
+    catchError(handleError)
+  ))
+);
+```
+
+```ts
+actions.pipe(
+  ofType("SOMETHING"),
+  switchMap((action) => something(action)),
+  catchError((error, caught) => {
+    handleError(error);
+    return caught;
+  })
+);
+```
+
+## 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-unsafe-catch": [
+    "error",
+    { "observable": "[Aa]ction(s|s\\$|\\$)$" }
+  ]
+}
+```

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

@@ -0,0 +1,16 @@
+# Avoid completing effects and epics (`no-unsafe-first`)
+
+This rule effects failures if `first` is used in an effect or epic in a manner that will complete the outermost observable.
+
+## 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-unsafe-first": [
+    "error",
+    { "observable": "[Aa]ction(s|s\\$|\\$)$" }
+  ]
+}
+```

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

@@ -0,0 +1,30 @@
+# Avoid passing `undefined` to `next` (`no-unsafe-subject-next`)
+
+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.
+
+## Rule details
+
+Examples of **incorrect** code for this rule:
+
+```ts
+const subject = new Subject<number>();
+subject.next();
+```
+
+Examples of **correct** code for this rule:
+
+```ts
+const subject = new Subject<void>();
+subject.next();
+```
+
+```ts
+const subject = new Subject<number>();
+subject.next(0);
+```
+
+## Options
+
+This rule has no options.

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

@@ -0,0 +1,38 @@
+# Avoid `switchMap` bugs in effects and epics (`no-unsafe-switchmap`)
+
+This rule effects failures if `switchMap` is used in effects or epics that perform actions other than reads. For a detailed explanation, see the blog post linked below.
+
+## Options
+
+This rule accepts a single option which is an object with `allow`, `disallow` and `observable` properties.
+
+The `observable` property 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.
+
+The `allow` or `disallow` properties are mutually exclusive. Whether or not `switchMap` is allowed will depend upon the matching of action types with `allow` or `disallow`. The properties can be specified as regular expression strings or as arrays of words.
+
+```json
+{
+  "rxjs-x/no-unsafe-switchmap": [
+    "error",
+    {
+      "disallow": [
+        "add",
+        "create",
+        "delete",
+        "post",
+        "put",
+        "remove",
+        "set",
+        "update"
+      ],
+      "observable": "[Aa]ction(s|s\\$|\\$)$"
+    }
+  ]
+}
+```
+
+The properties in the options object are themselves optional; they do not all have to be specified.
+
+## Further reading
+
+- [Avoiding switchMap-related bugs](https://ncjamieson.com/avoiding-switchmap-related-bugs/)

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

@@ -0,0 +1,46 @@
+# Avoid `takeUntil` subscription leaks (`no-unsafe-takeuntil`)
+
+This rule effects failures whenever `takeUntil` is used in observable compositions that can leak subscriptions.
+
+Although it's recommended that `takeUntil` be placed last - to ensure unsubscription from any inner observables - there are a number of operators that might _need_ to be placed after it - like `toArray` or any other operator that depends upon a `complete` notification. The rule is aware of these operators (see the rule's options, below) and will not effect failures if they are placed after `takeUntil`.
+
+## Rule details
+
+Examples of **incorrect** code for this rule:
+
+```ts
+const combined = source
+    .pipe(takeUntil(notifier), combineLatest(b))
+    .subscribe((value) => console.log(value));
+```
+
+Examples of **correct** code for this rule:
+
+```ts
+const combined = source
+    .pipe(combineLatest(b), takeUntil(notifier))
+    .subscribe((value) => console.log(value));
+```
+
+## Options
+
+This rule accepts a single option which is an object with `alias` and `allow` properties. The `alias` property is an array of names of operators that should be treated similarly to `takeUntil` and the `allow` property is an array of names of operators that are safe to use after `takeUntil`.
+
+By default, the `allow` property contains all of the built-in operators that are safe to use after `takeUntil`.
+
+```json
+{
+    "rxjs-x/no-unsafe-takeuntil": [
+        "error",
+        {
+            "alias": ["untilDestroyed"]
+        }
+    ]
+}
+```
+
+The properties in the options object are themselves optional; they do not all have to be specified.
+
+## Further reading
+
+- [Avoiding takeUntil leaks](https://ncjamieson.com/avoiding-takeuntil-leaks/)

package/docs/rules/prefer-observer.md

@@ -0,0 +1,34 @@
+# Avoid separate handlers (`prefer-observer`)
+
+This rule effects failures if `subscribe` - or `tap` - is called with separate handlers instead of an observer.
+
+## Rule details
+
+Examples of **incorrect** code for this rule:
+
+```ts
+import { of } from "rxjs";
+of(42, 54).subscribe((value) => console.log(value));
+```
+
+Examples of **correct** code for this rule:
+
+```ts
+import { of } from "rxjs";
+of(42, 54).subscribe({
+  next: (value) => console.log(value)
+});
+```
+
+## Options
+
+This rule accepts a single option which is an object with an `allowNext` property that determines whether a single `next` callback is allowed. By default, `allowNext` is `true`.
+
+```json
+{
+  "rxjs-x/prefer-observer": [
+    "error",
+    { "allowNext": false }
+  ]
+}
+```

package/docs/rules/suffix-subjects.md

@@ -0,0 +1,42 @@
+# Identify subjects (`suffix-subjects`)
+
+This rule effects failures if subject variables, properties and parameters don't conform to a naming scheme that identifies them as subjects.
+
+## Rule details
+
+Examples of **incorrect** code for this rule:
+
+```ts
+const answers = new Subject<number>();
+```
+
+Examples of **correct** code for this rule:
+
+```ts
+const answersSubject = new Subject<number>();
+```
+
+## Options
+
+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.
+
+The default (Angular-friendly) configuration looks like this:
+
+```json
+{
+  "rxjs-x/suffix-subjects": [
+    "error",
+    {
+      "parameters": true,
+      "properties": true,
+      "suffix": "Subject",
+      "types": {
+        "^EventEmitter$": false
+      },
+      "variables": true,
+    }
+  ]
+}
+```
+
+The properties in the options object are themselves optional; they do not all have to be specified.

package/docs/rules/throw-error.md

@@ -0,0 +1,49 @@
+# Avoid throwing non-Error values (`throw-error`)
+
+This rule forbids throwing values that are neither `Error` nor `DOMException` instances.
+
+## Rule details
+
+Examples of **incorrect** code for this rule:
+
+```ts
+throw "Kaboom!";
+```
+
+```ts
+import { throwError } from "rxjs";
+throwError("Kaboom!");
+```
+
+```ts
+import { throwError } from "rxjs";
+throwError(() => "Kaboom!");
+```
+
+Examples of **correct** code for this rule:
+
+```ts
+throw new Error("Kaboom!");
+```
+
+```ts
+throw new RangeError("Kaboom!");
+```
+
+```ts
+throw new DOMException("Kaboom!");
+```
+
+```ts
+import { throwError } from "rxjs";
+throwError(new Error("Kaboom!"));
+```
+
+```ts
+import { throwError } from "rxjs";
+throwError(() => new Error("Kaboom!"));
+```
+
+## Options
+
+This rule has no options.

package/package.json

@@ -0,0 +1,82 @@
+{
+  "name": "eslint-plugin-rxjs-x",
+  "type": "module",
+  "version": "0.0.1",
+  "packageManager": "yarn@4.5.1+sha512.341db9396b6e289fecc30cd7ab3af65060e05ebff4b3b47547b278b9e67b08f485ecd8c79006b405446262142c7a38154445ef7f17c1d5d1de7d90bf9ce7054d",
+  "description": "ESLint v9+ plugin for RxJS",
+  "author": "Jason Weinzierl <weinzierljason@gmail.com>",
+  "license": "MIT",
+  "homepage": "https://github.com/JasonWeinzierl/eslint-plugin-rxjs-x",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/JasonWeinzierl/eslint-plugin-rxjs-x.git"
+  },
+  "bugs": {
+    "url": "https://github.com/JasonWeinzierl/eslint-plugin-rxjs-x/issues"
+  },
+  "keywords": [
+    "lint",
+    "rules",
+    "eslint",
+    "rxjs"
+  ],
+  "sideEffects": false,
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.cjs"
+    }
+  },
+  "main": "./dist/index.mjs",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist",
+    "docs"
+  ],
+  "scripts": {
+    "build": "unbuild",
+    "lint": "eslint",
+    "release": "bumpp && yarn run build",
+    "test": "vitest",
+    "coverage": "vitest run --coverage",
+    "typecheck": "tsc --noEmit"
+  },
+  "dependencies": {
+    "@typescript-eslint/scope-manager": "^8.12.2",
+    "@typescript-eslint/utils": "^8.12.2",
+    "common-tags": "^1.8.0",
+    "decamelize": "^5.0.0 || ^6.0.0",
+    "tslib": "^2.0.0",
+    "tsutils": "^3.0.0",
+    "tsutils-etc": "^1.4.2"
+  },
+  "peerDependencies": {
+    "eslint": "^8.57.0 || ^9.0.0",
+    "rxjs": ">=7.0.0",
+    "typescript": ">=4.0.0"
+  },
+  "devDependencies": {
+    "@eslint/js": "^9.13.0",
+    "@stylistic/eslint-plugin": "^2.10.1",
+    "@types/common-tags": "^1.8.4",
+    "@types/node": "^18.18.0",
+    "@typescript-eslint/rule-tester": "^8.12.2",
+    "@vitest/coverage-v8": "^2.1.4",
+    "bumpp": "^9.8.0",
+    "eslint": "^9.13.0",
+    "eslint-config-flat-gitignore": "^0.3.0",
+    "eslint-import-resolver-typescript": "^3.6.3",
+    "eslint-plugin-import-x": "^4.4.0",
+    "eslint-plugin-n": "^17.12.0",
+    "rxjs": "^7.0.0",
+    "typescript": "~5.6.3",
+    "typescript-eslint": "^8.12.2",
+    "unbuild": "^2.0.0",
+    "vitest": "^2.1.4"
+  },
+  "engines": {
+    "node": "^18.18.0 || ^20.9.0 || >= 21.1.0"
+  }
+}