eslint-plugin-ft-flow

; } // this doesn't get checked since no JSX is present in a function type Options = { }; function SomeHelper(options: Options) { // ... } // this doesn't get checked since no JSX is present directly in a function function helper() { return

} function MyComponent(props: Props) { return helper(); } ``` The rule only works for locally defined props that are marked with a `$ReadOnly` or using covariant notation. It doesn't work with imported props: ```js // the rule has no way of knowing whether ImportedProps are read-only import { type ImportedProps } from './somewhere'; class Foo extends React.Component { } // the rule also checks for covariant properties type Props = {| +foo: string |}; class Bar extends React.Component { } // this fails because the object is not fully read-only type Props = {| +foo: string, bar: number, |}; class Bar extends React.Component { } // this fails because spreading makes object mutable (as of Flow 0.98) // https://github.com/gajus/eslint-plugin-flowtype/pull/400#issuecomment-489813899 type Props = {| +foo: string, ...bar, |}; class Bar extends React.Component { } ``` ```js { "rules": { "ft-flow/require-readonly-react-props": 2 } } ``` Optionally, you can enable support for [implicit exact Flow types](https://medium.com/flow-type/on-the-roadmap-exact-objects-by-default-16b72933c5cf) (useful when using `exact_by_default=true` Flow option): ```js { "rules": { "ft-flow/require-readonly-react-props": [ 2, { "useImplicitExactTypes": true } ] } } ``` The following patterns are considered problems: ```js type Props = { }; class Foo extends React.Component { } // Message: Props must be $ReadOnly type OtherProps = { foo: string }; class Foo extends React.Component { } // Message: OtherProps must be $ReadOnly class Foo extends React.Component<{}> { } // Message: Foo class props must be $ReadOnly type Props = { bar: {} }; class Foo extends React.Component { } // Message: Props must be $ReadOnly type Props = { }; class Foo extends Component { } // Message: Props must be $ReadOnly type Props = { }; class Foo extends PureComponent { } // Message: Props must be $ReadOnly export type Props = {}; class Foo extends Component { } // Message: Props must be $ReadOnly type Props = {| foo: string |}; class Foo extends Component { } // Message: Props must be $ReadOnly type Props = {| foo: string |} | {| bar: number |}; class Foo extends Component { } // Message: Props must be $ReadOnly // Options: [{"useImplicitExactTypes":true}] type Props = { foo: string } | { bar: number }; class Foo extends Component { } // Message: Props must be $ReadOnly type Props = {| +foo: string, ...bar |}; class Foo extends Component { } // Message: Props must be $ReadOnly type Props = {| +foo: string, -bar: number |}; class Foo extends Component { } // Message: Props must be $ReadOnly type Props = { }; function Foo(props: Props) { return

} // Message: Props must be $ReadOnly type Props = { }; function Foo(props: Props) { return foo ?

