README
rxjs-tslint-rules
TSLint is deprecated. All of the rules in this package - with the exception of the RxJS-version-5-only rules - have equivalent ESLint rules in the eslint-plugin-rxjs
and eslint-plugin-rxjs-angular
packages.
If you've arrived here looking for the TSLint rules that automatically convert RxJS version 5 code to version 6, you can find those rules here: rxjs-tslint
.
That said, if you've not already done so, you might want to checkout the rules in this package, too. Using them, you can avoid potential problems and questionable practices.
What is it?
rxjs-tslint-rules
is set of TSLint rules to:
- help manage projects that use
rxjs/add/...
imports; - enforce or disallow Finnish notation; and
- highlight other potential problems (see the rules for details).
Why might you need it?
When using imports that patch Observable
:
import { Observable } from "rxjs/Observable";
import "rxjs/add/observable/of";
import "rxjs/add/operator/map";
TypeScript will see the merged declarations in all modules, making it difficult to find rxjs/add/...
imports that are missing from modules in which patched observables and operators are used.
This can cause problems, as whether or not Observable
is patched then depends upon the order in which the modules are executed.
The rules in this package can be used to highlight missing - or unused - imports and other potential problems with RxJS.
There are some examples of policies that can be implemented using particular rule combinations in:
And Christian Liebel has written about his approach to importing RxJS in his blog post:
Install
Install the package using NPM:
npm install rxjs-tslint-rules --save-dev
Update your tslint.json
file to extend this package:
{
"extends": [
"rxjs-tslint-rules"
],
"rules": {
"rxjs-add": { "severity": "error" },
"rxjs-no-unused-add": { "severity": "error" }
}
}
Rules
WARNING: Before configuring any of the following rules, you should ensure that TSLint's no-unused-variable
rule is not enabled in your configuration (or in any configuration that you extend). That rule has caused problems in the past - as it leaves the TypeScript program in an unstable state - and has a significant number of still-open issues. Consider using the no-unused-declaration
rule from tslint-etc
instead.
The package includes the following rules (none of which are enabled by default):
Rule | Description | Options |
---|---|---|
rxjs-add |
Enforces the importation of patched observables and operators used in the module. | See below |
rxjs-ban-observables |
Disallows the use of banned observables. | See below |
rxjs-ban-operators |
Disallows the use of banned operators. | See below |
rxjs-deep-operators |
Enforces deep importation from within rxjs/operators - e.g. rxjs/operators/map . Until Webpack does not require configuration for tree shaking to work, there will be situations where deep imports are preferred. |
None |
rxjs-finnish |
Enforces the use of Finnish notation. | See below |
rxjs-just |
Enforces the use of a just alias for of . Some other Rx implementations use just and if that's your preference, this is the rule for you. (There was some discussion about deprecating of in favour of just , but it was decided to stick with of .) This rule includes a fixer. |
None |
rxjs-no-add |
Disallows the importation of patched observables and operators. | See below |
rxjs-no-async-subscribe |
Disallows passing async functions to subscribe. | None |
rxjs-no-compat |
Disallows importation from locations that depend upon rxjs-compat . |
None |
rxjs-no-connectable |
Disallows operators that return connectable observables. | None |
rxjs-no-create |
Disallows the calling of Observable.create . Use new Observable instead. |
None |
rxjs-no-deep-operators |
Disallows deep importation from rxjs/operators . Deep imports won't be in available in RxJS v6. |
None |
rxjs-no-do |
I do without do operators. Do you not? Well, do isn't always a code smell, but this rule can be useful as a warning. |
None |
rxjs-no-explicit-generics |
Disallows the explicit specification of generic type arguments when calling operators. Rely upon TypeScript's inference instead. | None |
rxjs-no-exposed-subjects |
Disallows exposed subjects. In classes, Subject properties and methods that return a Subject must be private . |
See below |
rxjs-no-finnish |
Disallows the use of Finnish notation. | None |
rxjs-no-ignored-error |
Disallows the calling of subscribe without specifying an error handler. |
None |
rxjs-no-ignored-notifier |
Disallows observables not composed from the repeatWhen or retryWhen notifier. |
None |
rxjs-no-ignored-observable |
Disallows the ignoring of observables returned by functions. | None. |
rxjs-no-ignored-replay-buffer |
Disallows using ReplaySubject , publishReplay or shareReplay without specifying the buffer size. |
None |
rxjs-no-ignored-subscribe |
Disallows the calling of subscribe without specifying arguments. | None |
rxjs-no-ignored-subscription |
Disallows ignoring the subscription returned by subscribe. | None |
rxjs-no-ignored-takewhile-value |
Disallows the ignoring of the takeWhile value. |
None |
rxjs-no-implicit-any-catch |
Like the no-implicit-any-catch rule in @typescript-eslint/eslint-plugin , but for the catchError operator instead of catch clauses. |
|
rxjs-no-index |
Disallows importation from rxjs/index , etc. - for the reason, see this issue. |
None |
rxjs-no-internal |
Disallows importation from rxjs/internal . |
None |
rxjs-no-nested-subscribe |
Disallows the calling of subscribe within a subscribe callback. |
None |
rxjs-no-operator |
Disallows importation from rxjs/operator . Useful if you prefer 'pipeable' operators - which are located in the operators directory. |
None |
rxjs-no-patched |
Disallows the calling of patched methods. Methods must be imported and called explicitly - not via Observable or Observable.prototype . |
See below |
rxjs-no-redundant-notify |
Disallows redundant notifications from completed or errored observables. | None |
rxjs-no-sharereplay |
Disallows using the shareReplay operator. Prior to version 6.4.0, that operator had some surprising behaviour. |
See below |
rxjs-no-subclass |
Disallows subclassing RxJS classes. | None |
rxjs-no-subject-unsubscribe |
Disallows calling the unsubscribe method of a Subject instance. For an explanation of why this can be a problem, see this Stack Overflow answer. |
None |
rxjs-no-subject-value |
Disallows accessing the value property of a BehaviorSubject instance. |
None |
rxjs-no-tap |
An alias for rxjs-no-do . |
None |
rxjs-no-unbound-methods |
Disallows the passing of unbound methods as callbacks. | None |
rxjs-no-unsafe-catch |
Disallows unsafe catch and catchError usage in NgRx effects and redux-observable epics. |
See below |
rxjs-no-unsafe-first |
Disallows unsafe first and take usage in NgRx effects and redux-observable epics. |
None |
rxjs-no-unsafe-scope |
Disallows the use of variables/properties from unsafe/outer scopes in operator callbacks. | See below |
rxjs-no-unsafe-subject-next |
Disallows unsafe optional next calls. The argument passed to next is optional, but not passing it is often unsafe. |
None |
rxjs-no-unsafe-switchmap |
Disallows unsafe switchMap usage in NgRx effects and redux-observable epics. |
See below |
rxjs-no-unsafe-takeuntil |
Disallows the application of operators after takeUntil . Operators placed after takeUntil can effect subscription leaks. |
See below |
rxjs-no-unused-add |
Disallows the importation of patched observables or operators that are not used in the module. | None |
rxjs-no-wholesale |
Disallows the wholesale importation of rxjs or rxjs/Rx . |
None |
rxjs-prefer-angular-async-pipe |
Disallows the calling of subscribe within an Angular component. |
None |
rxjs-prefer-angular-composition |
Enforces the composition of subscriptions within an Angular component. The rule ensures that subscriptions are composed into a class-property Subscription and that the Subscription is unsubscribed in ngOnDestroy . (For an example, see the tests.) |
None |
rxjs-prefer-angular-takeuntil |
Enforces the application of the takeUntil operator when calling subscribe within Angular components (and, optionally, within services, directives, and pipes). The rule (optionally) ensures that takeUntil is passed a class-property Subject and that the Subject is notified in ngOnDestroy . (For an example, see the tests.) |
See below |
rxjs-prefer-observer |
Enforces the passing of observers to subscribe and tap . See this RxJS issue. |
See below |
rxjs-suffix-subjects |
Disalllows subjects that don't end with the specified suffix option. |
See below |
rxjs-throw-error |
Enforces the passing of Error values to error notifications. |
None |
Options
rxjs-add
The rxjs-add
rule takes an optional object with the property file
. This is the path of the module - relative to the tsconfig.json
- that imports the patched observables and operators.
For example:
"rules": {
"rxjs-add": {
"options": [{
"allowElsewhere": false,
"allowUnused": false,
"file": "./source/rxjs-imports.ts"
}],
"severity": "error"
}
}
Specifying the file
option allows all of the patched observables and operators to be kept in a central location. Said module should be imported before other modules that use patched observables and operators. The importation of said module is not enforced; the rule only ensures that it imports observables and operators that are used in other modules.
If file
is specified, the allowElsewhere
and allowUnused
options can be used to configure whether or not patched imports are allowed in other files and whether or not unused patched imports are allowed. Both allowElsewhere
and allowUnused
default to false
.
Note that there is no file
option for the rxjs-no-unused-add
rule, so that rule should not be used in conjunction with the rxjs-add
rule - if the file
option is specified for the latter. Use the rxjs-add
rule's allowUnused
option instead.
If the file
option is not specified, patched observables and operators must be imported in the modules in which they are used.
rxjs-ban-observables/operators
The rxjs-ban-observables
and rxjs-ban-operators
rules take an object containing keys that are the names of observables/operators and values that are either booleans or strings containing the explanation for the ban.
For example:
"rules": {
"rxjs-ban-operators": {
"options": [{
"concat": "Use the concat factory function",
"merge": "Use the merge factory function"
}],
"severity": "error"
}
}
rxjs-finnish
The rxjs-finnish
rule takes an optional object with optional functions
, methods
, parameters
, properties
and variables
properties.
The properties are booleans and determine whether or not Finnish notation is enforced. All properties default to true
.
For example, to enforce Finnish notation for variables only:
"rules": {
"rxjs-finnish": {
"options": [{
"functions": false,
"methods": false,
"parameters": false,
"properties": false,
"variables": true
}],
"severity": "error"
}
}
The options also support names
and types
properties that can be used to prevent the enforcement of Finnish notation for certain names or types. The properties themselves are objects with keys that are regular expressions and values that are booleans.
For example, the following configuration will not enforce Finnish notation for names ending with Stream
or for the EventEmitter
type:
"rules": {
"rxjs-finnish": {
"options": [{
"names": {
"Stream