flow.md

Flow

Boolean style

enforces a particular style for boolean type annotations. This rule takes one argument.

✅ Enabled (error)

// GOOD
type AeType = boolean;

// BAD
/*
type BeType = bool;
type CeType = Boolean;
*/

Define flow type

marks Flow type identifiers as defined. Used to suppress no-undef reporting of type identifiers.

✅ Enabled (error)

// BAD
/*
const a: AeType = '';
*/
// GOOD
type BeType = string;
const b: BeType = '';

Delimiter dangle

enforces consistent use of trailing commas in Object and Tuple annotations.

✅ Enabled (error)

// BAD
/*
type AeType = {
	foo: string
};
*/
// GOOD
type BeType = {
	foo: string,
};

Generic spacing

enforces consistent spacing within generic type annotation parameters.

✅ Enabled (error)

// BAD
/*
type AeType = Promise< string>;
*/
// GOOD
type BeType = Promise<string>;

No primitive constructor types

disallows use of primitive constructors as types, such as Boolean, Number and String. See more.

✅ Enabled (error)

// BAD
/*
type NumberType = Number;
type StringType = String;
type BooleanType = Boolean;
*/

// GOOD
type NumberType = number;
type StringType = string;
type BooleanType = boolean;

No weak types

Warns against weak type annotations any, Object and Function. These types can cause flow to silently skip over portions of your code, which would have otherwise caused type errors.

❌ Disabled

// BAD
function foo(thing: string): any { return true; }

// GOOD
function foo(thing: string): boolean { return true; }

Object type delimiter

enforces consistent separators between properties in Flow object types.

✅ Enabled (error)

// BAD
/*
type FooType = { a: string; b: string };
type Foo2Type = {
    a: string,
    b: string
};
*/
// GOOD
type FooType = { a: string, b: string };
type Foo2Type = {
	a: string,
	b: string,
};

Require jsdoc

Overwrite require-jsdoc rule

❌ Disabled

// jsdoc is not required if you are using flow
function foo(thing: string): any { return true; }

Require parameter type

requires that all function parameters have type annotations.

✅ Enabled (error)

// BAD
/*
function x(foo) {}
*/
// GOOD
function x(foo: string) {}

Require return type

requires that functions have return type annotation.

✅ Enabled (error)

// BAD
/*
const a = (foo: string) => { return 'foo'; };
*/
// GOOD
const b = (foo: string): string => { return 'foo'; };

Require valid file annotation

this rule validates Flow file annotations.

✅ Enabled (error)

// @flow
// or
/* @flow */

Semi

enforces consistent use of semicolons after type aliases.

✅ Enabled (error)

// BAD
/*
type FooType = {}
*/
// GOOD
type FooType = {};

Space after type colon

enforces consistent spacing after the type annotation colon.

✅ Enabled (error)

// BAD
/*
const a = (foo:string) => {};
const b = (foo :string) => {};
const c = (foo : string) => {};
*/
// GOOD
const d = (foo: string) => {};

Space before generic bracket

Enforces consistent spacing before the opening < of generic type annotation parameters.

✅ Enabled (error)

// BAD
/*
type XeType = Promise <string>;
*/
// GOOD
type XeType = Promise<string>;

Space before type colon

Enforces consistent spacing before the type annotation colon.

✅ Enabled (error)

// BAD
/*
const a = (foo : string) => {};
*/
// GOOD
const b = (foo: string) => {};

Type id match

Enforces a consistent naming pattern for type aliases.

✅ Enabled (error)

// BAD
/*
type foo = {};
*/
// GOOD
type FooType = {};

Union intersection spacing

Enforces consistent spacing around union and intersection type separators (| and &).

✅ Enabled (error)

// BAD
/*
type XeType = string| number;
*/
// GOOD
type XeType = string | number;

Use flow type

Marks Flow type alias declarations as used. Used to suppress no-unused-vars errors that are triggered by type aliases.

✅ Enabled (error)

// GOOD
declare class A {}