: } // Message: Props must be $ReadOnly function Foo(props: {}) { return

} // Message: Foo component props must be $ReadOnly export type Props = {}; function Foo(props: Props) { return

} // Message: Props must be $ReadOnly ``` The following patterns are not considered problems: ```js class Foo extends React.Component<$ReadOnly<{}>> { } type Props = $ReadOnly<{}>; class Foo extends React.Component { } type Props = $ReadOnly<{}>; class Foo extends React.PureComponent { } class Foo extends React.Component<$ReadOnly<{}, State>> { } type Props = $ReadOnly<{}>; class Foo extends React.Component { } type Props = $ReadOnly<{}>; class Foo extends Component { } type Props = $ReadOnly<{}>; class Foo extends PureComponent { } type FooType = {}; class Foo extends Bar { } class Foo { } export type Props = $ReadOnly<{}>; class Foo extends Component { } export type Props = $ReadOnly<{}>; export class Foo extends Component { } type Props = {| +foo: string |}; class Foo extends Component { } type Props = {| +foo: string, +bar: number |}; class Foo extends Component { } type Props = {| +foo: string |} | {| +bar: number |}; class Foo extends Component { } // Options: [{"useImplicitExactTypes":true}] type Props = { +foo: string } | { +bar: number }; class Foo extends Component { } type Props = $FlowFixMe; class Foo extends Component { } type Props = {||}; class Foo extends Component { } // Options: [{"useImplicitExactTypes":true}] type Props = {||}; class Foo extends Component { } // Options: [{"useImplicitExactTypes":true}] type Props = {}; class Foo extends Component { } class Foo extends Component<{||}> { } // Options: [{"useImplicitExactTypes":true}] class Foo extends Component<{||}> { } // Options: [{"useImplicitExactTypes":true}] class Foo extends Component<{}> { } class Foo extends React.Component { } import { type Props } from "file"; class Foo extends React.Component { } type Props = {}; function Foo() { } type Props = $ReadOnly<{}>; function Foo(props: Props) { } type Props = {}; function Foo(props: OtherProps) { } function Foo() { return

} function Foo(props: $FlowFixMe) { return

} function Foo(props: {||}) { return

} // Options: [{"useImplicitExactTypes":true}] function Foo(props: {||}) { return

} // Options: [{"useImplicitExactTypes":true}] function Foo(props: {}) { return

} ``` ### `require-return-type` Requires that functions have return type annotation. #### Options You can skip all arrow functions by providing the `excludeArrowFunctions` option with `true`. Alternatively, you can exclude a concise arrow function (e.g. `() => 2`). Provide `excludeArrowFunctions` with `expressionsOnly` for this. ```js { "rules": { "ft-flow/require-return-type": [ 2, "always", { "excludeArrowFunctions": true } ] } } { "rules": { "ft-flow/require-return-type": [ 2, "always", { "excludeArrowFunctions": "expressionsOnly" } ] } } ``` You can exclude or include specific tests with the `includeOnlyMatching` and `excludeMatching` rules. ```js { "rules": { "ft-flow/require-return-type": [ 2, "always", { "includeOnlyMatching": [ "^F.*", "Ba(r|z)" ] } ] } } { "rules": { "ft-flow/require-return-type": [ 2, "always", { "excludeMatching": [ "^F.*", "Ba(r|z)" ] } ] } } ``` Both rules take an array that can contain either strings or valid RegExp statements. The following patterns are considered problems: ```js (foo) => { return "foo"; } // Message: Missing return type annotation. // Options: ["always"] (foo) => { return "foo"; } // Message: Missing return type annotation. // Options: ["always"] (foo) => "foo" // Message: Missing return type annotation. (foo) => ({}) // Message: Missing return type annotation. /* @flow */ (foo) => { return 1; } // Message: Missing return type annotation. (foo): undefined => { return; } // Message: Must not annotate undefined return type. (foo): void => { return; } // Message: Must not annotate undefined return type. (foo): undefined => { return undefined; } // Message: Must not annotate undefined return type. (foo): void => { return void 0; } // Message: Must not annotate undefined return type. // Options: ["always",{"annotateUndefined":"never"}] (foo): undefined => { return; } // Message: Must not annotate undefined return type. // Options: ["always",{"annotateUndefined":"never"}] (foo): void => { return; } // Message: Must not annotate undefined return type. // Options: ["always",{"annotateUndefined":"always"}] (foo) => { return; } // Message: Must annotate undefined return type. // Options: ["always",{"annotateUndefined":"never"}] (foo): undefined => { return undefined; } // Message: Must not annotate undefined return type. // Options: ["always",{"annotateUndefined":"always"}] (foo) => { return undefined; } // Message: Must annotate undefined return type. // Options: ["always",{"annotateUndefined":"always"}] (foo) => { return void 0; } // Message: Must annotate undefined return type. // Settings: {"ft-flow":{"onlyFilesWithFlowAnnotation":true}} // @flow (foo) => { return 1; } // Message: Missing return type annotation. // Options: ["always",{"annotateUndefined":"always"}] // Settings: {"ft-flow":{"onlyFilesWithFlowAnnotation":true}} // @flow (foo) => { return undefined; } // Message: Must annotate undefined return type. // Options: ["always"] async () => { return 2; } // Message: Missing return type annotation. // Options: ["always",{"annotateUndefined":"always"}] async () => {} // Message: Must annotate undefined return type. // Options: ["always",{"annotateUndefined":"always"}] async function x() {} // Message: Must annotate undefined return type. // Options: ["always",{"annotateUndefined":"never"}] async (): Promise => { return; } // Message: Must not annotate undefined return type. // Options: ["always",{"annotateUndefined":"never"}] async (): Promise => { return; } // Message: Must not annotate undefined return type. // Options: ["always",{"annotateUndefined":"always"}] class Test { constructor() { } } // Message: Must annotate undefined return type. class Test { foo() { return 42; } } // Message: Missing return type annotation. class Test { foo = () => { return 42; } } // Message: Missing return type annotation. class Test { foo = () => 42; } // Message: Missing return type annotation. // Options: ["always"] function* x() {} // Message: Missing return type annotation. // Options: ["always",{"excludeArrowFunctions":"expressionsOnly"}] () => { return 3; } // Message: Missing return type annotation. // Options: ["always",{"excludeArrowFunctions":"expressionsOnly"}] async () => { return 4; } // Message: Missing return type annotation. // Options: ["always",{"includeOnlyMatching":["bar"]}] function foo() { return 42; } function bar() { return 42; } // Message: Missing return type annotation. // Options: ["always",{"includeOnlyMatching":["bar"]}] const foo = () => { return 42; }; const bar = () => { return 42; } // Message: Missing return type annotation. // Options: ["always",{"includeOnlyMatching":["bar"]}] const foo = { bar() { return 42; }, foobar: function() { return 42; } } // Message: Missing return type annotation. // Message: Missing return type annotation. // Options: ["always",{"excludeMatching":["bar"]}] const foo = { bar() { return 42; }, baz() { return 42; } } // Message: Missing return type annotation. // Options: ["always",{"annotateUndefined":"always"}] function * foo() { yield 2; } // Message: Missing return type annotation. // Options: ["always",{"annotateUndefined":"always"}] async function * foo() { yield 2; } // Message: Missing return type annotation. ``` The following patterns are not considered problems: ```js return; (foo): string => {} const f: Foo = (a, b) => 42; // Options: ["always"] (foo): string => {} type fn = (a: string, b: number) => number; const f: fn = (a, b) => { return 42; } (foo) => { return; } (foo): Object => ( {} ) (foo) => { return undefined; } (foo) => { return void 0; } // Options: ["always",{"annotateUndefined":"always"}] (foo): undefined => { return; } // Options: ["always",{"annotateUndefined":"always"}] (foo): void => { return; } // Options: ["always",{"annotateUndefined":"never"}] (foo) => { return; } // Options: ["always",{"annotateUndefined":"never"}] (foo) => { return undefined; } // Options: ["always",{"annotateUndefined":"never"}] (foo) => { return void 0; } // Options: ["always",{"annotateUndefined":"always"}] (foo): undefined => { return undefined; } // Options: ["always",{"annotateUndefined":"always"}] (foo): void => { return void 0; } // Options: ["always"] // Settings: {"ft-flow":{"onlyFilesWithFlowAnnotation":true}} (foo) => { return 1; } // Options: ["always"] /* @noflow */ (foo) => { return 1; } // Options: ["always",{"annotateUndefined":"always"}] // Settings: {"ft-flow":{"onlyFilesWithFlowAnnotation":true}} (foo) => { return undefined; } // Options: ["always",{"annotateUndefined":"always"}] async function doThing(): Promise {} // Options: ["always",{"annotateUndefined":"ignore"}] async function doThing(): Promise {} // Options: ["always",{"annotateUndefined":"ignore"}] async function doThing() {} // Options: ["always",{"annotateUndefined":"always"}] function* doThing(): Generator { yield 2; } // Options: ["always",{"annotateUndefined":"always","excludeMatching":["constructor"]}] class Test { constructor() { } } class Test { constructor() { } } // Options: ["always",{"excludeMatching":["foo"]}] class Test { foo() { return 42; } } // Options: ["always",{"excludeMatching":["foo"]}] class Test { foo = () => { return 42; } } // Options: ["always",{"excludeMatching":["foo"]}] class Test { foo = () => 42; } class Test { foo = (): number => { return 42; } } class Test { foo = (): number => 42; } async (foo): Promise => { return 3; } // Options: ["always",{"excludeArrowFunctions":true}] () => 3 // Options: ["always",{"excludeArrowFunctions":true}] () => { return 4; } // Options: ["always",{"excludeArrowFunctions":true}] () => undefined // Options: ["always",{"annotateUndefined":"always","excludeArrowFunctions":true}] () => undefined // Options: ["always",{"annotateUndefined":"always","excludeArrowFunctions":true}] () => { return undefined; } // Options: ["always",{"excludeArrowFunctions":"expressionsOnly"}] () => 3 // Options: ["always",{"excludeArrowFunctions":"expressionsOnly"}] async () => 3 // Options: ["always",{"excludeMatching":["foo"]}] function foo() { return 42; } // Options: ["always",{"includeOnlyMatching":["bar"]}] function foo() { return 42; } // Options: ["always",{"excludeMatching":["bar"]}] function foo(): number { return 42; } function bar() { return 42; } // Options: ["always",{"includeOnlyMatching":["foo","baz"]}] function foo(): number { return 42; } function bar() { return 42; } // Options: ["always",{"excludeMatching":["^b.*","qux"]}] function foo(): number { return 42; } function bar() { return 42; } // Options: ["always",{"includeOnlyMatching":["^f.*"]}] function foo(): number { return 42; } function bar() { return 42; } // Options: ["always",{"includeOnlyMatching":["bar"]}] const foo = { baz() { return 42; } } // Options: ["always",{"excludeMatching":["bar"]}] const foo = { bar() { return 42; } } // Options: ["always",{"annotateUndefined":"always"}] function * foo(): Iterable { yield 2; } // Options: ["always",{"annotateUndefined":"always"}] async function * foo(): AsyncIterable { yield 2; } ``` ### `require-types-at-top` Requires all type declarations to be at the top of the file, after any import declarations. #### Options The rule has a string option: * `"never"` * `"always"` The default value is `"always"`. The following patterns are considered problems: ```js const foo = 3; type Foo = number; // Message: All type declaration must be at the top of the file, after any import declarations. const foo = 3; opaque type Foo = number; // Message: All type declaration must be at the top of the file, after any import declarations. const foo = 3; export type Foo = number; // Message: All type declaration must be at the top of the file, after any import declarations. const foo = 3; export opaque type Foo = number; // Message: All type declaration must be at the top of the file, after any import declarations. const foo = 3; type Foo = number | string; // Message: All type declaration must be at the top of the file, after any import declarations. import bar from "./bar"; const foo = 3; type Foo = number; // Message: All type declaration must be at the top of the file, after any import declarations. ``` The following patterns are not considered problems: ```js type Foo = number; const foo = 3; opaque type Foo = number; const foo = 3; export type Foo = number; const foo = 3; export opaque type Foo = number; const foo = 3; type Foo = number; const foo = 3; import bar from "./bar"; type Foo = number; type Foo = number; import bar from "./bar"; // Options: ["never"] const foo = 3; type Foo = number; ``` ### `require-valid-file-annotation` This rule validates Flow file annotations. This rule can optionally report missing or missed placed annotations, common typos (e.g. `// @floww`), and enforce a consistent annotation style. #### Options The rule has a string option: * `"never"` (default): Never report files that are missing an `@flow` annotation. * `"always"`: Always report files that are missing an `@flow` annotation This rule has an object option: * `"annotationStyle"` - Enforce a consistent file annotation style. * `"none"` (default): Either annotation style is accepted. * `"line"`: Require single line annotations (i.e. `// @flow`). * `"block"`: Require block annotations (i.e. `/* @flow */`). * `"strict"` - Enforce a strict flow file annotation. * `false` (default): strict flow annotation is not required. * `true`: Require strict flow annotation (i.e. `// @flow strict`). ```js { "rules": { "ft-flow/require-valid-file-annotation": [ 2, "always" ] } } { "rules": { "ft-flow/require-valid-file-annotation": [ 2, "always", { "annotationStyle": "block", "strict": true, } ] } } ``` The following patterns are considered problems: ```js // Options: ["always"] #!/usr/bin/env node // Message: Flow file annotation is missing. // Options: ["always"] #!/usr/bin/env node a; // Message: Flow file annotation is missing. ;// @flow // Message: Flow file annotation not at the top of the file. ; // @flow // Message: Flow file annotation not at the top of the file. // @Flow // Message: Malformed Flow file annotation. // @NoFlow // Message: Malformed Flow file annotation. // @Noflow // Message: Malformed Flow file annotation. // @floweeeeeee // Message: Misspelled or malformed Flow file annotation. // @nofloweeeeeee // Message: Misspelled or malformed Flow file annotation. // Options: ["always"] a; // Message: Flow file annotation is missing. // Options: ["always",{"annotationStyle":"line"}] /* @flow */ // Message: Flow file annotation style must be `// @flow` // Options: ["always",{"annotationStyle":"block"}] // @flow // Message: Flow file annotation style must be `/* @flow */` // Options: ["always",{"annotationStyle":"block"}] // @flow // Message: Flow file annotation style must be `/* @flow */` // Options: ["always",{"annotationStyle":"line","strict":true}] // @flow // Message: Strict Flow file annotation is required, must be `// @flow strict` // Options: ["always",{"annotationStyle":"line"}] /* @noflow */ // Message: Flow file annotation style must be `// @noflow` // Options: ["always",{"annotationStyle":"block"}] // @noflow // Message: Flow file annotation style must be `/* @noflow */` // Options: ["always"] a; // Message: Flow file annotation is missing. // Options: ["always",{"annotationStyle":"block"}] a; // Message: Flow file annotation is missing. // Options: ["always",{"annotationStyle":"line","strict":true}] a; // Message: Flow file annotation is missing. // Options: ["always",{"annotationStyle":"line","strict":true}] // @flow a; b; // Message: Strict Flow file annotation is required, must be `// @flow strict` // Options: ["never",{"annotationStyle":"line"}] /* @flow */ a; b; // Message: Flow file annotation style must be `// @flow` // Options: ["never",{"annotationStyle":"line"}] /* @flow strict */ a; b; // Message: Flow file annotation style must be `// @flow strict` ``` The following patterns are not considered problems: ```js a; // @flow a; //@flow a; //**@flow a; /* foo @flow bar */ a; // @flow a; // @flow // @FLow // @noflow a; // Options: ["always"] // Settings: {"ft-flow":{"onlyFilesWithFlowAnnotation":true}} a; // Options: ["always",{"annotationStyle":"line"}] // @flow // Options: ["always",{"annotationStyle":"line","strict":true}] // @noflow // Options: ["always",{"annotationStyle":"line","strict":true}] // @flow strict // Options: ["never",{"annotationStyle":"none"}] // @function // Options: ["never"] // @fixable // Options: ["always",{"annotationStyle":"block"}] /* @flow */ ``` ### `require-variable-type` Requires that all variable declarators have type annotations. #### Options You can exclude variables that match a certain regex by using `excludeVariableMatch`. This excludes all parameters that start with an underscore (`_`). The default pattern is `a^`, which doesn't match anything, i.e., all parameters are checked. ```js { "rules": { "ft-flow/require-variable-type": [ 2, { "excludeVariableMatch": "^_" } ] } } ``` You can choose specific variable types (`var`, `let`, and `const`) to ignore using `excludeVariableTypes`. This excludes `var` and `let` declarations from needing type annotations, but forces `const` declarations to have it. By default, all declarations are checked. ```js { "rules": { "ft-flow/require-variable-type": [ 2, { "excludeVariableTypes": { "var": true, "let": true, "const": false, } } ] } } ``` The following patterns are considered problems: ```js var foo = "bar" // Message: Missing "foo" variable type annotation. var foo : string = "bar", bar = 1 // Message: Missing "bar" variable type annotation. // Options: [{"excludeVariableMatch":"^_"}] var _foo = "bar", bar = 1 // Message: Missing "bar" variable type annotation. // Options: [{"excludeVariableTypes":{"let":false,"var":true}}] var foo = "bar", bar = 1; const oob : string = "oob"; let hey = "yah" // Message: Missing "hey" variable type annotation. ``` The following patterns are not considered problems: ```js var foo : string = "bar" var foo : string = "bar", bar : number = 1 // Options: [{"excludeVariableMatch":"^_"}] var _foo = "bar", bar : number = 1 // Options: [{"excludeVariableTypes":{"var":true}}] var foo = "bar", bar = 1 // Options: [{"excludeVariableTypes":{"let":true,"var":true}}] var foo = "bar", bar = 1; const oob : string = "oob"; let hey = "yah" ``` ### `semi` _The `--fix` option on the command line automatically fixes problems reported by this rule._ Enforces consistent use of semicolons after type aliases. This rule takes one argument. If it is `'never'` then a problem is raised when there is a semicolon after a type alias. If it is `'always'` then a problem is raised when there is no semicolon after a type alias. The default value is `'always'`. The following patterns are considered problems: ```js // Options: ["always"] class Foo { foo: string } // Message: Missing semicolon. // Options: ["never"] class Foo { foo: string; } // Message: Extra semicolon. // Options: [] type FooType = {} // Message: Missing semicolon. // Options: ["always"] type FooType = {} // Message: Missing semicolon. // Options: ["never"] type FooType = {}; // Message: Extra semicolon. // Options: [] opaque type FooType = {} // Message: Missing semicolon. ``` The following patterns are not considered problems: ```js type FooType = {}; // Options: ["always"] type FooType = {}; // Options: ["always"] (foo: string) => {} // Options: ["always"] class Foo { foo: string; } // Options: ["never"] class Foo { foo: string } // Options: ["always"] type FooType = { a: number; b: string; }; // Options: ["never"] type FooType = { a: number; b: string; } // Options: ["never"] type FooType = {} // Settings: {"ft-flow":{"onlyFilesWithFlowAnnotation":true}} type FooType = {} opaque type FooType = {}; ``` ### `sort-keys` _The `--fix` option on the command line automatically fixes problems reported by this rule._ Enforces natural, case-insensitive sorting of Object annotations. #### Options The first option specifies sort order. * `"asc"` (default) - enforce ascending sort order. * `"desc"` - enforce descending sort order. ```js { "rules": { "ft-flow/sort-keys": [ 2, "asc" ] } } ``` The following patterns are considered problems: ```js type FooType = { a: number, c: number, b: string } // Message: Expected type annotations to be in ascending order. "b" must be before "c". // Options: ["desc"] type FooType = { a: number, b: number } // Message: Expected type annotations to be in descending order. "b" must be before "a". // Options: ["desc"] type FooType = { b: number, C: number, a: string } // Message: Expected type annotations to be in descending order. "C" must be before "b". // Options: ["asc"] type FooType = { a: number, c: number, C: number, b: string } // Message: Expected type annotations to be in ascending order. "b" must be before "C". // Options: ["asc"] type FooType = { a: number, C: number, c: number, b: string } // Message: Expected type annotations to be in ascending order. "b" must be before "c". // Options: ["asc"] type FooType = { 1: number, 10: number, 2: boolean } // Message: Expected type annotations to be in ascending order. "2" must be before "10". type FooType = { a: number, c: number, b: string } // Message: Expected type annotations to be in ascending order. "b" must be before "c". type FooType = { a: number, c: number, b: string, } // Message: Expected type annotations to be in ascending order. "b" must be before "c". type FooType = { a: $ReadOnlyArray, c: $ReadOnlyMap, b: Map>>, } // Message: Expected type annotations to be in ascending order. "b" must be before "c". type FooType = { ...ErrorsInRecursiveGenericTypeArgsButDoesNotFix<{ y: boolean, x: string, z: { j: string, l: number, k: boolean, }, }>, a: number, c: string, b: Map>>, } // Message: Expected type annotations to be in ascending order. "x" must be before "y". // Message: Expected type annotations to be in ascending order. "k" must be before "l". // Message: Expected type annotations to be in ascending order. "b" must be before "c". // Message: Expected type annotations to be in ascending order. "x" must be before "y". // Message: Expected type annotations to be in ascending order. "k" must be before "l". type FooType = { ...BPreservesSpreadOrder, ...APreservesSpreadOrder, c: string, b: number, } // Message: Expected type annotations to be in ascending order. "b" must be before "c". type FooType = { ...BPreservesSpreadSpans, ...APreservesSpreadSpans, c: string, b: number, ...CPreservesSpreadSpans, e: string, d: number, } // Message: Expected type annotations to be in ascending order. "b" must be before "c". // Message: Expected type annotations to be in ascending order. "d" must be before "e". type FooType = { ...BPreservesSpreadOrderAndTypeArgs, ...APreservesSpreadOrderAndTypeArgs, c: string, b: number, } // Message: Expected type annotations to be in ascending order. "b" must be before "c". type FooType = { /* preserves block comment before spread BType */ // preserves line comment before spread BType ... /* preserves comment in spread BType */ BType /* preserves trailing comment in spread AType */, /* preserves block comment before spread AType */ // preserves line comment before spread AType ... /* preserves comment in spread AType */ AType /* preserves trailing comment in spread AType */, /* preserves block comment before reordered key "c" */ // preserves line comment before reordered key "c" c:/* preserves comment and white space or lack of it */string/* preserves trailing comment for key "c" */, b: number, dWithoutComma: boolean } // Message: Expected type annotations to be in ascending order. "b" must be before "c". type FooType = { +a: number, c: number, b: string, } // Message: Expected type annotations to be in ascending order. "b" must be before "c". type FooType = { -a: number, c: number, b: string, } // Message: Expected type annotations to be in ascending order. "b" must be before "c". type FooType = { a?: number, c: ?number, b: string, } // Message: Expected type annotations to be in ascending order. "b" must be before "c". type FooType = { a: (number) => void, c: number, b: (param: string) => number, } // Message: Expected type annotations to be in ascending order. "b" must be before "c". type FooType = { a: number | string | boolean, c: number, b: (param: string) => number, } // Message: Expected type annotations to be in ascending order. "b" must be before "c". type FooType = { c: number, a: number | string | boolean, b: (param: string) => number, } // Message: Expected type annotations to be in ascending order. "a" must be before "c". type FooType = { c: { z: number, x: string, y: boolean, }, a: number | string | boolean, b: (param: string) => number, } // Message: Expected type annotations to be in ascending order. "x" must be before "z". // Message: Expected type annotations to be in ascending order. "a" must be before "c". type FooType = { c: { z: { j: string, l: number, k: boolean, }, x: string, y: boolean, }, a: number | string | boolean, b: (param: string) => number, } // Message: Expected type annotations to be in ascending order. "k" must be before "l". // Message: Expected type annotations to be in ascending order. "x" must be before "z". // Message: Expected type annotations to be in ascending order. "a" must be before "c". type FooType = { +c: number, -b: number, a: number, } // Message: Expected type annotations to be in ascending order. "b" must be before "c". // Message: Expected type annotations to be in ascending order. "a" must be before "b". type FooType = {| +c: number, -b: number, a: number, |} // Message: Expected type annotations to be in ascending order. "b" must be before "c". // Message: Expected type annotations to be in ascending order. "a" must be before "b". type FooType = { a(number): void, c: number, b(param: string): number, } // Message: Expected type annotations to be in ascending order. "b" must be before "c". type FooType = { a: number | string | boolean, c: number, b(param: string): number, } // Message: Expected type annotations to be in ascending order. "b" must be before "c". type FooType = { c: number, a: number | string | boolean, b(param: string): number, } // Message: Expected type annotations to be in ascending order. "a" must be before "c". type FooType = { c: { z: number, x: string, y: boolean, }, a: number | string | boolean, b(param: string): number, } // Message: Expected type annotations to be in ascending order. "x" must be before "z". // Message: Expected type annotations to be in ascending order. "a" must be before "c". type FooType = { c: { z: { j: string, l: number, k: boolean, }, x: string, y: boolean, }, a: number | string | boolean, b(param: string): number, } // Message: Expected type annotations to be in ascending order. "k" must be before "l". // Message: Expected type annotations to be in ascending order. "x" must be before "z". // Message: Expected type annotations to be in ascending order. "a" must be before "c". type FooType = { /* preserves block comment before a */ a: number | string | boolean, /* preserves block comment before c */ c: number, /* preserves block comment before b */ b(param: string): number, } // Message: Expected type annotations to be in ascending order. "b" must be before "c". export type GroupOrdersResponseType = {| isSuccess: boolean, code: number, message?: string, errorMessage: string, result: {| OrderNumber: string, Orders: GroupOrderSummaryType[], PlacedOn: string, Status: string, ReturnText: string, IncludesLegacyOrder: boolean |} |}; // Message: Expected type annotations to be in ascending order. "code" must be before "isSuccess". // Message: Expected type annotations to be in ascending order. "errorMessage" must be before "message". // Message: Expected type annotations to be in ascending order. "ReturnText" must be before "Status". // Message: Expected type annotations to be in ascending order. "IncludesLegacyOrder" must be before "ReturnText". ``` The following patterns are not considered problems: ```js type FooType = { a: number } type FooType = { a: number, b: number, c: (boolean | number) } type FooType = { a: string, b: foo, C: number } type FooType = { 1: number, 2: boolean, 10: number } // Options: ["desc"] type FooType = { c: number, b: number, a: number } // Options: ["desc"] type FooType = { C: number, b: string, a: {} } // Options: ["desc"] type FooType = { 10: number, 2: number, 1: boolean } // Settings: {"ft-flow":{"onlyFilesWithFlowAnnotation":true}} type FooType = { b: number, a: number } type FooType = { a: string, b(): number, c: boolean } type FooType = { a(): string, b: number, c: boolean } ``` ### `sort-type-union-intersection-members` _The `--fix` option on the command line automatically fixes problems reported by this rule._ Enforces that members of a type union/intersection are sorted alphabetically. #### Options You can specify the sort order using `order`. * `"asc"` (default) - enforce ascending sort order. * `"desc"` - enforce descending sort order. ```js { "rules": { "ft-flow/sort-type-union-intersection-members": [ 2, { "order": "asc" } ] } } ``` You can disable checking intersection types using `checkIntersections`. * `true` (default) - enforce sort order of intersection members. * `false` - do not enforce sort order of intersection members. ```js { "rules": { "ft-flow/sort-type-union-intersection-members": [ 2, { "checkIntersections": true } ] } } ``` You can disable checking union types using `checkUnions`. * `true` (default) - enforce sort order of union members. * `false` - do not enforce sort order of union members. ```js { "rules": { "ft-flow/sort-type-union-intersection-members": [ 2, { "checkUnions": true } ] } } ``` You can specify the ordering of groups using `groupOrder`. Each member of the type is placed into a group, and then the rule sorts alphabetically within each group. The ordering of groups is determined by this option. * `keyword` - Keyword types (`any`, `string`, etc) * `named` - Named types (`A`, `A['prop']`, `B[]`, `Array`) * `literal` - Literal types (`1`, `'b'`, `true`, etc) * `function` - Function types (`() => void`) * `object` - Object types (`{ a: string }`, `{ [key: string]: number }`) * `tuple` - Tuple types (`[A, B, C]`) * `intersection` - Intersection types (`A & B`) * `union` - Union types (`A | B`) * `nullish` - `null` and `undefined` ```js { "rules": { "ft-flow/sort-type-union-intersection-members": [ 2, { "groupOrder": [ 'keyword', 'named', 'literal', 'function', 'object', 'tuple', 'intersection', 'union', 'nullish', ] } ] } } ``` The following patterns are considered problems: ```js type T1 = B | A; // Message: Expected union members to be in ascending order. "A" should be before "B". type T2 = { b: string } & { a: string }; // Message: Expected intersection members to be in ascending order. "{ a: string }" should be before "{ b: string }". type T3 = [1, 2, 4] & [1, 2, 3]; // Message: Expected intersection members to be in ascending order. "[1, 2, 3]" should be before "[1, 2, 4]". type T4 = | [1, 2, 4] | [1, 2, 3] | { b: string } | { a: string } | (() => void) | (() => string) | 'b' | 'a' | 'b' | 'a' | string[] | number[] | B | A | string | any; // Message: Expected union members to be in ascending order. "[1, 2, 3]" should be before "[1, 2, 4]". // Message: Expected union members to be in ascending order. "{ b: string }" should be before "[1, 2, 3]". // Message: Expected union members to be in ascending order. "{ a: string }" should be before "{ b: string }". // Message: Expected union members to be in ascending order. "() => void" should be before "{ a: string }". // Message: Expected union members to be in ascending order. "() => string" should be before "() => void". // Message: Expected union members to be in ascending order. "'b'" should be before "() => string". // Message: Expected union members to be in ascending order. "'a'" should be before "'b'". // Message: Expected union members to be in ascending order. "'b'" should be before "'a'". // Message: Expected union members to be in ascending order. "'a'" should be before "'b'". // Message: Expected union members to be in ascending order. "string[]" should be before "'a'". // Message: Expected union members to be in ascending order. "number[]" should be before "string[]". // Message: Expected union members to be in ascending order. "B" should be before "number[]". // Message: Expected union members to be in ascending order. "A" should be before "B". // Message: Expected union members to be in ascending order. "string" should be before "A". // Message: Expected union members to be in ascending order. "any" should be before "string". ``` The following patterns are not considered problems: ```js type T1 = A | B; type T2 = { a: string } & { b: string }; type T3 = [1, 2, 3] & [1, 2, 4]; type T4 = | any | string | A | B | number[] | string[] | 'a' | 'a' | 'b' | 'b' | (() => string) | (() => void) | { a: string } | { b: string } | [1, 2, 3] | [1, 2, 4]; ``` ### `space-after-type-colon` _The `--fix` option on the command line automatically fixes problems reported by this rule._ Enforces consistent spacing after the type annotation colon. #### Options This rule has a string argument. * `"always"` (default): Require a space after the type annotation colon (e.g. foo: BarType). * `"never"`: Require no spaces after the type annotation colon (e.g. foo:BarType). This rule has an option object. * `"allowLineBreak"` - Allow a line break to count as a space following the annotation colon. * `"true"`: Enable * `"false"`: Disable ```js { "rules": { "ft-flow/space-after-type-colon": [ 2, "always", { "allowLineBreak": false } ] } } ``` The following patterns are considered problems: ```js // Options: ["never"] (foo: string) => {} // Message: There must be no space after "foo" parameter type annotation colon. // Options: ["always"] (foo: string) => {} // Message: There must be 1 space after "foo" parameter type annotation colon. // Options: ["always"] (foo:(() => void)) => {} // Message: There must be a space after "foo" parameter type annotation colon. // Options: ["never"] (foo: (() => void)) => {} // Message: There must be no space after "foo" parameter type annotation colon. // Options: ["always"] (foo: (() => void)) => {} // Message: There must be 1 space after "foo" parameter type annotation colon. ({ lorem, ipsum, dolor } : SomeType) => {} // Message: There must be 1 space after "{ lorem, ipsum, dolor }" parameter type annotation colon. (foo:{ a: string, b: number }) => {} // Message: There must be a space after "foo" parameter type annotation colon. ({ a, b } :{ a: string, b: number }) => {} // Message: There must be a space after "{ a, b }" parameter type annotation colon. ([ a, b ] :string[]) => {} // Message: There must be a space after "[ a, b ]" parameter type annotation colon. (i?:number) => {} // Message: There must be a space after "i" parameter type annotation colon. (i?: number) => {} // Message: There must be 1 space after "i" parameter type annotation colon. // Options: ["never"] (i?: number) => {} // Message: There must be no space after "i" parameter type annotation colon. (foo: { a: string, b: number }) => {} // Message: There must not be a line break after "foo" parameter type annotation colon. (foo: { a: string, b: number }) => {} // Message: There must not be a line break after "foo" parameter type annotation colon. (foo: { a: string, b: number }) => {} // Message: There must not be a line break after "foo" parameter type annotation colon. // Options: ["always"] ():Object => {} // Message: There must be a space after return type colon. // Options: ["never"] (): Object => {} // Message: There must be no space after return type colon. // Options: ["always"] (): Object => {} // Message: There must be 1 space after return type colon. // Options: ["always"] ():(() => void) => {} // Message: There must be a space after return type colon. // Options: ["never"] (): (() => void) => {} // Message: There must be no space after return type colon. // Options: ["always"] (): (() => void) => {} // Message: There must be 1 space after return type colon. // Options: ["never"] export default function (foo: string) {} // Message: There must be no space after "foo" parameter type annotation colon. // Options: ["never"] function foo (foo: string) {} // Message: There must be no space after "foo" parameter type annotation colon. // Options: ["always"] (foo:string) => {} // Message: There must be a space after "foo" parameter type annotation colon. function foo (foo:string) {} // Message: There must be a space after "foo" parameter type annotation colon. async function foo({ lorem, ipsum, dolor }:SomeType) {} // Message: There must be a space after "{ lorem, ipsum, dolor }" parameter type annotation colon. function x(i?:number) {} // Message: There must be a space after "i" parameter type annotation colon. function x(i?: number) {} // Message: There must be 1 space after "i" parameter type annotation colon. // Options: ["never"] function x(i?: number) {} // Message: There must be no space after "i" parameter type annotation colon. function a():x {} // Message: There must be a space after return type colon. // Options: ["always"] function a(): x {} // Message: There must be 1 space after return type colon. // Options: ["never"] function a(): x {} // Message: There must be no space after return type colon. type X = (foo:number) => string // Message: There must be a space after "foo" parameter type annotation colon. // Options: ["never"] type X = (foo: number) => string // Message: There must be no space after "foo" parameter type annotation colon. type X = (foo: number) => string // Message: There must be 1 space after "foo" parameter type annotation colon. type X = (foo:?number) => string // Message: There must be a space after "foo" parameter type annotation colon. type X = (foo:(number)) => string // Message: There must be a space after "foo" parameter type annotation colon. type X = (foo:((number))) => string // Message: There must be a space after "foo" parameter type annotation colon. type X = (foo: ((number))) => string // Message: There must be 1 space after "foo" parameter type annotation colon. // Options: ["never"] type X = (foo: ((number))) => string // Message: There must be no space after "foo" parameter type annotation colon. type X = (foo:?(number)) => string // Message: There must be a space after "foo" parameter type annotation colon. type TArrayPredicate = (el: T, i?:number) => boolean // Message: There must be a space after "i" parameter type annotation colon. type TArrayPredicate = (el: T, i?: number) => boolean // Message: There must be 1 space after "i" parameter type annotation colon. // Options: ["never"] type TArrayPredicate = (el:T, i?: number) => boolean // Message: There must be no space after "i" parameter type annotation colon. class X { foo:string } // Message: There must be a space after "foo" class property type annotation colon. // Options: ["never"] class X { foo: string } // Message: There must be no space after "foo" class property type annotation colon. class X { foo:?string } // Message: There must be a space after "foo" class property type annotation colon. // Options: ["never"] class X { foo: ?string } // Message: There must be no space after "foo" class property type annotation colon. class X { static foo:number } // Message: There must be a space after "foo" class property type annotation colon. // Options: ["never"] class X { static foo: number } // Message: There must be no space after "foo" class property type annotation colon. class X { static foo :number } // Message: There must be a space after "foo" class property type annotation colon. // Options: ["never"] class X { static foo : number } // Message: There must be no space after "foo" class property type annotation colon. declare class X { static foo:number } // Message: There must be a space after "foo" type annotation colon. // Options: ["never"] declare class X { static foo: number } // Message: There must be no space after "foo" type annotation colon. declare class X { static foo :number } // Message: There must be a space after "foo" type annotation colon. // Options: ["never"] declare class X { static foo : number } // Message: There must be no space after "foo" type annotation colon. class X { +foo:string } // Message: There must be a space after "foo" class property type annotation colon. class X { +foo: string } // Message: There must be 1 space after "foo" class property type annotation colon. // Options: ["never"] class X { +foo: string } // Message: There must be no space after "foo" class property type annotation colon. class X { static +foo:string } // Message: There must be a space after "foo" class property type annotation colon. class X { static +foo: string } // Message: There must be 1 space after "foo" class property type annotation colon. // Options: ["never"] class X { static +foo: string } // Message: There must be no space after "foo" class property type annotation colon. type X = { foo:string } // Message: There must be a space after "foo" type annotation colon. // Options: ["always"] type X = { foo:string } // Message: There must be a space after "foo" type annotation colon. // Options: ["never"] type X = { foo: string } // Message: There must be no space after "foo" type annotation colon. type X = { foo: string } // Message: There must be 1 space after "foo" type annotation colon. type X = { foo?:string } // Message: There must be a space after "foo" type annotation colon. // Options: ["never"] type X = { foo?: string } // Message: There must be no space after "foo" type annotation colon. type X = { foo?:?string } // Message: There must be a space after "foo" type annotation colon. type X = { foo?: ?string } // Message: There must be 1 space after "foo" type annotation colon. type Foo = { barType:(string | () => void) } // Message: There must be a space after "barType" type annotation colon. type Foo = { barType:(((string | () => void))) } // Message: There must be a space after "barType" type annotation colon. // Options: ["never"] type Foo = { barType: (string | () => void) } // Message: There must be no space after "barType" type annotation colon. type Foo = { barType: (string | () => void) } // Message: There must be 1 space after "barType" type annotation colon. type Foo = { barType: ((string | () => void)) } // Message: There must be 1 space after "barType" type annotation colon. type X = { get:() => A; } // Message: There must be a space after "get" type annotation colon. type X = { get:() => A; } // Message: There must be a space after "get" type annotation colon. // Options: ["never"] type X = { get: () => A; } // Message: There must be no space after "get" type annotation colon. // Options: ["never"] type X = { get: () => A; } // Message: There must be no space after "get" type annotation colon. type X = { get: () => A; } // Message: There must be 1 space after "get" type annotation colon. type X = { get: () => A; } // Message: There must be 1 space after "get" type annotation colon. type X = { +foo:string } // Message: There must be a space after "foo" type annotation colon. type X = { +foo: string } // Message: There must be 1 space after "foo" type annotation colon. // Options: ["never"] type X = { +foo: string } // Message: There must be no space after "foo" type annotation colon. type X = { +foo?:string } // Message: There must be a space after "foo" type annotation colon. type X = { +foo?: string } // Message: There must be 1 space after "foo" type annotation colon. // Options: ["never"] type X = { +foo?: string } // Message: There must be no space after "foo" type annotation colon. // Options: ["always"] type X = { [a:b]: c } // Message: There must be a space after type annotation colon. // Options: ["never"] type X = { [a: b]:c } // Message: There must be no space after type annotation colon. // Options: ["always"] type X = { [a: b]: c } // Message: There must be 1 space after type annotation colon. // Options: ["always"] type X = { +[a:b]: c } // Message: There must be a space after type annotation colon. // Options: ["never"] type X = { +[a: b]:c } // Message: There must be no space after type annotation colon. // Options: ["always"] type X = { +[a: b]: c } // Message: There must be 1 space after type annotation colon. // Options: ["always"] type X = { [a: b]:c } // Message: There must be a space after type annotation colon. // Options: ["never"] type X = { [a:b]: c } // Message: There must be no space after type annotation colon. // Options: ["always"] type X = { [a: b]: c } // Message: There must be 1 space after type annotation colon. // Options: ["always"] type X = { [a:b]:c } // Message: There must be a space after type annotation colon. // Message: There must be a space after type annotation colon. // Options: ["never"] type X = { [a: b]: c } // Message: There must be no space after type annotation colon. // Message: There must be no space after type annotation colon. // Options: ["always"] type X = { [a: b]: c } // Message: There must be 1 space after type annotation colon. // Message: There must be 1 space after type annotation colon. // Options: ["always"] type X = { [a:(b)]:(c) } // Message: There must be a space after type annotation colon. // Message: There must be a space after type annotation colon. // Options: ["never"] type X = { [a: (b)]: (c) } // Message: There must be no space after type annotation colon. // Message: There must be no space after type annotation colon. // Options: ["never"] const x = ({}: {}) // Message: There must be no space after type cast colon. // Options: ["always"] const x = ({}:{}) // Message: There must be a space after type cast colon. // Options: ["always"] const x = ({}: {}) // Message: There must be 1 space after type cast colon. // Options: ["never"] ((x): (string)) // Message: There must be no space after type cast colon. // Options: ["always"] ((x):(string)) // Message: There must be a space after type cast colon. // Options: ["always"] ((x): (string)) // Message: There must be 1 space after type cast colon. // Options: ["always"] const x:number = 7; // Message: There must be a space after const type annotation colon. // Options: ["always"] let x:number = 42; // Message: There must be a space after let type annotation colon. // Options: ["always"] var x:number = 42; // Message: There must be a space after var type annotation colon. ``` The following patterns are not considered problems: ```js (foo) => {} (foo: string) => {} (foo: (string|number)) => {} // Options: ["never"] (foo:string) => {} // Options: ["always"] (foo: string) => {} // Options: ["never"] (foo:(() => void)) => {} // Options: ["always"] (foo: (() => void)) => {} ({ lorem, ipsum, dolor }: SomeType) => {} (foo: { a: string, b: number }) => {} ({ a, b }: ?{ a: string, b: number }) => {} ([ a, b ]: string[]) => {} (i?: number) => {} // Options: ["never"] (i?:number) => {} // Options: ["always",{"allowLineBreak":true}] (foo: { a: string, b: number }) => {} // Options: ["always",{"allowLineBreak":true}] (foo: { a: string, b: number }) => {} // Options: ["never"] ():Object => {} // Options: ["always"] (): Object => {} // Options: ["never"] ():(number | string) => {} // Options: ["always"] (): (number | string) => {} // Options: ["never"] ():number|string => {} // Options: ["always"] (): number|string => {} // Options: ["never"] ():(() => void) => {} // Options: ["always"] (): (() => void) => {} // Options: ["never"] ():( () => void ) => {} // Options: ["always"] (): ( () => void ) => {} (): { a: number, b: string } => {} // Options: ["never"] () :{ a:number, b:string } => {} function x(foo: string) {} class Foo { constructor(foo: string) {} } // Options: ["never"] function x(foo:string) {} // Options: ["never"] class Foo { constructor(foo:string) {} } async function foo({ lorem, ipsum, dolor }: SomeType) {} function x({ a, b }: { a: string, b: number }) {} function x(i?: number) {} // Options: ["never"] function x(i?:number) {} function a(): x {} // Options: ["never"] function a():x {} function a(): (number | string) {} // Options: ["never"] function a() :(number | string) {} type X = (foo: number) => string; type X = (foo : number) => string; type X = (foo: ?number) => string; type X = (foo? : ?number) => string; type X = (foo: ?{ x: number }) => string; // Options: ["never"] type X = (foo:number) => string; // Options: ["never"] type X = (foo:?{ x:number }) => string; type X = (foo: (number)) => string type X = (foo: ((number))) => string // Options: ["never"] type X = (foo:((number))) => string type X = ?(foo: ((number))) => string // Options: ["never"] type X = ?(foo:((number))) => string type TArrayPredicate = (el: T, i?: number) => boolean // Options: ["never"] type TArrayPredicate = (el:T, i?:number) => boolean type X = (number) => string; type X = (?number) => string; type X = number => string; type X = ?number => string; type X = ({ foo: bar }) => string; // Options: ["always"] type X = (number) => string; // Options: ["always"] type X = (?number) => string; // Options: ["always"] type X = number => string; // Options: ["always"] type X = ?number => string; // Options: ["always"] type X = ({ foo: bar }) => string; class Foo { bar } class Foo { bar = 3 } class Foo { bar: string } class Foo { bar: ?string } // Options: ["never"] class Foo { bar:string } // Options: ["never"] class Foo { bar:?string } class X { static foo : number } // Options: ["never"] class X { static foo :number } declare class X { static foo : number } // Options: ["never"] declare class X { static foo :number } class X { +foo: string } class X { static +foo: string } // Options: ["never"] class X { +foo:string } // Options: ["never"] class X { static +foo:string } type X = { foo: string } // Options: ["never"] type X = { foo:string } type X = { foo?: string } type X = { foo?: ?string } // Options: ["never"] type X = { foo?:?string } type Foo = { barType: (string | () => void) } type Foo = { barType: ((string | () => void)) } // Options: ["never"] type Foo = { barType:(string | () => void) } // Options: ["never"] type Foo = { barType:((string | () => void)) } type X = { get(): A; } type X = { get(): A; } // Options: ["never"] type X = { get(): A; } // Options: ["never"] type X = { get(): A; } type X = { get: () => A; } type X = { get: () => A; } // Options: ["never"] type X = { get:() => A; } // Options: ["never"] type X = { get:() => A; } type X = { +foo: string } type X = { +foo?: string } // Options: ["never"] type X = { +foo:string } // Options: ["never"] type X = { +foo?:string } // Options: ["always"] type X = { [a: b]: c } // Options: ["never"] type X = { [a:b]:c } // Options: ["always"] type X = { +[a: b]: c } // Options: ["never"] type X = { +[a:b]:c } // Options: ["always"] type X = { [string]: c } // Options: ["never"] type X = { [string]:c } // Options: ["never"] const x = ({}:{}) // Options: ["always"] const x = ({}: {}) // Options: ["never"] ((x):(string)) // Options: ["always"] ((x): (string)) // Options: ["always"] const x: number = 7; // Options: ["always"] let x: number = 42; // Options: ["always"] var x: number = 42; ``` ### `space-before-generic-bracket` _The `--fix` option on the command line automatically fixes problems reported by this rule._ Enforces consistent spacing before the opening `<` of generic type annotation parameters. This rule takes one argument. If it is `'never'` then a problem is raised when there is a space before the `<`. If it is `'always'` then a problem is raised when there is no space before the `<`. The default value is `'never'`. The following patterns are considered problems: ```js type X = Promise // Message: There must be no space before "Promise" generic type annotation bracket // Options: ["never"] type X = Promise // Message: There must be no space before "Promise" generic type annotation bracket type X = Promise // Message: There must be no space before "Promise" generic type annotation bracket // Options: ["always"] type X = Promise // Message: There must be a space before "Promise" generic type annotation bracket // Options: ["always"] type X = Promise // Message: There must be one space before "Promise" generic type annotation bracket ``` The following patterns are not considered problems: ```js type X = Promise // Options: ["always"] type X = Promise ``` ### `space-before-type-colon` _The `--fix` option on the command line automatically fixes problems reported by this rule._ Enforces consistent spacing before the type annotation colon. This rule takes one argument. If it is `'always'` then a problem is raised when there is no space before the type annotation colon. If it is `'never'` then a problem is raised when there is a space before the type annotation colon. The default value is `'never'`. The following patterns are considered problems: ```js // Options: ["never"] (foo : string) => {} // Message: There must be no space before "foo" parameter type annotation colon. // Options: ["never"] (foo ? : string) => {} // Message: There must be no space before "foo" parameter type annotation colon. // Options: ["always"] (foo: string) => {} // Message: There must be a space before "foo" parameter type annotation colon. // Options: ["always"] (foo : string) => {} // Message: There must be 1 space before "foo" parameter type annotation colon. // Options: ["always"] (foo?: string) => {} // Message: There must be a space before "foo" parameter type annotation colon. // Options: ["always"] (foo ? : string) => {} // Message: There must be 1 space before "foo" parameter type annotation colon. // Options: ["always"] (foo ?: string) => {} // Message: There must be a space before "foo" parameter type annotation colon. ({ lorem, ipsum, dolor } : SomeType) => {} // Message: There must be no space before "{ lorem, ipsum, dolor }" parameter type annotation colon. (foo : { a: string, b: number }) => {} // Message: There must be no space before "foo" parameter type annotation colon. ({ a, b } : { a: string, b: number }) => {} // Message: There must be no space before "{ a, b }" parameter type annotation colon. ([ a, b ] : string[]) => {} // Message: There must be no space before "[ a, b ]" parameter type annotation colon. () : x => {} // Message: There must be no space before return type colon. // Options: ["always"] (): x => {} // Message: There must be a space before return type colon. // Options: ["always"] () : x => {} // Message: There must be 1 space before return type colon. function x(foo : string) {} // Message: There must be no space before "foo" parameter type annotation colon. // Options: ["always"] function x(foo: string) {} // Message: There must be a space before "foo" parameter type annotation colon. var x = function (foo : string) {} // Message: There must be no space before "foo" parameter type annotation colon. // Options: ["always"] var x = function (foo: string) {} // Message: There must be a space before "foo" parameter type annotation colon. class Foo { constructor(foo : string ) {} } // Message: There must be no space before "foo" parameter type annotation colon. // Options: ["always"] class Foo { constructor(foo: string ) {} } // Message: There must be a space before "foo" parameter type annotation colon. async function foo({ lorem, ipsum, dolor } : SomeType) {} // Message: There must be no space before "{ lorem, ipsum, dolor }" parameter type annotation colon. function a() : x {} // Message: There must be no space before return type colon. // Options: ["always"] function a(): x {} // Message: There must be a space before return type colon. // Options: ["always"] function a() : x {} // Message: There must be 1 space before return type colon. type X = (foo :string) => string; // Message: There must be no space before "foo" parameter type annotation colon. // Options: ["always"] type X = (foo:string) => string; // Message: There must be a space before "foo" parameter type annotation colon. // Options: ["always"] type X = (foo :string) => string; // Message: There must be 1 space before "foo" parameter type annotation colon. type X = (foo? :string) => string; // Message: There must be no space before "foo" parameter type annotation colon. type X = (foo? :string) => string; // Message: There must be no space before "foo" parameter type annotation colon. // Options: ["always"] type X = (foo?:string) => string; // Message: There must be a space before "foo" parameter type annotation colon. type X = (foo? :?string) => string; // Message: There must be no space before "foo" parameter type annotation colon. class X { foo :string } // Message: There must be no space before "foo" class property type annotation colon. // Options: ["always"] class X { foo: string } // Message: There must be a space before "foo" class property type annotation colon. class X { foo :?string } // Message: There must be no space before "foo" class property type annotation colon. // Options: ["always"] class X { foo: ?string } // Message: There must be a space before "foo" class property type annotation colon. class X { static foo : number } // Message: There must be no space before "foo" class property type annotation colon. class X { static foo :number } // Message: There must be no space before "foo" class property type annotation colon. // Options: ["always"] class X { static foo: number } // Message: There must be a space before "foo" class property type annotation colon. // Options: ["always"] class X { static foo:number } // Message: There must be a space before "foo" class property type annotation colon. declare class Foo { static bar :number; } // Message: There must be no space before "bar" type annotation colon. declare class Foo { static bar : number; } // Message: There must be no space before "bar" type annotation colon. // Options: ["always"] declare class Foo { static bar:number; } // Message: There must be a space before "bar" type annotation colon. // Options: ["always"] declare class Foo { static bar: number; } // Message: There must be a space before "bar" type annotation colon. // Options: ["always"] class X { +foo: string } // Message: There must be a space before "foo" class property type annotation colon. // Options: ["always"] class X { +foo : string } // Message: There must be 1 space before "foo" class property type annotation colon. // Options: ["never"] class X { +foo : string } // Message: There must be no space before "foo" class property type annotation colon. // Options: ["always"] class X { static +foo: string } // Message: There must be a space before "foo" class property type annotation colon. // Options: ["always"] class X { static +foo : string } // Message: There must be 1 space before "foo" class property type annotation colon. // Options: ["never"] class X { static +foo : string } // Message: There must be no space before "foo" class property type annotation colon. type X = { foo : string } // Message: There must be no space before "foo" type annotation colon. // Options: ["never"] type X = { foo : string } // Message: There must be no space before "foo" type annotation colon. // Options: ["always"] type X = { foo: string } // Message: There must be a space before "foo" type annotation colon. // Options: ["always"] type X = { foo : string } // Message: There must be 1 space before "foo" type annotation colon. type X = { foo? : string } // Message: There must be no space before "foo" type annotation colon. // Options: ["always"] type X = { foo?: string } // Message: There must be a space before "foo" type annotation colon. // Options: ["always"] type X = { foo? : string } // Message: There must be 1 space before "foo" type annotation colon. // Options: ["always"] type X = { foo ?: string } // Message: There must be a space before "foo" type annotation colon. // Options: ["always"] type X = { +foo: string } // Message: There must be a space before "foo" type annotation colon. // Options: ["always"] type X = { +foo : string } // Message: There must be 1 space before "foo" type annotation colon. // Options: ["never"] type X = { +foo : string } // Message: There must be no space before "foo" type annotation colon. // Options: ["always"] type X = { +foo?: string } // Message: There must be a space before "foo" type annotation colon. // Options: ["always"] type X = { +foo? : string } // Message: There must be 1 space before "foo" type annotation colon. // Options: ["never"] type X = { +foo? : string } // Message: There must be no space before "foo" type annotation colon. // Options: ["always"] type X = { [a: b] : c } // Message: There must be a space before type annotation colon. // Options: ["never"] type X = { [a : b]: c } // Message: There must be no space before type annotation colon. // Options: ["always"] type X = { [a : b] : c } // Message: There must be 1 space before type annotation colon. // Options: ["always"] type X = { +[a:b] : c } // Message: There must be a space before type annotation colon. // Options: ["never"] type X = { +[a : b]: c } // Message: There must be no space before type annotation colon. // Options: ["always"] type X = { +[a : b] : c } // Message: There must be 1 space before type annotation colon. // Options: ["always"] type X = { [a : b]: c } // Message: There must be a space before type annotation colon. // Options: ["never"] type X = { [a: b] : c } // Message: There must be no space before type annotation colon. // Options: ["always"] type X = { [a : b] : c } // Message: There must be 1 space before type annotation colon. // Options: ["always"] type X = { [a:b]:c } // Message: There must be a space before type annotation colon. // Message: There must be a space before type annotation colon. // Options: ["never"] type X = { [a : b] : c } // Message: There must be no space before type annotation colon. // Message: There must be no space before type annotation colon. // Options: ["always"] type X = { [a : b] : c } // Message: There must be 1 space before type annotation colon. // Message: There must be 1 space before type annotation colon. // Options: ["always"] type X = { [a:(b)]:(c) } // Message: There must be a space before type annotation colon. // Message: There must be a space before type annotation colon. // Options: ["never"] type X = { [a : (b)] : (c) } // Message: There must be no space before type annotation colon. // Message: There must be no space before type annotation colon. // Options: ["never"] const x = ({} :{}) // Message: There must be no space before type cast colon. // Options: ["always"] const x = ({}:{}) // Message: There must be a space before type cast colon. // Options: ["always"] const x = ({} :{}) // Message: There must be 1 space before type cast colon. // Options: ["never"] ((x) : string) // Message: There must be no space before type cast colon. // Options: ["always"] ((x): string) // Message: There must be a space before type cast colon. // Options: ["always"] ((x) : string) // Message: There must be 1 space before type cast colon. // Options: ["always"] const x:number = 7; // Message: There must be a space before const type annotation colon. // Options: ["always"] let x:number = 42; // Message: There must be a space before let type annotation colon. // Options: ["always"] var x:number = 42; // Message: There must be a space before var type annotation colon. ``` The following patterns are not considered problems: ```js (foo) => {} (foo: string) => {} (foo?: string) => {} (foo ?: string) => {} // Options: ["never"] (foo: string) => {} // Options: ["always"] (foo : string) => {} // Options: ["always"] (foo? : string) => {} // Options: ["always"] (foo ? : string) => {} // Options: ["always"] (foo ? : string) => {} ({ lorem, ipsum, dolor }: SomeType) => {} (foo: { a: string, b: number }) => {} ({ a, b }: ?{ a: string, b: number }) => {} (): { a: number, b: string } => {} // Options: ["always"] () : { a : number, b : string } => {} ([ a, b ]: string[]) => {} (): x => {} // Options: ["always"] () : x => {} (): (number | string) => {} // Options: ["always"] () : (number | string) => {} function x(foo: string) {} // Options: ["always"] function x(foo : string) {} var x = function (foo: string) {} // Options: ["always"] var x = function (foo : string) {} class X { foo({ bar }: Props = this.props) {} } class Foo { constructor(foo: string ) {} } // Options: ["always"] class Foo { constructor(foo : string ) {} } async function foo({ lorem, ipsum, dolor }: SomeType) {} function x({ a, b }: { a: string, b: number }) {} function a(): x {} // Options: ["always"] function a() : x {} function a(): (number | string) {} // Options: ["always"] function a() : (number | string) {} type X = (foo:string) => number; type X = (foo: string) => number; type X = (foo: ?string) => number; type X = (foo?: string) => number; type X = (foo?: ?string) => number; type X = (foo ?: string) => number; // Options: ["always"] type X = (foo? : string) => number // Options: ["always"] type X = (foo? : ?string) => number type X = (number) => string; type X = (?number) => string; type X = number => string; type X = ?number => string; type X = ({ foo: bar }) => string; // Options: ["always"] type X = (number) => string; // Options: ["always"] type X = (?number) => string; // Options: ["always"] type X = number => string; // Options: ["always"] type X = ?number => string; // Options: ["always"] type X = ({ foo : bar }) => string; class Foo { bar } class Foo { bar = 3 } class Foo { bar: string } class Foo { bar: ?string } class Foo { bar:?string } // Options: ["always"] class Foo { bar : string } class X { static foo:number } class X { static foo: number } // Options: ["always"] class X { static foo :number } // Options: ["always"] class X { static foo : number } declare class Foo { static bar:number; } // Options: ["always"] declare class Foo { static bar :number; } declare class Foo { static bar: number; } // Options: ["always"] declare class Foo { static bar : number; } class X { +foo: string } class X { static +foo: string } // Options: ["always"] class X { +foo : string } // Options: ["always"] class X { static +foo : string } type X = { foo: string } // Options: ["always"] type X = { foo : string } type X = { foo?: string } type X = { foo ?: string } // Options: ["always"] type X = { foo? : string } type X = { +foo: string } type X = { +foo?: string } // Options: ["always"] type X = { +foo : string } // Options: ["always"] type X = { +foo? : string } // Options: ["always"] type X = { [a : b] : c } // Options: ["never"] type X = { [a:b]:c } // Options: ["always"] type X = { [string] : c } // Options: ["never"] type X = { [string]:c } // Options: ["always"] type X = { +[a : b] : c } // Options: ["never"] type X = { +[a:b]:c } // Options: ["always"] type X = { [a : (b)] : (c) } // Options: ["never"] type X = { [a:(b)]:(c) } // Options: ["never"] const x = ({}:{}) // Options: ["always"] const x = ({} :{}) // Options: ["never"] ((x): string) // Options: ["always"] ((x) : string) // Options: ["always"] const x :number = 7; // Options: ["always"] let x :number = 42; // Options: ["always"] var x :number = 42; ``` ### `spread-exact-type` Enforce object types, that are spread to be exact type explicitly. The following patterns are considered problems: ```js type bar = {...{test: string}} // Message: Use $Exact to make type spreading safe. type foo = {test: number}; type bar = {...foo} // Message: Use $Exact to make type spreading safe. ``` The following patterns are not considered problems: ```js type bar = {...$Exact<{test: string}>} type foo = {test: number}; type bar = {...$Exact} ``` ### `type-id-match` Enforces a consistent naming pattern for type aliases. #### Options This rule requires a text RegExp: ```js { "rules": { "ft-flow/type-id-match": [ 2, "^([A-Z][a-z0-9]*)+Type$" ] } } ``` `'^([A-Z][a-z0-9]*)+Type$'` is the default pattern. The following patterns are considered problems: ```js opaque type foo = {}; // Message: Type identifier 'foo' does not match pattern '/^([A-Z][a-z0-9]*)+Type$/u'. type foo = {}; // Message: Type identifier 'foo' does not match pattern '/^([A-Z][a-z0-9]*)+Type$/u'. // Options: ["^foo$"] type FooType = {}; // Message: Type identifier 'FooType' does not match pattern '/^foo$/u'. ``` The following patterns are not considered problems: ```js type FooType = {}; // Options: ["^foo$"] type foo = {}; // Settings: {"ft-flow":{"onlyFilesWithFlowAnnotation":true}} type foo = {}; ``` ### `type-import-style` _The `--fix` option on the command line automatically fixes problems reported by this rule._ Enforces a particular style for type imports: ``` // 'identifier' style import {type T, type U, type V} from '...'; // 'declaration' style import type {T, U, V} from '...'; ``` #### Options The rule has a string option: * `"identifier"` (default): Enforces that type imports are all in the 'identifier' style. * `"declaration"`: Enforces that type imports are all in the 'declaration' style. This rule has an object option: * `ignoreTypeDefault` - if `true`, when in "identifier" mode, default type imports will be ignored. Default is `false`. The following patterns are considered problems: ```js import type {A, B} from 'a'; // Message: Unexpected "import type" // Options: ["identifier"] import type {A, B} from 'a'; // Message: Unexpected "import type" // Options: ["identifier"] import type {A, B as C} from 'a'; // Message: Unexpected "import type" // Options: ["identifier"] import type A from 'a'; // Message: Unexpected "import type" // Options: ["declaration"] import {type A, type B} from 'a'; // Message: Unexpected type import // Message: Unexpected type import ``` The following patterns are not considered problems: ```js import {type A, type B} from 'a'; // Options: ["identifier"] import {type A, type B} from 'a'; // Options: ["declaration"] import type {A, B} from 'a'; // Options: ["identifier"] import typeof * as A from 'a'; // Options: ["identifier",{"ignoreTypeDefault":true}] import type A from 'a'; // Options: ["identifier"] declare module "m" { import type A from 'a'; } ``` ### `union-intersection-spacing` _The `--fix` option on the command line automatically fixes problems reported by this rule._ Enforces consistent spacing around union and intersection type separators (`|` and `&`). This rule takes one argument. If it is `'always'` then a problem is raised when there is no space around the separator. If it is `'never'` then a problem is raised when there is a space around the separator. The default value is `'always'`. The following patterns are considered problems: ```js type X = string| number; // Message: There must be a space before union type annotation separator // Options: ["always"] type X = string| number; // Message: There must be a space before union type annotation separator type X = string |number; // Message: There must be a space after union type annotation separator type X = string|number; // Message: There must be a space before union type annotation separator // Message: There must be a space after union type annotation separator type X = {x: string}|{y: number}; // Message: There must be a space before union type annotation separator // Message: There must be a space after union type annotation separator type X = string | number |boolean; // Message: There must be a space after union type annotation separator type X = string|number|boolean; // Message: There must be a space before union type annotation separator // Message: There must be a space after union type annotation separator // Message: There must be a space before union type annotation separator // Message: There must be a space after union type annotation separator type X = (string)| number; // Message: There must be a space before union type annotation separator type X = ((string))|(number | foo); // Message: There must be a space before union type annotation separator // Message: There must be a space after union type annotation separator // Options: ["never"] type X = string |number; // Message: There must be no space before union type annotation separator // Options: ["never"] type X = string| number; // Message: There must be no space after union type annotation separator type X = string& number; // Message: There must be a space before intersection type annotation separator // Options: ["always"] type X = string& number; // Message: There must be a space before intersection type annotation separator type X = string &number; // Message: There must be a space after intersection type annotation separator type X = {x: string}&{y: number}; // Message: There must be a space before intersection type annotation separator // Message: There must be a space after intersection type annotation separator type X = string&number; // Message: There must be a space before intersection type annotation separator // Message: There must be a space after intersection type annotation separator type X = string & number &boolean; // Message: There must be a space after intersection type annotation separator type X = string&number&boolean; // Message: There must be a space before intersection type annotation separator // Message: There must be a space after intersection type annotation separator // Message: There must be a space before intersection type annotation separator // Message: There must be a space after intersection type annotation separator type X = (string)& number; // Message: There must be a space before intersection type annotation separator type X = ((string))&(number & foo); // Message: There must be a space before intersection type annotation separator // Message: There must be a space after intersection type annotation separator // Options: ["never"] type X = string &number; // Message: There must be no space before intersection type annotation separator // Options: ["never"] type X = string& number; // Message: There must be no space after intersection type annotation separator ``` The following patterns are not considered problems: ```js type X = string | number; type X = string | number | boolean; type X = (string) | number; type X = ((string)) | (number | foo); // Options: ["never"] type X = string|number type X = | string | number function x() { type X = | string | number } // Settings: {"ft-flow":{"onlyFilesWithFlowAnnotation":true}} type X = string| number; type X = string & number; type X = string & number & boolean; type X = (string) & number; type X = ((string)) & (number & foo); // Options: ["never"] type X = string&number type X = & string & number function x() { type X = & string & number } // Settings: {"ft-flow":{"onlyFilesWithFlowAnnotation":true}} type X = string& number; ``` ### `use-flow-type` Marks Flow [type alias](https://flowtype.org/docs/type-aliases.html) declarations as used. Used to suppress [`no-unused-vars`](http://eslint.org/docs/rules/no-unused-vars) errors that are triggered by type aliases. The following patterns are not considered problems: ```js declare class A {} // Additional rules: {"no-unused-vars":1} declare function A(): Y // Additional rules: {"no-unused-vars":1} declare module A {} // Additional rules: {"no-unused-vars":1} declare module A { declare var a: Y } // Additional rules: {"no-unused-vars":1} declare var A: Y // Additional rules: {"no-unused-vars":1} import type A from "a"; type X> = { b: B }; let x: X; console.log(x); // Additional rules: {"no-unused-vars":1} import type A from "a"; type X> = { b: B }; let x: X; console.log(x); // Additional rules: {"no-unused-vars":1} ``` ### `use-read-only-spread` Warns against accidentally creating an object which is no longer read-only because of how spread operator works in Flow. Imagine the following code: ```flow js type INode = {| +type: string, |}; type Identifier = {| ...INode, +name: string, |}; ``` You might expect the identifier name to be read-only, however, that's not true ([flow.org/try](https://flow.org/try/#0C4TwDgpgBAkgcgewCbQLxQN4B8BQUoDUokAXFAM7ABOAlgHYDmANDlgL4DcOOx0MKdYDQBmNCFSjpseKADp58ZBBb4CdAIYBbCGUq1GLdlxwBjBHUpQAHmX4RBIsRKlQN2sgHIPTKL08eoTm4rWV5JKA8AZQALBABXABskVwRgKAAjaAB3WmB1dISIAEIPLhC3NAiY+KSUtMyoHJo8guLSnCA)): ```flow js const x: Identifier = { name: '', type: '' }; x.type = 'must NOT be writable!'; // No Flow error x.name = 'must NOT be writable!'; // No Flow error ``` This rule suggests to use `$ReadOnly<…>` to prevent accidental loss of readonly-ness: ```flow js type Identifier = $ReadOnly<{| ...INode, +name: string, |}>; const x: Identifier = { name: '', type: '' }; x.type = 'must NOT be writable!'; // $FlowExpectedError[cannot-write] x.name = 'must NOT be writable!'; // $FlowExpectedError[cannot-write] ``` The following patterns are considered problems: ```js type INode = {||}; type Identifier = {| ...INode, +aaa: string, |}; // Message: Flow type with spread property and all readonly properties must be wrapped in '$ReadOnly<…>' to prevent accidental loss of readonly-ness. type INode = {||}; type Identifier = {| ...INode, +aaa: string, +bbb: string, |}; // Message: Flow type with spread property and all readonly properties must be wrapped in '$ReadOnly<…>' to prevent accidental loss of readonly-ness. ``` The following patterns are not considered problems: ```js type INode = {||}; type Identifier = {| ...INode, name: string, |}; type INode = {||}; type Identifier = {| ...INode, name: string, // writable on purpose +surname: string, |}; type Identifier = {| +name: string, |}; type INode = {||}; type Identifier = $ReadOnly<{| ...INode, +name: string, |}>; type INode = {||}; type Identifier = $ReadOnly<{| ...INode, name: string, // writable on purpose |}>; type INode = {||}; type Identifier = $ReadOnly<{| ...INode, -name: string, |}>; ``` ### `valid-syntax` **Deprecated** Babylon (the Babel parser) v6.10.0 fixes parsing of the invalid syntax this plugin warned against. Checks for simple Flow syntax errors. The following patterns are not considered problems: ```js function x(foo: string = "1") {} function x(foo: Type = bar()) {} ```