An ESLint plugin to enforce the use of TypeScript total functions.
npm install eslint-plugin-total-functions
An ESLint plugin to enforce the use of total functions (and prevent the use of partial functions) in TypeScript. If you like your types to tell the truth, this is the ESLint plugin for you.
| TypeScript | ESLint | eslint-plugin-total-functions | Suppported? |
| :--------------: | :-----: | :---------------------------: | :---------: |
| 5.0.2 | 8.36.0 | 7.0.0 | |
| 4.9.5 | 8.35.0 | 6.2.0 | No |
| 4.7.3 | 8.17.0 | 6.0.0 | No |
| 4.5.4 | 8.5.0 | 5.0.0 | No |
| 4.4.2 | 7.32.0 | 4.10.1 | No |
| 4.3.5 | 7.30.0 | 4.8.0 | No |
| 4.1.2 | 7.12.0 | 4.7.2 | No |
| 4.0.2 | 7.9.0 | 3.3.0 | No |
``sh`
yarn add --dev eslint-plugin-total-functions \
@typescript-eslint/parser \
eslint \
typescript
Use eslint-config-typed-fp which includes this plugin among others.
1. Turn on TypeScript's strict mode and noUncheckedIndexedAccess option.
2. Set up ESLint + TypeScript.
3. Turn on eslint-plugin-functional (recommended). Its rules related to mutation and OO are more important than this plugin's rules and they'll help keep your types honest.
4. Update your .eslintrc.js:
`diff
module.exports = {
parser: "@typescript-eslint/parser",
parserOptions: {
project: "./tsconfig.json",
ecmaVersion: 2018,
sourceType: "module"
},
extends: [
+ "plugin:total-functions/recommended",
],
plugins: [
+ "total-functions",
],
};
`
Alternatively you can configure individual rules separately (see below).
| Rule | Recommended | All | Fixer? |
| :-------------------------------------: | :----------: | :---: | :----: |
| require-strict-mode | ✅ | ✅ | |
| no-unsafe-type-assertion | ✅ | ✅ | |
| no-unsafe-readonly-mutable-assignment | ✅ | ✅ | |
| no-unsafe-mutable-readonly-assignment | | ✅ | |
| no-enums | ✅ | ✅ | |
| no-partial-url-constructor | ✅ | ✅ | |
| no-partial-division | ✅ | ✅ | |
| no-partial-string-normalize | ✅ | ✅ | |
| no-premature-fp-ts-effects | ✅ | ✅ | |
| no-nested-fp-ts-effects | | ✅ | |
| no-partial-array-reduce | ✅ | ✅ | |
| no-hidden-type-assertions | | ✅ | |
* no-unsafe-optional-property-assignment
* no-unsafe-enum-assignment (No longer required as of TypeScript 5, see https://devblogs.microsoft.com/typescript/announcing-typescript-5-0/#all-enums-are-union-enums)
The world is a very strange place when strict mode is disabled. This rule enforces strict mode and noUncheckedIndexedAccess mode (which is sadly not included under the strict umbrella).
Bans unsafe type assertions, for example:
`typescript`
type Foo = { readonly bar: number };
const foo = {} as Foo; // This compiles
foo.bar.toString(); // This explodes at runtime
This is similar to the consistent-type-assertions rule from typescript-eslint, however:
1. this rule is _weaker_ than consistent-type-assertions with its assertionStyle option set to never -- this rule will permit type assertions that it considers safe as opposed to blanket banning all type assertions, andconsistent-type-assertions
2. this rule is _stronger_ than with its objectLiteralTypeAssertions option set to never, for example:
`typescript`
type Foo = { readonly bar: number };
const foo = {};
const foo2 = foo as Foo; // Flagged by this rule, but not by consistent-type-assertions (unless you set assertionStyle to never)
foo2.bar.toString(); // This explodes at runtime
For examples of type assertions that this rule considers valid and invalid, see no-unsafe-type-assertion.test.ts.
See TypeScript issue #7481 for a request to fix this at the language level.
Bans unsafe assignment of readonly values to mutable values (which can lead to surprising mutation in the readonly value). This includes passing readonly values as arguments to functions that expect mutable parameters.
For examples of assignment that this rule considers valid and invalid, see no-unsafe-readonly-mutable-assignment.test.ts.
See TypeScript issue #13347 for a request to fix this at the language level.
The inverse counterpart to no-unsafe-readonly-mutable-assignment. This rule bans unsafe assignment of mutable values to readonly values (which just like the inverse can lead to surprising mutation in the readonly value).
This rule is often noisy in practice so, unlike no-unsafe-readonly-mutable-assignment, is excluded from the recommended config.
Note that the following is considered an assignment from mutable to readonly:
`ts`
type ReadonlyA = { readonly a: string };
const readonlyA: ReadonlyA = { a: "" };
The solution is to append as const to the RHS:
`ts`
type ReadonlyA = { readonly a: string };
const readonlyA: ReadonlyA = { a: "" } as const;
For examples of assignment that this rule considers valid and invalid, see no-unsafe-mutable-readonly-assignment.test.ts.
Enums have a number of issues, including unsoundness issues (which are especially relevant here). This rule bans the declaration of enums entirely. Use an alternative such as a union of strings instead.
Deprecated No longer required as of TypeScript 5 (https://devblogs.microsoft.com/typescript/announcing-typescript-5-0/#all-enums-are-union-enums).
If you do use an enum (or are forced to by a library), this rule flags unsafe assignment that the TypeScript compiler (prior to version 5) permits. For example:
`typescript
enum ZeroOrOne {
Zero = 0,
One = 1,
}
// This compiles (prior to TypeScript 5) but is flagged by no-unsafe-enum-assignment
const zeroOrOne: ZeroOrOne = 2;
// This is not flagged by no-unsafe-enum-assignment
const zeroOrOne: ZeroOrOne = ZeroOrOne.Zero;
`
The URL constructor can throw (i.e. it is partial).
`typescript`
// This compiles and foo appears to be a URL. It isn't.
const foo: URL = new URL(""); // Throws TypeError [ERR_INVALID_URL]: Invalid URL
Instead, you should use a wrapper that catches that error and returns URL | undefined or similar (perhaps using an Option type).
URL also happens to be mutable, which will be flagged by prefer-immutable-types. The readonly-types package provides a readonlyURL function that solves both of these issues.
Division by zero is undefined. That makes the division operator partial.
In the case of number, it results in Infinity (IEEE 754...).
In the case of bigint it throws a RangeError.
The latter is much more indisputably partial than the former.
`
> 1 / 0
Infinity
> 1n / 0n
Uncaught RangeError: Division by zero
This rule flags division unless the denominator is provably non-zero. If you need division, you should wrap it in a wrapper that returns undefined when the denominator is zero. Alternatively, consider using branded types / refinements, such as https://github.com/gcanti/io-ts/blob/master/index.md#branded-types--refinements or https://gcanti.github.io/newtype-ts/modules/NonZero.ts.html