eslint-plugin-flowtype - npm Package Compare versions

Comparing version 2.11.1 to 2.11.4

dist/index.js

 'use strict';
 
 Object.defineProperty(exports, "__esModule", {
-    value: true
+  value: true
 });
@@ -58,30 +58,30 @@
 exports.default = {
-    rules: {
-        'define-flow-type': _defineFlowType2.default,
-        'generic-spacing': _genericSpacing2.default,
-        'require-parameter-type': _requireParameterType2.default,
-        'require-return-type': _requireReturnType2.default,
-        'require-valid-file-annotation': _requireValidFileAnnotation2.default,
-        'space-after-type-colon': _spaceAfterTypeColon2.default,
-        'space-before-generic-bracket': _spaceBeforeGenericBracket2.default,
-        'space-before-type-colon': _spaceBeforeTypeColon2.default,
-        'type-id-match': _typeIdMatch2.default,
-        'union-intersection-spacing': _unionIntersectionSpacing2.default,
-        'use-flow-type': _useFlowType2.default,
-        'valid-syntax': _validSyntax2.default
-    },
-    rulesConfig: {
-        'define-flow-type': 0,
-        'generic-spacing': 0,
-        'require-parameter-type': 0,
-        'require-return-type': 0,
-        'space-after-type-colon': 0,
-        'space-before-generic-bracket': 0,
-        'space-before-type-colon': 0,
-        'type-id-match': 0,
-        'union-intersection-spacing': 0,
-        'use-flow-type': 0,
-        'valid-syntax': 0
-    }
+  rules: {
+    'define-flow-type': _defineFlowType2.default,
+    'generic-spacing': _genericSpacing2.default,
+    'require-parameter-type': _requireParameterType2.default,
+    'require-return-type': _requireReturnType2.default,
+    'require-valid-file-annotation': _requireValidFileAnnotation2.default,
+    'space-after-type-colon': _spaceAfterTypeColon2.default,
+    'space-before-generic-bracket': _spaceBeforeGenericBracket2.default,
+    'space-before-type-colon': _spaceBeforeTypeColon2.default,
+    'type-id-match': _typeIdMatch2.default,
+    'union-intersection-spacing': _unionIntersectionSpacing2.default,
+    'use-flow-type': _useFlowType2.default,
+    'valid-syntax': _validSyntax2.default
+  },
+  rulesConfig: {
+    'define-flow-type': 0,
+    'generic-spacing': 0,
+    'require-parameter-type': 0,
+    'require-return-type': 0,
+    'space-after-type-colon': 0,
+    'space-before-generic-bracket': 0,
+    'space-before-type-colon': 0,
+    'type-id-match': 0,
+    'union-intersection-spacing': 0,
+    'use-flow-type': 0,
+    'valid-syntax': 0
+  }
 };
 module.exports = exports['default'];

dist/rules/defineFlowType.js

 'use strict';
 
 Object.defineProperty(exports, "__esModule", {
-    value: true
+  value: true
 });
@@ -9,59 +9,59 @@ var schema = exports.schema = [];
 exports.default = function (context) {
-    var globalScope = void 0;
+  var globalScope = void 0;
 
-    // do nearly the same thing that eslint does for config globals
-    // https://github.com/eslint/eslint/blob/v2.0.0/lib/eslint.js#L118-L194
-    var makeDefined = function makeDefined(ident) {
-        var ii = void 0;
+  // do nearly the same thing that eslint does for config globals
+  // https://github.com/eslint/eslint/blob/v2.0.0/lib/eslint.js#L118-L194
+  var makeDefined = function makeDefined(ident) {
+    var ii = void 0;
 
-        // start from the right since we're going to remove items from the array
-        for (ii = globalScope.through.length - 1; ii >= 0; ii--) {
-            var ref = globalScope.through[ii];
+    // start from the right since we're going to remove items from the array
+    for (ii = globalScope.through.length - 1; ii >= 0; ii--) {
+      var ref = globalScope.through[ii];
 
-            if (ref.identifier.name === ident.name) {
-                // use "__defineGeneric" since we don't have a reference to "escope.Variable"
-                globalScope.__defineGeneric( // eslint-disable-line no-underscore-dangle
-                ident.name, globalScope.set, globalScope.variables);
-                var variable = globalScope.set.get(ident.name);
+      if (ref.identifier.name === ident.name) {
+        // use "__defineGeneric" since we don't have a reference to "escope.Variable"
+        globalScope.__defineGeneric( // eslint-disable-line no-underscore-dangle
+        ident.name, globalScope.set, globalScope.variables);
+        var variable = globalScope.set.get(ident.name);
 
-                variable.writeable = false;
-                // "through" contains all references whose definition cannot be found
-                // so we need to update references and remove the ones that were added
-                globalScope.through.splice(ii, 1);
-                ref.resolved = variable;
-                variable.references.push(ref);
-            }
-        }
-    };
+        variable.writeable = false;
+        // "through" contains all references whose definition cannot be found
+        // so we need to update references and remove the ones that were added
+        globalScope.through.splice(ii, 1);
+        ref.resolved = variable;
+        variable.references.push(ref);
+      }
+    }
+  };
 
-    return {
-        ClassImplements: function ClassImplements(node) {
-            makeDefined(node.id);
-        },
-        GenericTypeAnnotation: function GenericTypeAnnotation(node) {
-            if (node.id.type === 'Identifier') {
-                makeDefined(node.id);
-            } else if (node.id.type === 'QualifiedTypeIdentifier') {
-                var qid = void 0;
+  return {
+    ClassImplements: function ClassImplements(node) {
+      makeDefined(node.id);
+    },
+    GenericTypeAnnotation: function GenericTypeAnnotation(node) {
+      if (node.id.type === 'Identifier') {
+        makeDefined(node.id);
+      } else if (node.id.type === 'QualifiedTypeIdentifier') {
+        var qid = void 0;
 
-                qid = node.id;
-                do {
-                    qid = qid.qualification;
-                } while (qid.qualification);
+        qid = node.id;
+        do {
+          qid = qid.qualification;
+        } while (qid.qualification);
 
-                makeDefined(qid);
-            }
-        },
-        InterfaceDeclaration: function InterfaceDeclaration(node) {
-            makeDefined(node.id);
-        },
-        Program: function Program() {
-            globalScope = context.getScope();
-        },
-        TypeParameterDeclaration: function TypeParameterDeclaration(node) {
-            node.params.forEach(function (param) {
-                makeDefined(param);
-            });
-        }
-    };
+        makeDefined(qid);
+      }
+    },
+    InterfaceDeclaration: function InterfaceDeclaration(node) {
+      makeDefined(node.id);
+    },
+    Program: function Program() {
+      globalScope = context.getScope();
+    },
+    TypeParameterDeclaration: function TypeParameterDeclaration(node) {
+      node.params.forEach(function (param) {
+        makeDefined(param);
+      });
+    }
+  };
 };

dist/rules/genericSpacing.js

 'use strict';
 
 Object.defineProperty(exports, "__esModule", {
-    value: true
+  value: true
 });
@@ -12,90 +12,90 @@
 exports.default = function (context) {
-    var sourceCode = context.getSourceCode();
+  var sourceCode = context.getSourceCode();
 
-    var never = (context.options[0] || 'never') === 'never';
+  var never = (context.options[0] || 'never') === 'never';
 
-    return {
-        GenericTypeAnnotation: function GenericTypeAnnotation(node) {
-            var types = node.typeParameters;
+  return {
+    GenericTypeAnnotation: function GenericTypeAnnotation(node) {
+      var types = node.typeParameters;
 
-            // Promise<foo>
-            // ^^^^^^^^^^^^ GenericTypeAnnotation (with typeParameters)
-            //         ^^^  GenericTypeAnnotation (without typeParameters)
-            if (!types) {
-                return;
-            }
+      // Promise<foo>
+      // ^^^^^^^^^^^^ GenericTypeAnnotation (with typeParameters)
+      //         ^^^  GenericTypeAnnotation (without typeParameters)
+      if (!types) {
+        return;
+      }
 
-            var _sourceCode$getFirstT = sourceCode.getFirstTokens(types, 2);
+      var _sourceCode$getFirstT = sourceCode.getFirstTokens(types, 2);
 
-            var _sourceCode$getFirstT2 = _slicedToArray(_sourceCode$getFirstT, 2);
+      var _sourceCode$getFirstT2 = _slicedToArray(_sourceCode$getFirstT, 2);
 
-            var opener = _sourceCode$getFirstT2[0];
-            var firstInnerToken = _sourceCode$getFirstT2[1];
+      var opener = _sourceCode$getFirstT2[0];
+      var firstInnerToken = _sourceCode$getFirstT2[1];
 
-            var _sourceCode$getLastTo = sourceCode.getLastTokens(types, 2);
+      var _sourceCode$getLastTo = sourceCode.getLastTokens(types, 2);
 
-            var _sourceCode$getLastTo2 = _slicedToArray(_sourceCode$getLastTo, 2);
+      var _sourceCode$getLastTo2 = _slicedToArray(_sourceCode$getLastTo, 2);
 
-            var lastInnerToken = _sourceCode$getLastTo2[0];
-            var closer = _sourceCode$getLastTo2[1];
+      var lastInnerToken = _sourceCode$getLastTo2[0];
+      var closer = _sourceCode$getLastTo2[1];
 
 
-            var spacesBefore = firstInnerToken.start - opener.end;
-            var spacesAfter = closer.start - lastInnerToken.end;
+      var spacesBefore = firstInnerToken.start - opener.end;
+      var spacesAfter = closer.start - lastInnerToken.end;
 
-            if (never) {
-                if (spacesBefore) {
-                    context.report({
-                        data: { name: node.id.name },
-                        fix: _utilities.spacingFixers.stripSpacesAfter(opener, spacesBefore),
-                        message: 'There must be no space at start of "{{name}}" generic type annotation',
-                        node: types
-                    });
-                }
+      if (never) {
+        if (spacesBefore) {
+          context.report({
+            data: { name: node.id.name },
+            fix: _utilities.spacingFixers.stripSpacesAfter(opener, spacesBefore),
+            message: 'There must be no space at start of "{{name}}" generic type annotation',
+            node: types
+          });
+        }
 
-                if (spacesAfter) {
-                    context.report({
-                        data: { name: node.id.name },
-                        fix: _utilities.spacingFixers.stripSpacesAfter(lastInnerToken, spacesAfter),
-                        message: 'There must be no space at end of "{{name}}" generic type annotation',
-                        node: types
-                    });
-                }
-            } else {
-                if (spacesBefore > 1) {
-                    context.report({
-                        data: { name: node.id.name },
-                        fix: _utilities.spacingFixers.stripSpacesAfter(opener, spacesBefore - 1),
-                        message: 'There must be one space at start of "{{name}}" generic type annotation',
-                        node: types
-                    });
-                } else if (spacesBefore === 0) {
-                    context.report({
-                        data: { name: node.id.name },
-                        fix: _utilities.spacingFixers.addSpaceAfter(opener),
-                        message: 'There must be a space at start of "{{name}}" generic type annotation',
-                        node: types
-                    });
-                }
+        if (spacesAfter) {
+          context.report({
+            data: { name: node.id.name },
+            fix: _utilities.spacingFixers.stripSpacesAfter(lastInnerToken, spacesAfter),
+            message: 'There must be no space at end of "{{name}}" generic type annotation',
+            node: types
+          });
+        }
+      } else {
+        if (spacesBefore > 1) {
+          context.report({
+            data: { name: node.id.name },
+            fix: _utilities.spacingFixers.stripSpacesAfter(opener, spacesBefore - 1),
+            message: 'There must be one space at start of "{{name}}" generic type annotation',
+            node: types
+          });
+        } else if (spacesBefore === 0) {
+          context.report({
+            data: { name: node.id.name },
+            fix: _utilities.spacingFixers.addSpaceAfter(opener),
+            message: 'There must be a space at start of "{{name}}" generic type annotation',
+            node: types
+          });
+        }
 
-                if (spacesAfter > 1) {
-                    context.report({
-                        data: { name: node.id.name },
-                        fix: _utilities.spacingFixers.stripSpacesAfter(lastInnerToken, spacesAfter - 1),
-                        message: 'There must be one space at end of "{{name}}" generic type annotation',
-                        node: types
-                    });
-                } else if (spacesAfter === 0) {
-                    context.report({
-                        data: { name: node.id.name },
-                        fix: _utilities.spacingFixers.addSpaceAfter(lastInnerToken),
-                        message: 'There must be a space at end of "{{name}}" generic type annotation',
-                        node: types
-                    });
-                }
-            }
+        if (spacesAfter > 1) {
+          context.report({
+            data: { name: node.id.name },
+            fix: _utilities.spacingFixers.stripSpacesAfter(lastInnerToken, spacesAfter - 1),
+            message: 'There must be one space at end of "{{name}}" generic type annotation',
+            node: types
+          });
+        } else if (spacesAfter === 0) {
+          context.report({
+            data: { name: node.id.name },
+            fix: _utilities.spacingFixers.addSpaceAfter(lastInnerToken),
+            message: 'There must be a space at end of "{{name}}" generic type annotation',
+            node: types
+          });
         }
-    };
+      }
+    }
+  };
 };
 
 module.exports = exports['default'];

dist/rules/requireParameterType.js

 'use strict';
 
 Object.defineProperty(exports, "__esModule", {
-    value: true
+  value: true
 });
@@ -16,33 +16,33 @@
 exports.default = (0, _utilities.iterateFunctionNodes)(function (context) {
-    var checkThisFile = !_lodash2.default.get(context, 'settings.flowtype.onlyFilesWithFlowAnnotation') || (0, _utilities.isFlowFile)(context);
+  var checkThisFile = !_lodash2.default.get(context, 'settings.flowtype.onlyFilesWithFlowAnnotation') || (0, _utilities.isFlowFile)(context);
 
-    if (!checkThisFile) {
-        return function () {};
-    }
+  if (!checkThisFile) {
+    return function () {};
+  }
 
-    var skipArrows = _lodash2.default.get(context, 'options[0].excludeArrowFunctions');
+  var skipArrows = _lodash2.default.get(context, 'options[0].excludeArrowFunctions');
 
-    return function (functionNode) {
-        _lodash2.default.forEach(functionNode.params, function (identifierNode) {
-            var typeAnnotation = _lodash2.default.get(identifierNode, 'typeAnnotation') || _lodash2.default.get(identifierNode, 'left.typeAnnotation');
+  return function (functionNode) {
+    _lodash2.default.forEach(functionNode.params, function (identifierNode) {
+      var typeAnnotation = _lodash2.default.get(identifierNode, 'typeAnnotation') || _lodash2.default.get(identifierNode, 'left.typeAnnotation');
 
-            var isArrow = functionNode.type === 'ArrowFunctionExpression';
-            var isArrowFunctionExpression = functionNode.expression;
+      var isArrow = functionNode.type === 'ArrowFunctionExpression';
+      var isArrowFunctionExpression = functionNode.expression;
 
-            if (skipArrows === 'expressionsOnly' && isArrowFunctionExpression || skipArrows === true && isArrow) {
-                return;
-            }
+      if (skipArrows === 'expressionsOnly' && isArrowFunctionExpression || skipArrows === true && isArrow) {
+        return;
+      }
 
-            if (!typeAnnotation) {
-                context.report({
-                    data: {
-                        name: (0, _utilities.quoteName)((0, _utilities.getParameterName)(identifierNode, context))
-                    },
-                    message: 'Missing {{name}}parameter type annotation.',
-                    node: identifierNode
-                });
-            }
+      if (!typeAnnotation) {
+        context.report({
+          data: {
+            name: (0, _utilities.quoteName)((0, _utilities.getParameterName)(identifierNode, context))
+          },
+          message: 'Missing {{name}}parameter type annotation.',
+          node: identifierNode
         });
-    };
+      }
+    });
+  };
 });
 module.exports = exports['default'];

dist/rules/requireReturnType.js

 'use strict';
 
 Object.defineProperty(exports, "__esModule", {
-    value: true
+  value: true
 });
@@ -16,80 +16,80 @@
 exports.default = function (context) {
-    var checkThisFile = !_lodash2.default.get(context, 'settings.flowtype.onlyFilesWithFlowAnnotation') || (0, _utilities.isFlowFile)(context);
+  var checkThisFile = !_lodash2.default.get(context, 'settings.flowtype.onlyFilesWithFlowAnnotation') || (0, _utilities.isFlowFile)(context);
 
-    if (!checkThisFile) {
-        return function () {};
-    }
+  if (!checkThisFile) {
+    return function () {};
+  }
 
-    var annotateReturn = (_lodash2.default.get(context, 'options[0]') || 'always') === 'always';
-    var annotateUndefined = (_lodash2.default.get(context, 'options[1].annotateUndefined') || 'never') === 'always';
-    var skipArrows = _lodash2.default.get(context, 'options[1].excludeArrowFunctions') || false;
+  var annotateReturn = (_lodash2.default.get(context, 'options[0]') || 'always') === 'always';
+  var annotateUndefined = (_lodash2.default.get(context, 'options[1].annotateUndefined') || 'never') === 'always';
+  var skipArrows = _lodash2.default.get(context, 'options[1].excludeArrowFunctions') || false;
 
-    var targetNodes = [];
+  var targetNodes = [];
 
-    var registerFunction = function registerFunction(functionNode) {
-        targetNodes.push({
-            functionNode: functionNode
-        });
-    };
+  var registerFunction = function registerFunction(functionNode) {
+    targetNodes.push({
+      functionNode: functionNode
+    });
+  };
 
-    var isUndefinedReturnType = function isUndefinedReturnType(returnNode) {
-        return returnNode.argument === null || returnNode.argument.name === 'undefined' || returnNode.argument.operator === 'void';
-    };
+  var isUndefinedReturnType = function isUndefinedReturnType(returnNode) {
+    return returnNode.argument === null || returnNode.argument.name === 'undefined' || returnNode.argument.operator === 'void';
+  };
 
-    var getIsReturnTypeAnnotationUndefined = function getIsReturnTypeAnnotationUndefined(targetNode) {
-        var isReturnTypeAnnotationLiteralUndefined = _lodash2.default.get(targetNode, 'functionNode.returnType.typeAnnotation.id.name') === 'undefined' && _lodash2.default.get(targetNode, 'functionNode.returnType.typeAnnotation.type') === 'GenericTypeAnnotation';
-        var isReturnTypeAnnotationVoid = _lodash2.default.get(targetNode, 'functionNode.returnType.typeAnnotation.type') === 'VoidTypeAnnotation';
+  var getIsReturnTypeAnnotationUndefined = function getIsReturnTypeAnnotationUndefined(targetNode) {
+    var isReturnTypeAnnotationLiteralUndefined = _lodash2.default.get(targetNode, 'functionNode.returnType.typeAnnotation.id.name') === 'undefined' && _lodash2.default.get(targetNode, 'functionNode.returnType.typeAnnotation.type') === 'GenericTypeAnnotation';
+    var isReturnTypeAnnotationVoid = _lodash2.default.get(targetNode, 'functionNode.returnType.typeAnnotation.type') === 'VoidTypeAnnotation';
 
-        return isReturnTypeAnnotationLiteralUndefined || isReturnTypeAnnotationVoid;
-    };
+    return isReturnTypeAnnotationLiteralUndefined || isReturnTypeAnnotationVoid;
+  };
 
-    var evaluateFunction = function evaluateFunction(functionNode) {
-        var targetNode = targetNodes.pop();
+  var evaluateFunction = function evaluateFunction(functionNode) {
+    var targetNode = targetNodes.pop();
 
-        if (functionNode !== targetNode.functionNode) {
-            throw new Error('Mismatch.');
-        }
+    if (functionNode !== targetNode.functionNode) {
+      throw new Error('Mismatch.');
+    }
 
-        var isArrow = functionNode.type === 'ArrowFunctionExpression';
-        var isArrowFunctionExpression = functionNode.expression;
-        var hasImplicitReturnType = functionNode.async || functionNode.generator;
-        var isFunctionReturnUndefined = !isArrowFunctionExpression && !hasImplicitReturnType && (!targetNode.returnStatementNode || isUndefinedReturnType(targetNode.returnStatementNode));
-        var isReturnTypeAnnotationUndefined = getIsReturnTypeAnnotationUndefined(targetNode);
+    var isArrow = functionNode.type === 'ArrowFunctionExpression';
+    var isArrowFunctionExpression = functionNode.expression;
+    var hasImplicitReturnType = functionNode.async || functionNode.generator;
+    var isFunctionReturnUndefined = !isArrowFunctionExpression && !hasImplicitReturnType && (!targetNode.returnStatementNode || isUndefinedReturnType(targetNode.returnStatementNode));
+    var isReturnTypeAnnotationUndefined = getIsReturnTypeAnnotationUndefined(targetNode);
 
-        if (skipArrows === 'expressionsOnly' && isArrowFunctionExpression || skipArrows === true && isArrow) {
-            return;
-        }
+    if (skipArrows === 'expressionsOnly' && isArrowFunctionExpression || skipArrows === true && isArrow) {
+      return;
+    }
 
-        if (isFunctionReturnUndefined && isReturnTypeAnnotationUndefined && !annotateUndefined) {
-            context.report(functionNode, 'Must not annotate undefined return type.');
-        } else if (isFunctionReturnUndefined && !isReturnTypeAnnotationUndefined && annotateUndefined) {
-            context.report(functionNode, 'Must annotate undefined return type.');
-        } else if (!isFunctionReturnUndefined && !isReturnTypeAnnotationUndefined) {
-            if (annotateReturn && !functionNode.returnType) {
-                context.report(functionNode, 'Missing return type annotation.');
-            }
-        }
-    };
+    if (isFunctionReturnUndefined && isReturnTypeAnnotationUndefined && !annotateUndefined) {
+      context.report(functionNode, 'Must not annotate undefined return type.');
+    } else if (isFunctionReturnUndefined && !isReturnTypeAnnotationUndefined && annotateUndefined) {
+      context.report(functionNode, 'Must annotate undefined return type.');
+    } else if (!isFunctionReturnUndefined && !isReturnTypeAnnotationUndefined) {
+      if (annotateReturn && !functionNode.returnType) {
+        context.report(functionNode, 'Missing return type annotation.');
+      }
+    }
+  };
 
-    var evaluateNoise = function evaluateNoise() {
-        targetNodes.pop();
-    };
+  var evaluateNoise = function evaluateNoise() {
+    targetNodes.pop();
+  };
 
-    return {
-        ArrowFunctionExpression: registerFunction,
-        'ArrowFunctionExpression:exit': evaluateFunction,
-        ClassDeclaration: registerFunction,
-        'ClassDeclaration:exit': evaluateNoise,
-        ClassExpression: registerFunction,
-        'ClassExpression:exit': evaluateNoise,
-        FunctionDeclaration: registerFunction,
-        'FunctionDeclaration:exit': evaluateFunction,
-        FunctionExpression: registerFunction,
-        'FunctionExpression:exit': evaluateFunction,
-        ReturnStatement: function ReturnStatement(node) {
-            targetNodes[targetNodes.length - 1].returnStatementNode = node;
-        }
-    };
+  return {
+    ArrowFunctionExpression: registerFunction,
+    'ArrowFunctionExpression:exit': evaluateFunction,
+    ClassDeclaration: registerFunction,
+    'ClassDeclaration:exit': evaluateNoise,
+    ClassExpression: registerFunction,
+    'ClassExpression:exit': evaluateNoise,
+    FunctionDeclaration: registerFunction,
+    'FunctionDeclaration:exit': evaluateFunction,
+    FunctionExpression: registerFunction,
+    'FunctionExpression:exit': evaluateFunction,
+    ReturnStatement: function ReturnStatement(node) {
+      targetNodes[targetNodes.length - 1].returnStatementNode = node;
+    }
+  };
 };
 
 module.exports = exports['default'];

dist/rules/requireValidFileAnnotation.js

 'use strict';
 
 Object.defineProperty(exports, "__esModule", {
-    value: true
+  value: true
 });
@@ -17,40 +17,40 @@ exports.schema = undefined;
 var looksLikeFlowFileAnnotation = function looksLikeFlowFileAnnotation(comment) {
-    return (/@(?:no)?flow/i.test(comment)
-    );
+  return (/@(?:no)?flow/i.test(comment)
+  );
 };
 
 var schema = exports.schema = [{
-    enum: ['always']
+  enum: ['always']
 }];
 
 exports.default = function (context) {
-    var checkThisFile = !_lodash2.default.get(context, 'settings.flowtype.onlyFilesWithFlowAnnotation') || (0, _utilities.isFlowFile)(context);
+  var checkThisFile = !_lodash2.default.get(context, 'settings.flowtype.onlyFilesWithFlowAnnotation') || (0, _utilities.isFlowFile)(context);
 
-    if (!checkThisFile) {
-        return {};
-    }
+  if (!checkThisFile) {
+    return {};
+  }
 
-    var always = context.options[0] === 'always';
+  var always = context.options[0] === 'always';
 
-    return {
-        Program: function Program(node) {
-            var firstToken = node.tokens[0];
+  return {
+    Program: function Program(node) {
+      var firstToken = node.tokens[0];
 
-            var potentialFlowFileAnnotation = _lodash2.default.find(context.getAllComments(), function (comment) {
-                return looksLikeFlowFileAnnotation(comment.value);
-            });
+      var potentialFlowFileAnnotation = _lodash2.default.find(context.getAllComments(), function (comment) {
+        return looksLikeFlowFileAnnotation(comment.value);
+      });
 
-            if (potentialFlowFileAnnotation) {
-                if (firstToken && firstToken.start < potentialFlowFileAnnotation.start) {
-                    context.report(potentialFlowFileAnnotation, 'Flow file annotation not at the top of the file.');
-                }
+      if (potentialFlowFileAnnotation) {
+        if (firstToken && firstToken.start < potentialFlowFileAnnotation.start) {
+          context.report(potentialFlowFileAnnotation, 'Flow file annotation not at the top of the file.');
+        }
 
-                if (!(0, _utilities.isFlowFileAnnotation)(potentialFlowFileAnnotation.value)) {
-                    context.report(potentialFlowFileAnnotation, 'Malformed flow file annotation.');
-                }
-            } else if (always) {
-                context.report(node, 'Flow file annotation is missing.');
-            }
+        if (!(0, _utilities.isFlowFileAnnotation)(potentialFlowFileAnnotation.value)) {
+          context.report(potentialFlowFileAnnotation, 'Malformed flow file annotation.');
         }
-    };
+      } else if (always) {
+        context.report(node, 'Flow file annotation is missing.');
+      }
+    }
+  };
 };

dist/rules/spaceAfterTypeColon.js

 'use strict';
 
 Object.defineProperty(exports, "__esModule", {
-    value: true
+  value: true
 });
@@ -20,193 +20,205 @@
 var parseOptions = function parseOptions(context) {
-    return {
-        always: (context.options[0] || 'always') === 'always'
-    };
+  return {
+    always: (context.options[0] || 'always') === 'always'
+  };
 };
 
 var propertyEvaluator = function propertyEvaluator(context, typeForMessage) {
-    var _parseOptions = parseOptions(context);
+  var _parseOptions = parseOptions(context);
 
-    var always = _parseOptions.always;
+  var always = _parseOptions.always;
 
 
-    var sourceCode = context.getSourceCode();
+  var sourceCode = context.getSourceCode();
 
-    var getSpacesAfterColon = function getSpacesAfterColon(node, typeAnnotation) {
-        if (node.type === 'FunctionTypeParam') {
-            var colon = sourceCode.getFirstToken(node, node.optional ? 2 : 1);
+  var getSpacesAfterColon = function getSpacesAfterColon(node, typeAnnotation) {
+    if (node.type === 'FunctionTypeParam') {
+      var colon = sourceCode.getFirstToken(node, node.optional ? 2 : 1);
 
-            return {
-                colon: colon,
-                spaceAfter: sourceCode.getTokenAfter(colon).start - colon.end
-            };
-        } else {
-            var _sourceCode$getFirstT = sourceCode.getFirstTokens(typeAnnotation, 2);
+      return {
+        colon: colon,
+        spaceAfter: sourceCode.getTokenAfter(colon).start - colon.end
+      };
+    } else {
+      var _sourceCode$getFirstT = sourceCode.getFirstTokens(typeAnnotation, 2);
 
-            var _sourceCode$getFirstT2 = _slicedToArray(_sourceCode$getFirstT, 2);
+      var _sourceCode$getFirstT2 = _slicedToArray(_sourceCode$getFirstT, 2);
 
-            var _colon = _sourceCode$getFirstT2[0];
-            var token = _sourceCode$getFirstT2[1];
+      var _colon = _sourceCode$getFirstT2[0];
+      var token = _sourceCode$getFirstT2[1];
 
 
-            return {
-                colon: _colon,
-                spaceAfter: token.start - typeAnnotation.start - 1
-            };
-        }
-    };
+      return {
+        colon: _colon,
+        spaceAfter: token.start - typeAnnotation.start - 1
+      };
+    }
+  };
 
-    return function (node) {
-        var typeAnnotation = _lodash2.default.get(node, 'typeAnnotation') || _lodash2.default.get(node, 'left.typeAnnotation');
+  return function (node) {
+    var typeAnnotation = _lodash2.default.get(node, 'typeAnnotation') || _lodash2.default.get(node, 'left.typeAnnotation');
 
-        if (typeAnnotation) {
-            var _getSpacesAfterColon = getSpacesAfterColon(node, typeAnnotation);
+    if (typeAnnotation) {
+      var _getSpacesAfterColon = getSpacesAfterColon(node, typeAnnotation);
 
-            var colon = _getSpacesAfterColon.colon;
-            var spaceAfter = _getSpacesAfterColon.spaceAfter;
+      var colon = _getSpacesAfterColon.colon;
+      var spaceAfter = _getSpacesAfterColon.spaceAfter;
 
 
-            var data = {
-                name: (0, _utilities.quoteName)((0, _utilities.getParameterName)(node, context)),
-                type: typeForMessage
-            };
+      var data = {
+        name: (0, _utilities.quoteName)((0, _utilities.getParameterName)(node, context)),
+        type: typeForMessage
+      };
 
-            if (always && spaceAfter > 1) {
-                context.report({
-                    data: data,
-                    fix: _utilities.spacingFixers.stripSpacesAfter(colon, spaceAfter - 1),
-                    message: 'There must be 1 space after {{name}}{{type}} type annotation colon.',
-                    node: node
-                });
-            } else if (always && spaceAfter === 0) {
-                context.report({
-                    data: data,
-                    fix: _utilities.spacingFixers.addSpaceAfter(colon),
-                    message: 'There must be a space after {{name}}{{type}} type annotation colon.',
-                    node: node
-                });
-            } else if (!always && spaceAfter > 0) {
-                context.report({
-                    data: data,
-                    fix: _utilities.spacingFixers.stripSpacesAfter(colon, spaceAfter),
-                    message: 'There must be no space after {{name}}{{type}} type annotation colon.',
-                    node: node
-                });
-            }
-        }
-    };
+      if (always && spaceAfter > 1) {
+        context.report({
+          data: data,
+          fix: _utilities.spacingFixers.stripSpacesAfter(colon, spaceAfter - 1),
+          message: 'There must be 1 space after {{name}}{{type}} type annotation colon.',
+          node: node
+        });
+      } else if (always && spaceAfter === 0) {
+        context.report({
+          data: data,
+          fix: _utilities.spacingFixers.addSpaceAfter(colon),
+          message: 'There must be a space after {{name}}{{type}} type annotation colon.',
+          node: node
+        });
+      } else if (!always && spaceAfter > 0) {
+        context.report({
+          data: data,
+          fix: _utilities.spacingFixers.stripSpacesAfter(colon, spaceAfter),
+          message: 'There must be no space after {{name}}{{type}} type annotation colon.',
+          node: node
+        });
+      }
+    }
+  };
 };
 
 var returnTypeEvaluator = function returnTypeEvaluator(context) {
-    var _parseOptions2 = parseOptions(context);
+  var _parseOptions2 = parseOptions(context);
 
-    var always = _parseOptions2.always;
+  var always = _parseOptions2.always;
 
 
-    var sourceCode = context.getSourceCode();
+  var sourceCode = context.getSourceCode();
 
-    return function (functionNode) {
-        // skip FunctionTypeAnnotation, possibly another rule as it's an arrow, not a colon?
-        // (foo: number) => string
-        //              ^^^^
-        if (functionNode.returnType && functionNode.type !== 'FunctionTypeAnnotation') {
-            var _sourceCode$getFirstT3 = sourceCode.getFirstTokens(functionNode.returnType, 2);
+  return function (functionNode) {
+    // skip FunctionTypeAnnotation, possibly another rule as it's an arrow, not a colon?
+    // (foo: number) => string
+    //              ^^^^
+    if (functionNode.returnType && functionNode.type !== 'FunctionTypeAnnotation') {
+      var _sourceCode$getFirstT3 = sourceCode.getFirstTokens(functionNode.returnType, 2);
 
-            var _sourceCode$getFirstT4 = _slicedToArray(_sourceCode$getFirstT3, 2);
+      var _sourceCode$getFirstT4 = _slicedToArray(_sourceCode$getFirstT3, 2);
 
-            var colon = _sourceCode$getFirstT4[0];
-            var token = _sourceCode$getFirstT4[1];
+      var colon = _sourceCode$getFirstT4[0];
+      var token = _sourceCode$getFirstT4[1];
 
-            var spaces = token.start - functionNode.returnType.start - 1;
+      var spaces = token.start - functionNode.returnType.start - 1;
 
-            if (always && spaces > 1) {
-                context.report({
-                    fix: _utilities.spacingFixers.stripSpacesAfter(colon, spaces - 1),
-                    message: 'There must be 1 space after return type colon.',
-                    node: functionNode
-                });
-            } else if (always && spaces === 0) {
-                context.report({
-                    fix: _utilities.spacingFixers.addSpaceAfter(colon),
-                    message: 'There must be a space after return type colon.',
-                    node: functionNode
-                });
-            } else if (!always && spaces > 0) {
-                context.report({
-                    fix: _utilities.spacingFixers.stripSpacesAfter(colon, spaces),
-                    message: 'There must be no space after return type colon.',
-                    node: functionNode
-                });
-            }
-        }
-    };
+      if (always && spaces > 1) {
+        context.report({
+          fix: _utilities.spacingFixers.stripSpacesAfter(colon, spaces - 1),
+          message: 'There must be 1 space after return type colon.',
+          node: functionNode
+        });
+      } else if (always && spaces === 0) {
+        context.report({
+          fix: _utilities.spacingFixers.addSpaceAfter(colon),
+          message: 'There must be a space after return type colon.',
+          node: functionNode
+        });
+      } else if (!always && spaces > 0) {
+        context.report({
+          fix: _utilities.spacingFixers.stripSpacesAfter(colon, spaces),
+          message: 'There must be no space after return type colon.',
+          node: functionNode
+        });
+      }
+    }
+  };
 };
 
 var functionEvaluators = (0, _utilities.iterateFunctionNodes)(function (context) {
-    var checkParam = propertyEvaluator(context, 'parameter');
-    var checkReturnType = returnTypeEvaluator(context);
+  var checkParam = propertyEvaluator(context, 'parameter');
+  var checkReturnType = returnTypeEvaluator(context);
 
-    return function (functionNode) {
-        _lodash2.default.forEach(functionNode.params, checkParam);
-        checkReturnType(functionNode);
-    };
+  return function (functionNode) {
+    _lodash2.default.forEach(functionNode.params, checkParam);
+    checkReturnType(functionNode);
+  };
 });
 
+// 1) type X = { foo(): A; }
+// 2) type X = { foo: () => A; }
+// the above have identical ASTs (save for their ranges)
+// case 1 doesn't have a type annotation colon and should be ignored
+var isShortPropertyFunction = function isShortPropertyFunction(objectTypeProperty) {
+  return objectTypeProperty.value.type === 'FunctionTypeAnnotation' && objectTypeProperty.start === objectTypeProperty.value.start;
+};
+
 var objectTypePropertyEvaluator = function objectTypePropertyEvaluator(context) {
-    var _parseOptions3 = parseOptions(context);
+  var _parseOptions3 = parseOptions(context);
 
-    var always = _parseOptions3.always;
+  var always = _parseOptions3.always;
 
 
-    var sourceCode = context.getSourceCode();
+  var sourceCode = context.getSourceCode();
 
-    var getColon = function getColon(objectTypeProperty) {
-        if (objectTypeProperty.optional || objectTypeProperty.static) {
-            return sourceCode.getFirstToken(objectTypeProperty, 2);
-        } else {
-            return sourceCode.getFirstToken(objectTypeProperty, 1);
-        }
-    };
+  var getColon = function getColon(objectTypeProperty) {
+    if (objectTypeProperty.optional || objectTypeProperty.static) {
+      return sourceCode.getFirstToken(objectTypeProperty, 2);
+    } else {
+      return sourceCode.getFirstToken(objectTypeProperty, 1);
+    }
+  };
 
-    return function (objectTypeProperty) {
-        var colon = getColon(objectTypeProperty);
-        var typeAnnotation = sourceCode.getTokenAfter(colon);
+  return function (objectTypeProperty) {
+    if (isShortPropertyFunction(objectTypeProperty)) {
+      return;
+    }
 
-        var spaces = typeAnnotation.start - colon.end;
+    var colon = getColon(objectTypeProperty);
+    var typeAnnotation = sourceCode.getTokenAfter(colon);
 
-        var data = {
-            name: (0, _utilities.quoteName)((0, _utilities.getParameterName)(objectTypeProperty, context))
-        };
+    var spaces = typeAnnotation.start - colon.end;
 
-        if (always && spaces > 1) {
-            context.report({
-                data: data,
-                fix: _utilities.spacingFixers.stripSpacesAfter(colon, spaces - 1),
-                message: 'There must be 1 space after {{name}}type annotation colon.',
-                node: objectTypeProperty
-            });
-        } else if (always && spaces === 0) {
-            context.report({
-                data: data,
-                fix: _utilities.spacingFixers.addSpaceAfter(colon),
-                message: 'There must be a space after {{name}}type annotation colon.',
-                node: objectTypeProperty
-            });
-        } else if (!always && spaces > 0) {
-            context.report({
-                data: data,
-                fix: _utilities.spacingFixers.stripSpacesAfter(colon, spaces),
-                message: 'There must be no space after {{name}}type annotation colon.',
-                node: objectTypeProperty
-            });
-        }
+    var data = {
+      name: (0, _utilities.quoteName)((0, _utilities.getParameterName)(objectTypeProperty, context))
     };
+
+    if (always && spaces > 1) {
+      context.report({
+        data: data,
+        fix: _utilities.spacingFixers.stripSpacesAfter(colon, spaces - 1),
+        message: 'There must be 1 space after {{name}}type annotation colon.',
+        node: objectTypeProperty
+      });
+    } else if (always && spaces === 0) {
+      context.report({
+        data: data,
+        fix: _utilities.spacingFixers.addSpaceAfter(colon),
+        message: 'There must be a space after {{name}}type annotation colon.',
+        node: objectTypeProperty
+      });
+    } else if (!always && spaces > 0) {
+      context.report({
+        data: data,
+        fix: _utilities.spacingFixers.stripSpacesAfter(colon, spaces),
+        message: 'There must be no space after {{name}}type annotation colon.',
+        node: objectTypeProperty
+      });
+    }
+  };
 };
 
 exports.default = function (context) {
-    return _extends({}, functionEvaluators(context), {
-        ClassProperty: propertyEvaluator(context, 'class property'),
-        ObjectTypeProperty: objectTypePropertyEvaluator(context)
-    });
+  return _extends({}, functionEvaluators(context), {
+    ClassProperty: propertyEvaluator(context, 'class property'),
+    ObjectTypeProperty: objectTypePropertyEvaluator(context)
+  });
 };
 
 module.exports = exports['default'];

dist/rules/spaceBeforeGenericBracket.js

 'use strict';
 
 Object.defineProperty(exports, "__esModule", {
-    value: true
+  value: true
 });
@@ -10,47 +10,47 @@
 exports.default = function (context) {
-    var never = (context.options[0] || 'never') === 'never';
+  var never = (context.options[0] || 'never') === 'never';
 
-    return {
-        GenericTypeAnnotation: function GenericTypeAnnotation(node) {
-            var types = node.typeParameters;
+  return {
+    GenericTypeAnnotation: function GenericTypeAnnotation(node) {
+      var types = node.typeParameters;
 
-            // Promise<foo>
-            // ^^^^^^^^^^^^ GenericTypeAnnotation (with typeParameters)
-            //         ^^^  GenericTypeAnnotation (without typeParameters)
-            if (!types) {
-                return;
-            }
+      // Promise<foo>
+      // ^^^^^^^^^^^^ GenericTypeAnnotation (with typeParameters)
+      //         ^^^  GenericTypeAnnotation (without typeParameters)
+      if (!types) {
+        return;
+      }
 
-            var spaceBefore = types.start - node.id.end;
+      var spaceBefore = types.start - node.id.end;
 
-            if (never && spaceBefore) {
-                context.report({
-                    data: { name: node.id.name },
-                    fix: _utilities.spacingFixers.stripSpacesAfter(node.id, spaceBefore),
-                    message: 'There must be no space before "{{name}}" generic type annotation bracket',
-                    node: node
-                });
-            }
+      if (never && spaceBefore) {
+        context.report({
+          data: { name: node.id.name },
+          fix: _utilities.spacingFixers.stripSpacesAfter(node.id, spaceBefore),
+          message: 'There must be no space before "{{name}}" generic type annotation bracket',
+          node: node
+        });
+      }
 
-            if (!never && !spaceBefore) {
-                context.report({
-                    data: { name: node.id.name },
-                    fix: _utilities.spacingFixers.addSpaceAfter(node.id),
-                    message: 'There must be a space before "{{name}}" generic type annotation bracket',
-                    node: node
-                });
-            }
+      if (!never && !spaceBefore) {
+        context.report({
+          data: { name: node.id.name },
+          fix: _utilities.spacingFixers.addSpaceAfter(node.id),
+          message: 'There must be a space before "{{name}}" generic type annotation bracket',
+          node: node
+        });
+      }
 
-            if (!never && spaceBefore > 1) {
-                context.report({
-                    data: { name: node.id.name },
-                    fix: _utilities.spacingFixers.stripSpacesAfter(node.id, spaceBefore - 1),
-                    message: 'There must be one space before "{{name}}" generic type annotation bracket',
-                    node: node
-                });
-            }
-        }
-    };
+      if (!never && spaceBefore > 1) {
+        context.report({
+          data: { name: node.id.name },
+          fix: _utilities.spacingFixers.stripSpacesAfter(node.id, spaceBefore - 1),
+          message: 'There must be one space before "{{name}}" generic type annotation bracket',
+          node: node
+        });
+      }
+    }
+  };
 };
 
 module.exports = exports['default'];

dist/rules/spaceBeforeTypeColon.js

 'use strict';
 
 Object.defineProperty(exports, "__esModule", {
-    value: true
+  value: true
 });
@@ -20,151 +20,151 @@
 var parseOptions = function parseOptions(context) {
-    return {
-        always: context.options[0] === 'always'
-    };
+  return {
+    always: context.options[0] === 'always'
+  };
 };
 
 var propertyEvaluator = function propertyEvaluator(context, typeForMessage) {
-    var _parseOptions = parseOptions(context);
+  var _parseOptions = parseOptions(context);
 
-    var always = _parseOptions.always;
+  var always = _parseOptions.always;
 
 
-    var sourceCode = context.getSourceCode();
+  var sourceCode = context.getSourceCode();
 
-    var getSpacesBeforeColon = function getSpacesBeforeColon(node, typeAnnotation) {
-        if (node.type === 'FunctionTypeParam') {
-            // the colon isn't included in the typeAnnotation node here...
-            var colon = sourceCode.getTokenBefore(typeAnnotation);
-            var tokenBeforeColon = sourceCode.getTokenBefore(colon);
+  var getSpacesBeforeColon = function getSpacesBeforeColon(node, typeAnnotation) {
+    if (node.type === 'FunctionTypeParam') {
+      // the colon isn't included in the typeAnnotation node here...
+      var colon = sourceCode.getTokenBefore(typeAnnotation);
+      var tokenBeforeColon = sourceCode.getTokenBefore(colon);
 
-            return {
-                spaces: colon.start - tokenBeforeColon.end,
-                tokenBeforeType: tokenBeforeColon
-            };
-        } else {
-            // tokenBeforeColon can be the identifier or the closing } token of a destructuring
-            var _tokenBeforeColon = sourceCode.getTokenBefore(typeAnnotation);
+      return {
+        spaces: colon.start - tokenBeforeColon.end,
+        tokenBeforeType: tokenBeforeColon
+      };
+    } else {
+      // tokenBeforeColon can be the identifier or the closing } token of a destructuring
+      var _tokenBeforeColon = sourceCode.getTokenBefore(typeAnnotation);
 
-            return {
-                spaces: typeAnnotation.start - _tokenBeforeColon.end,
-                tokenBeforeType: _tokenBeforeColon
-            };
-        }
-    };
+      return {
+        spaces: typeAnnotation.start - _tokenBeforeColon.end,
+        tokenBeforeType: _tokenBeforeColon
+      };
+    }
+  };
 
-    return function (node) {
-        var typeAnnotation = _lodash2.default.get(node, 'typeAnnotation') || _lodash2.default.get(node, 'left.typeAnnotation');
+  return function (node) {
+    var typeAnnotation = _lodash2.default.get(node, 'typeAnnotation') || _lodash2.default.get(node, 'left.typeAnnotation');
 
-        if (typeAnnotation) {
-            // tokenBeforeType can be the identifier or the closing } token of a destructuring
-            var _getSpacesBeforeColon = getSpacesBeforeColon(node, typeAnnotation);
+    if (typeAnnotation) {
+      // tokenBeforeType can be the identifier or the closing } token of a destructuring
+      var _getSpacesBeforeColon = getSpacesBeforeColon(node, typeAnnotation);
 
-            var spaces = _getSpacesBeforeColon.spaces;
-            var tokenBeforeType = _getSpacesBeforeColon.tokenBeforeType;
+      var spaces = _getSpacesBeforeColon.spaces;
+      var tokenBeforeType = _getSpacesBeforeColon.tokenBeforeType;
 
 
-            var data = {
-                name: (0, _utilities.quoteName)((0, _utilities.getParameterName)(node, context)),
-                type: typeForMessage
-            };
+      var data = {
+        name: (0, _utilities.quoteName)((0, _utilities.getParameterName)(node, context)),
+        type: typeForMessage
+      };
 
-            if (always && spaces > 1) {
-                context.report({
-                    data: data,
-                    fix: _utilities.spacingFixers.stripSpacesAfter(tokenBeforeType, spaces - 1),
-                    message: 'There must be 1 space before {{name}}{{type}} type annotation colon.',
-                    node: node
-                });
-            } else if (always && spaces === 0) {
-                context.report({
-                    data: data,
-                    fix: _utilities.spacingFixers.addSpaceAfter(tokenBeforeType),
-                    message: 'There must be a space before {{name}}{{type}} type annotation colon.',
-                    node: node
-                });
-            } else if (!always && spaces > 0) {
-                context.report({
-                    data: data,
-                    fix: _utilities.spacingFixers.stripSpacesAfter(tokenBeforeType, spaces),
-                    message: 'There must be no space before {{name}}{{type}} type annotation colon.',
-                    node: node
-                });
-            }
-        }
-    };
+      if (always && spaces > 1) {
+        context.report({
+          data: data,
+          fix: _utilities.spacingFixers.stripSpacesAfter(tokenBeforeType, spaces - 1),
+          message: 'There must be 1 space before {{name}}{{type}} type annotation colon.',
+          node: node
+        });
+      } else if (always && spaces === 0) {
+        context.report({
+          data: data,
+          fix: _utilities.spacingFixers.addSpaceAfter(tokenBeforeType),
+          message: 'There must be a space before {{name}}{{type}} type annotation colon.',
+          node: node
+        });
+      } else if (!always && spaces > 0) {
+        context.report({
+          data: data,
+          fix: _utilities.spacingFixers.stripSpacesAfter(tokenBeforeType, spaces),
+          message: 'There must be no space before {{name}}{{type}} type annotation colon.',
+          node: node
+        });
+      }
+    }
+  };
 };
 
 var functionEvaluators = (0, _utilities.iterateFunctionNodes)(function (context) {
-    var checkParam = propertyEvaluator(context, 'parameter');
+  var checkParam = propertyEvaluator(context, 'parameter');
 
-    return function (functionNode) {
-        _lodash2.default.forEach(functionNode.params, checkParam);
-    };
+  return function (functionNode) {
+    _lodash2.default.forEach(functionNode.params, checkParam);
+  };
 });
 
 var objectTypePropertyEvaluator = function objectTypePropertyEvaluator(context) {
-    var _parseOptions2 = parseOptions(context);
+  var _parseOptions2 = parseOptions(context);
 
-    var always = _parseOptions2.always;
+  var always = _parseOptions2.always;
 
 
-    var sourceCode = context.getSourceCode();
+  var sourceCode = context.getSourceCode();
 
-    var getFirstTokens = function getFirstTokens(objectTypeProperty) {
-        var tokens = sourceCode.getFirstTokens(objectTypeProperty, 3);
+  var getFirstTokens = function getFirstTokens(objectTypeProperty) {
+    var tokens = sourceCode.getFirstTokens(objectTypeProperty, 3);
 
-        if (objectTypeProperty.optional || objectTypeProperty.static) {
-            return [tokens[1], tokens[2]];
-        } else {
-            return [tokens[0], tokens[1]];
-        }
-    };
+    if (objectTypeProperty.optional || objectTypeProperty.static) {
+      return [tokens[1], tokens[2]];
+    } else {
+      return [tokens[0], tokens[1]];
+    }
+  };
 
-    return function (objectTypeProperty) {
-        // tokenBeforeColon can be identifier, or a ? token if is optional
-        var _getFirstTokens = getFirstTokens(objectTypeProperty);
+  return function (objectTypeProperty) {
+    // tokenBeforeColon can be identifier, or a ? token if is optional
+    var _getFirstTokens = getFirstTokens(objectTypeProperty);
 
-        var _getFirstTokens2 = _slicedToArray(_getFirstTokens, 2);
+    var _getFirstTokens2 = _slicedToArray(_getFirstTokens, 2);
 
-        var tokenBeforeColon = _getFirstTokens2[0];
-        var colon = _getFirstTokens2[1];
+    var tokenBeforeColon = _getFirstTokens2[0];
+    var colon = _getFirstTokens2[1];
 
-        var spaces = colon.start - tokenBeforeColon.end;
+    var spaces = colon.start - tokenBeforeColon.end;
 
-        var data = {
-            name: (0, _utilities.quoteName)((0, _utilities.getParameterName)(objectTypeProperty, context))
-        };
+    var data = {
+      name: (0, _utilities.quoteName)((0, _utilities.getParameterName)(objectTypeProperty, context))
+    };
 
-        if (always && spaces > 1) {
-            context.report({
-                data: data,
-                fix: _utilities.spacingFixers.stripSpacesAfter(tokenBeforeColon, spaces - 1),
-                message: 'There must be 1 space before {{name}}type annotation colon.',
-                node: objectTypeProperty
-            });
-        } else if (always && spaces === 0) {
-            context.report({
-                data: data,
-                fix: _utilities.spacingFixers.addSpaceAfter(tokenBeforeColon),
-                message: 'There must be a space before {{name}}type annotation colon.',
-                node: objectTypeProperty
-            });
-        } else if (!always && spaces > 0) {
-            context.report({
-                data: data,
-                fix: _utilities.spacingFixers.stripSpacesAfter(tokenBeforeColon, spaces),
-                message: 'There must be no space before {{name}}type annotation colon.',
-                node: objectTypeProperty
-            });
-        }
-    };
+    if (always && spaces > 1) {
+      context.report({
+        data: data,
+        fix: _utilities.spacingFixers.stripSpacesAfter(tokenBeforeColon, spaces - 1),
+        message: 'There must be 1 space before {{name}}type annotation colon.',
+        node: objectTypeProperty
+      });
+    } else if (always && spaces === 0) {
+      context.report({
+        data: data,
+        fix: _utilities.spacingFixers.addSpaceAfter(tokenBeforeColon),
+        message: 'There must be a space before {{name}}type annotation colon.',
+        node: objectTypeProperty
+      });
+    } else if (!always && spaces > 0) {
+      context.report({
+        data: data,
+        fix: _utilities.spacingFixers.stripSpacesAfter(tokenBeforeColon, spaces),
+        message: 'There must be no space before {{name}}type annotation colon.',
+        node: objectTypeProperty
+      });
+    }
+  };
 };
 
 exports.default = function (context) {
-    return _extends({}, functionEvaluators(context), {
-        ClassProperty: propertyEvaluator(context, 'class property'),
-        ObjectTypeProperty: objectTypePropertyEvaluator(context)
-    });
+  return _extends({}, functionEvaluators(context), {
+    ClassProperty: propertyEvaluator(context, 'class property'),
+    ObjectTypeProperty: objectTypePropertyEvaluator(context)
+  });
 };
 
 module.exports = exports['default'];

dist/rules/typeIdMatch.js

 'use strict';
 
 Object.defineProperty(exports, "__esModule", {
-    value: true
+  value: true
 });
 var schema = exports.schema = [{
-    type: 'string'
+  type: 'string'
 }];
 
 exports.default = function (context) {
-    var pattern = new RegExp(context.options[0] || '^([A-Z][a-z0-9]+)+Type$');
+  var pattern = new RegExp(context.options[0] || '^([A-Z][a-z0-9]+)+Type$');
 
-    return {
-        TypeAlias: function TypeAlias(typeAliasNode) {
-            var typeIdentifierName = typeAliasNode.id.name;
+  return {
+    TypeAlias: function TypeAlias(typeAliasNode) {
+      var typeIdentifierName = typeAliasNode.id.name;
 
-            if (!pattern.test(typeIdentifierName)) {
-                context.report(typeAliasNode, 'Type identifier \'{{name}}\' does not match pattern \'{{pattern}}\'.', {
-                    name: typeIdentifierName,
-                    pattern: pattern.toString()
-                });
-            }
-        }
-    };
+      if (!pattern.test(typeIdentifierName)) {
+        context.report(typeAliasNode, 'Type identifier \'{{name}}\' does not match pattern \'{{pattern}}\'.', {
+          name: typeIdentifierName,
+          pattern: pattern.toString()
+        });
+      }
+    }
+  };
 };

dist/rules/unionIntersectionSpacing.js

 'use strict';
 
 Object.defineProperty(exports, "__esModule", {
-    value: true
+  value: true
 });
@@ -10,79 +10,79 @@
 exports.default = function (context) {
-    var sourceCode = context.getSourceCode();
+  var sourceCode = context.getSourceCode();
 
-    var always = (context.options[0] || 'always') === 'always';
+  var always = (context.options[0] || 'always') === 'always';
 
-    var getTokenAfterParens = function getTokenAfterParens(node) {
-        var sep = void 0;
+  var getTokenAfterParens = function getTokenAfterParens(node) {
+    var sep = void 0;
 
-        sep = sourceCode.getTokenAfter(node);
+    sep = sourceCode.getTokenAfter(node);
 
-        while (sep.type === 'Punctuator' && sep.value === ')') {
-            sep = sourceCode.getTokenAfter(sep);
-        }
+    while (sep.type === 'Punctuator' && sep.value === ')') {
+      sep = sourceCode.getTokenAfter(sep);
+    }
 
-        return sep;
-    };
+    return sep;
+  };
 
-    var check = function check(node) {
-        node.types.forEach(function (type, index) {
-            if (index + 1 === node.types.length) {
-                return;
-            }
+  var check = function check(node) {
+    node.types.forEach(function (type, index) {
+      if (index + 1 === node.types.length) {
+        return;
+      }
 
-            var separator = getTokenAfterParens(type);
-            var endOfType = sourceCode.getTokenBefore(separator);
-            var nextType = sourceCode.getTokenAfter(separator);
+      var separator = getTokenAfterParens(type);
+      var endOfType = sourceCode.getTokenBefore(separator);
+      var nextType = sourceCode.getTokenAfter(separator);
 
-            var spaceBefore = separator.start - endOfType.end;
-            var spaceAfter = nextType.start - separator.end;
+      var spaceBefore = separator.start - endOfType.end;
+      var spaceAfter = nextType.start - separator.end;
 
-            var data = { type: node.type === 'UnionTypeAnnotation' ? 'union' : 'intersection' };
+      var data = { type: node.type === 'UnionTypeAnnotation' ? 'union' : 'intersection' };
 
-            if (always) {
-                if (!spaceBefore) {
-                    context.report({
-                        data: data,
-                        fix: _utilities.spacingFixers.addSpaceAfter(endOfType),
-                        message: 'There must be a space before {{type}} type annotation separator',
-                        node: node
-                    });
-                }
+      if (always) {
+        if (!spaceBefore) {
+          context.report({
+            data: data,
+            fix: _utilities.spacingFixers.addSpaceAfter(endOfType),
+            message: 'There must be a space before {{type}} type annotation separator',
+            node: node
+          });
+        }
 
-                if (!spaceAfter) {
-                    context.report({
-                        data: data,
-                        fix: _utilities.spacingFixers.addSpaceAfter(separator),
-                        message: 'There must be a space after {{type}} type annotation separator',
-                        node: node
-                    });
-                }
-            } else {
-                if (spaceBefore) {
-                    context.report({
-                        data: data,
-                        fix: _utilities.spacingFixers.stripSpacesAfter(endOfType, spaceBefore),
-                        message: 'There must be no space before {{type}} type annotation separator',
-                        node: node
-                    });
-                }
+        if (!spaceAfter) {
+          context.report({
+            data: data,
+            fix: _utilities.spacingFixers.addSpaceAfter(separator),
+            message: 'There must be a space after {{type}} type annotation separator',
+            node: node
+          });
+        }
+      } else {
+        if (spaceBefore) {
+          context.report({
+            data: data,
+            fix: _utilities.spacingFixers.stripSpacesAfter(endOfType, spaceBefore),
+            message: 'There must be no space before {{type}} type annotation separator',
+            node: node
+          });
+        }
 
-                if (spaceAfter) {
-                    context.report({
-                        data: data,
-                        fix: _utilities.spacingFixers.stripSpacesAfter(separator, spaceAfter),
-                        message: 'There must be no space after {{type}} type annotation separator',
-                        node: node
-                    });
-                }
-            }
-        });
-    };
+        if (spaceAfter) {
+          context.report({
+            data: data,
+            fix: _utilities.spacingFixers.stripSpacesAfter(separator, spaceAfter),
+            message: 'There must be no space after {{type}} type annotation separator',
+            node: node
+          });
+        }
+      }
+    });
+  };
 
-    return {
-        IntersectionTypeAnnotation: check,
-        UnionTypeAnnotation: check
-    };
+  return {
+    IntersectionTypeAnnotation: check,
+    UnionTypeAnnotation: check
+  };
 };
 
 module.exports = exports['default'];

dist/rules/useFlowType.js

 'use strict';
 
 Object.defineProperty(exports, "__esModule", {
-    value: true
+  value: true
 });
@@ -9,34 +9,34 @@ var schema = exports.schema = [];
 exports.default = function (context) {
-    var markTypeAsUsed = function markTypeAsUsed(node) {
-        context.markVariableAsUsed(node.id.name);
-    };
+  var markTypeAsUsed = function markTypeAsUsed(node) {
+    context.markVariableAsUsed(node.id.name);
+  };
 
-    return {
-        DeclareClass: markTypeAsUsed,
-        DeclareFunction: markTypeAsUsed,
-        DeclareModule: markTypeAsUsed,
-        DeclareVariable: markTypeAsUsed,
-        GenericTypeAnnotation: function GenericTypeAnnotation(node) {
-            var typeId = void 0;
-            var scope = void 0;
-            var variable = void 0;
+  return {
+    DeclareClass: markTypeAsUsed,
+    DeclareFunction: markTypeAsUsed,
+    DeclareModule: markTypeAsUsed,
+    DeclareVariable: markTypeAsUsed,
+    GenericTypeAnnotation: function GenericTypeAnnotation(node) {
+      var typeId = void 0;
+      var scope = void 0;
+      var variable = void 0;
 
-            if (node.id.type === 'Identifier') {
-                typeId = node.id;
-            } else if (node.id.type === 'QualifiedTypeIdentifier') {
-                typeId = node.id;
-                do {
-                    typeId = typeId.qualification;
-                } while (typeId.qualification);
-            }
+      if (node.id.type === 'Identifier') {
+        typeId = node.id;
+      } else if (node.id.type === 'QualifiedTypeIdentifier') {
+        typeId = node.id;
+        do {
+          typeId = typeId.qualification;
+        } while (typeId.qualification);
+      }
 
-            for (scope = context.getScope(); scope; scope = scope.upper) {
-                variable = scope.set.get(typeId.name);
-                if (variable && variable.defs.length) {
-                    context.markVariableAsUsed(typeId.name);
-                    break;
-                }
-            }
+      for (scope = context.getScope(); scope; scope = scope.upper) {
+        variable = scope.set.get(typeId.name);
+        if (variable && variable.defs.length) {
+          context.markVariableAsUsed(typeId.name);
+          break;
         }
-    };
+      }
+    }
+  };
 };

dist/rules/validSyntax.js

 'use strict';
 
 Object.defineProperty(exports, "__esModule", {
-    value: true
+  value: true
 });
@@ -16,21 +16,21 @@
 exports.default = (0, _utilities.iterateFunctionNodes)(function (context) {
-    return function (functionNode) {
-        _lodash2.default.forEach(functionNode.params, function (identifierNode) {
-            var nodeType = _lodash2.default.get(identifierNode, 'type');
-            var isAssignmentPattern = nodeType === 'AssignmentPattern';
-            var hasTypeAnnotation = Boolean(_lodash2.default.get(identifierNode, 'typeAnnotation'));
-            var leftAnnotated = Boolean(_lodash2.default.get(identifierNode, 'left.typeAnnotation'));
+  return function (functionNode) {
+    _lodash2.default.forEach(functionNode.params, function (identifierNode) {
+      var nodeType = _lodash2.default.get(identifierNode, 'type');
+      var isAssignmentPattern = nodeType === 'AssignmentPattern';
+      var hasTypeAnnotation = Boolean(_lodash2.default.get(identifierNode, 'typeAnnotation'));
+      var leftAnnotated = Boolean(_lodash2.default.get(identifierNode, 'left.typeAnnotation'));
 
-            if (isAssignmentPattern && hasTypeAnnotation && !leftAnnotated) {
-                context.report({
-                    data: {
-                        name: (0, _utilities.quoteName)((0, _utilities.getParameterName)(identifierNode, context))
-                    },
-                    message: '{{name}}parameter type annotation must be placed on left-hand side of assignment.',
-                    node: identifierNode
-                });
-            }
+      if (isAssignmentPattern && hasTypeAnnotation && !leftAnnotated) {
+        context.report({
+          data: {
+            name: (0, _utilities.quoteName)((0, _utilities.getParameterName)(identifierNode, context))
+          },
+          message: '{{name}}parameter type annotation must be placed on left-hand side of assignment.',
+          node: identifierNode
         });
-    };
+      }
+    });
+  };
 });
 module.exports = exports['default'];

dist/utilities/getParameterName.js

 'use strict';
 
 Object.defineProperty(exports, "__esModule", {
-    value: true
+  value: true
 });
@@ -14,42 +14,42 @@
 exports.default = function (identifierNode, context) {
-    if (_lodash2.default.has(identifierNode, 'name')) {
-        return identifierNode.name;
-    }
+  if (_lodash2.default.has(identifierNode, 'name')) {
+    return identifierNode.name;
+  }
 
-    if (_lodash2.default.has(identifierNode, 'left.name')) {
-        return identifierNode.left.name;
-    }
+  if (_lodash2.default.has(identifierNode, 'left.name')) {
+    return identifierNode.left.name;
+  }
 
-    if (_lodash2.default.has(identifierNode, 'key.name')) {
-        return identifierNode.key.name;
-    }
+  if (_lodash2.default.has(identifierNode, 'key.name')) {
+    return identifierNode.key.name;
+  }
 
-    if (identifierNode.type === 'RestElement') {
-        return identifierNode.argument.name;
-    }
+  if (identifierNode.type === 'RestElement') {
+    return identifierNode.argument.name;
+  }
 
-    if (identifierNode.type === 'ObjectTypeProperty') {
-        return context.getSourceCode().getFirstToken(identifierNode, identifierNode.static ? 1 : 0).value;
-    }
+  if (identifierNode.type === 'ObjectTypeProperty') {
+    return context.getSourceCode().getFirstToken(identifierNode, identifierNode.static ? 1 : 0).value;
+  }
 
-    if (identifierNode.type === 'FunctionTypeParam') {
-        return context.getSourceCode().getFirstToken(identifierNode).value;
-    }
+  if (identifierNode.type === 'FunctionTypeParam') {
+    return context.getSourceCode().getFirstToken(identifierNode).value;
+  }
 
-    if (identifierNode.type === 'ObjectPattern' || identifierNode.type === 'ArrayPattern') {
-        var text = context.getSourceCode().getText(identifierNode);
+  if (identifierNode.type === 'ObjectPattern' || identifierNode.type === 'ArrayPattern') {
+    var text = context.getSourceCode().getText(identifierNode);
 
-        if (identifierNode.typeAnnotation) {
-            return text.replace(context.getSourceCode().getText(identifierNode.typeAnnotation), '').trim();
-        } else {
-            return text;
-        }
+    if (identifierNode.typeAnnotation) {
+      return text.replace(context.getSourceCode().getText(identifierNode.typeAnnotation), '').trim();
+    } else {
+      return text;
     }
-    if (_lodash2.default.get(identifierNode, 'left.type') === 'ObjectPattern') {
-        return context.getSourceCode().getText(identifierNode.left);
-    }
+  }
+  if (_lodash2.default.get(identifierNode, 'left.type') === 'ObjectPattern') {
+    return context.getSourceCode().getText(identifierNode.left);
+  }
 
-    return null;
+  return null;
 };
 
 module.exports = exports['default'];

dist/utilities/isFlowFile.js

 'use strict';
 
 Object.defineProperty(exports, "__esModule", {
-    value: true
+  value: true
 });
@@ -14,13 +14,13 @@
 exports.default = function (context) {
-    var comments = context.getAllComments();
+  var comments = context.getAllComments();
 
-    if (!comments.length) {
-        return false;
-    }
+  if (!comments.length) {
+    return false;
+  }
 
-    var firstComment = comments[0];
+  var firstComment = comments[0];
 
-    return (0, _isFlowFileAnnotation2.default)(firstComment.value);
+  return (0, _isFlowFileAnnotation2.default)(firstComment.value);
 };
 
 module.exports = exports['default'];

dist/utilities/isFlowFileAnnotation.js

 'use strict';
 
 Object.defineProperty(exports, "__esModule", {
-    value: true
+  value: true
 });
@@ -16,9 +16,9 @@
 exports.default = function (comment) {
-    // The flow parser splits comments with the following regex to look for the @flow flag.
-    // See https://github.com/facebook/flow/blob/a96249b93541f2f7bfebd8d62085bf7a75de02f2/src/parsing/docblock.ml#L39
-    return _lodash2.default.some(comment.split(/[ \t\r\n\\*/]+/), function (commentPart) {
-        return FLOW_MATCHER.test(commentPart);
-    });
+  // The flow parser splits comments with the following regex to look for the @flow flag.
+  // See https://github.com/facebook/flow/blob/a96249b93541f2f7bfebd8d62085bf7a75de02f2/src/parsing/docblock.ml#L39
+  return _lodash2.default.some(comment.split(/[ \t\r\n\\*/]+/), function (commentPart) {
+    return FLOW_MATCHER.test(commentPart);
+  });
 };
 
 module.exports = exports['default'];

dist/utilities/iterateFunctionNodes.js

 "use strict";
 
 Object.defineProperty(exports, "__esModule", {
-    value: true
+  value: true
 });
 
 exports.default = function (iterator) {
-    return function (context) {
-        var nodeIterator = iterator(context);
+  return function (context) {
+    var nodeIterator = iterator(context);
 
-        return {
-            ArrowFunctionExpression: nodeIterator,
-            FunctionDeclaration: nodeIterator,
-            FunctionExpression: nodeIterator,
-            FunctionTypeAnnotation: nodeIterator
-        };
+    return {
+      ArrowFunctionExpression: nodeIterator,
+      FunctionDeclaration: nodeIterator,
+      FunctionExpression: nodeIterator,
+      FunctionTypeAnnotation: nodeIterator
     };
+  };
 };
 
 module.exports = exports["default"];

dist/utilities/quoteName.js

 'use strict';
 
 Object.defineProperty(exports, "__esModule", {
-    value: true
+  value: true
 });
 
 exports.default = function (name) {
-    return name ? '"' + name + '" ' : '';
+  return name ? '"' + name + '" ' : '';
 };
 
 module.exports = exports['default'];

dist/utilities/spacingFixers.js

 'use strict';
 
 Object.defineProperty(exports, "__esModule", {
-    value: true
+  value: true
 });
 var stripSpacesAfter = exports.stripSpacesAfter = function stripSpacesAfter(node, spaces) {
-    return function (fixer) {
-        return fixer.removeRange([node.end, node.end + spaces]);
-    };
+  return function (fixer) {
+    return fixer.removeRange([node.end, node.end + spaces]);
+  };
 };
 
 var addSpaceAfter = exports.addSpaceAfter = function addSpaceAfter(node) {
-    return function (fixer) {
-        return fixer.insertTextAfter(node, ' ');
-    };
+  return function (fixer) {
+    return fixer.insertTextAfter(node, ' ');
+  };
 };

package.json

 {
   "name": "eslint-plugin-flowtype",
   "description": "Flowtype linting rules for ESLint.",
-  "version": "2.11.1",
+  "version": "2.11.4",
   "main": "./dist/index.js",
@@ -25,3 +25,3 @@ "repository": {
   "dependencies": {
-    "lodash": "^4.9.0"
+    "lodash": "^4.15.0"
   },
@@ -32,20 +32,22 @@ "scripts": {
     "build": "babel ./src --out-dir ./dist",
-    "readme-add-assertions": "babel-node ./bin/readmeAssertions",
-    "readme": "node ./node_modules/.bin/gitdown ./.README/README.md --output-file ./README.md; npm run readme-add-assertions",
+    "documentation-add-assertions": "babel-node ./bin/readmeAssertions",
+    "documentation": "gitdown ./.README/README.md --output-file ./README.md; npm run documentation-add-assertions",
     "create-index": "create-index ./src --update-index"
   },
   "devDependencies": {
-    "babel-cli": "^6.7.5",
-    "babel-eslint": "^6.0.2",
+    "babel-cli": "^6.11.4",
+    "babel-eslint": "^6.1.2",
     "babel-plugin-add-module-exports": "^0.2.1",
-    "babel-preset-es2015": "^6.9.0",
+    "babel-preset-es2015": "^6.13.2",
     "babel-preset-stage-0": "^6.5.0",
-    "babel-register": "^6.9.0",
+    "babel-register": "^6.11.6",
     "chai": "^3.5.0",
-    "create-index": "^0.1.2",
-    "eslint": "^2.13.1",
-    "eslint-config-canonical": "1.7.12",
-    "gitdown": "^2.4.8",
-    "mocha": "^2.5.3"
+    "create-index": "^0.1.3",
+    "eslint": "^3.3.1",
+    "eslint-config-canonical": "1.7.16",
+    "gitdown": "^2.4.10",
+    "mocha": "^3.0.2",
+    "standard-version": "^2.4.0",
+    "travis-after-all": "^1.4.4"
   }
 }

README.md

@@ -53,36 +53,36 @@ <h1 id="eslint-plugin-flowtype">eslint-plugin-flowtype</h1>
 {
-    "parser": "babel-eslint",
-    "plugins": [
-        "flowtype"
+  "parser": "babel-eslint",
+  "plugins": [
+    "flowtype"
+  ],
+  "rules": {
+    "flowtype/define-flow-type": 1,
+    "flowtype/require-parameter-type": 1,
+    "flowtype/require-return-type": [
+      1,
+      "always",
+      {
+        "annotateUndefined": "never"
+      }
     ],
-    "rules": {
-        "flowtype/define-flow-type": 1,
-        "flowtype/require-parameter-type": 1,
-        "flowtype/require-return-type": [
-            1,
-            "always",
-            {
-                "annotateUndefined": "never"
-            }
-        ],
-        "flowtype/space-after-type-colon": [
-            1,
-            "always"
-        ],
-        "flowtype/space-before-type-colon": [
-            1,
-            "never"
-        ],
-        "flowtype/type-id-match": [
-            1,
-            "^([A-Z][a-z0-9]+)+Type$"
-        ],
-        "flowtype/use-flow-type": 1,
-        "flowtype/valid-syntax": 1
-    },
-    "settings": {
-        "flowtype": {
-            "onlyFilesWithFlowAnnotation": false
-        }
+    "flowtype/space-after-type-colon": [
+      1,
+      "always"
+    ],
+    "flowtype/space-before-type-colon": [
+      1,
+      "never"
+    ],
+    "flowtype/type-id-match": [
+      1,
+      "^([A-Z][a-z0-9]+)+Type$"
+    ],
+    "flowtype/use-flow-type": 1,
+    "flowtype/valid-syntax": 1
+  },
+  "settings": {
+    "flowtype": {
+      "onlyFilesWithFlowAnnotation": false
     }
+  }
 }
@@ -99,7 +99,7 @@ ```
 {
-    "settings": {
-        "flowtype": {
-            "onlyFilesWithFlowAnnotation": true
-        }
+  "settings": {
+    "flowtype": {
+      "onlyFilesWithFlowAnnotation": true
     }
+  }
 }
@@ -654,2 +654,12 @@ ```
 
+(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.
+
 // Options: ["always"]
@@ -697,2 +707,12 @@ ():Object => {}
 
+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.
+
 type X = (foo:number) => string
@@ -727,2 +747,12 @@ // 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 }
@@ -812,2 +842,22 @@ // Message: There must be a space after "foo" class property type annotation colon.
 // 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:<X>() => 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: <X>() => 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:  <X>() => A; }
+// Message: There must be 1 space after "get" type annotation colon.
 ```
@@ -844,3 +894,8 @@
 
+(i?: number) => {}
+
 // Options: ["never"]
+(i?:number) => {}
+
+// Options: ["never"]
 ():Object => {}
@@ -894,2 +949,7 @@
 
+function x(i?: number) {}
+
+// Options: ["never"]
+function x(i?:number) {}
+
 type X = (foo: number) => string;
@@ -923,2 +983,7 @@
 
+type TArrayPredicate = (el: T, i?: number) => boolean
+
+// Options: ["never"]
+type TArrayPredicate = (el:T, i?:number) => boolean
+
 class Foo { bar }
@@ -969,2 +1034,22 @@
 type Foo = { barType:((string | () => void)) }
+
+type X = { get(): A; }
+
+type X = { get<X>(): A; }
+
+// Options: ["never"]
+type X = { get(): A; }
+
+// Options: ["never"]
+type X = { get<X>(): A; }
+
+type X = { get: () => A; }
+
+type X = { get: <X>() => A; }
+
+// Options: ["never"]
+type X = { get:() => A; }
+
+// Options: ["never"]
+type X = { get:<X>() => A; }
 ```
@@ -1432,5 +1517,5 @@
 function x() {
-	type X =
-	| string
-	| number
+type X =
+| string
+| number
 }
@@ -1454,5 +1539,5 @@
 function x() {
-	type X =
-	& string
-	& number
+type X =
+& string
+& number
 }
@@ -1459,0 +1544,0 @@ ```

New alerts

License Policy Violation

License

This package is not allowed per your license policy. Review the package's license to ensure compliance.

Found 1 instance in 1 package

Fixed alerts

License Policy Violation

License

This package is not allowed per your license policy. Review the package's license to ensure compliance.

Found 1 instance in 1 package

Improved metrics

Number of package files

36

increased by2.86%

Lines of code

1035

increased by0.98%

Number of lines in readme file

1742

increased by5.13%

Worsened metrics

Total package byte prevSize

115903

decreased by-0.67%

Dev dependency count

14

increased by16.67%

Dependency changes

• Updatedlodash@^4.15.0