bump flow so there are no errors

Author: v1rtl

__mocks__/genInteractives.js

@@ -170,7 +170,7 @@ export function genInteractiveElements(): Array<JSXElementMockType> {
     if (bracketIndex > -1) {
       name = elementSymbol.slice(0, bracketIndex);
     }
-    const attributes = interactiveElementsMap[elementSymbol].map(({ prop, value }) => JSXAttributeMock(prop, value));
+    const attributes = interactiveElementsMap[elementSymbol as any].map(({ prop, value }) => JSXAttributeMock(prop, value));
     return JSXElementMock(name, attributes);
   });
 }

__tests__/__util__/ruleOptionsMapperFactory.js

@@ -23,7 +23,7 @@ export default function ruleOptionsMapperFactory(ruleOptions: Array<mixed> = [])
       code,
       errors,
       // Flatten the array of objects in an array of one object.
-      options: [fromEntries((options || []).concat(ruleOptions).flatMap((item) => entries(item)))],
+      options: [fromEntries((options || []).concat(ruleOptions).flatMap((item) => entries(item as any)))],
       parserOptions,
       settings,
     };

package.json

@@ -56,7 +56,7 @@
     "eslint-plugin-flowtype": "^5.8.0 || ^8.0.3",
     "eslint-plugin-import": "^2.31.0",
     "estraverse": "^5.3.0",
-    "flow-bin": "^0.147.0",
+    "flow-bin": "^0.250.0",
     "in-publish": "^2.0.1",
     "jackspeak": "=2.1.1",
     "jscodeshift": "^17.0.0",

src/rules/anchor-ambiguous-text.js

@@ -7,8 +7,7 @@
 // ----------------------------------------------------------------------------
 // Rule Definition
 // ----------------------------------------------------------------------------
-
-import type { ESLintConfig, ESLintContext } from '../../flow/eslint';
+import type { ESLintConfig, ESLintContext } from "../../flow/eslint";
 import { arraySchema, generateObjSchema } from '../util/schemas';
 import getAccessibleChildText from '../util/getAccessibleChildText';
 import getElementType from '../util/getElementType';
@@ -44,7 +43,7 @@ export default ({
     const ambiguousWords = new Set(words);
 
     return {
-      JSXOpeningElement: (node) => {
+      JSXOpeningElement: (node: any) => {
         const nodeType = elementType(node);
 
         // Only check anchor elements and custom types.
@@ -64,7 +63,7 @@ export default ({
           data: {
             wordsList: words.join('", "'),
           },
-        });
+        } as any);
       },
     };
   },

src/rules/anchor-is-valid.js

@@ -60,7 +60,7 @@ export default ({
 
         // Create active aspect flag object. Failing checks will only report
         // if the related flag is set to true.
-        const activeAspects = {};
+        const activeAspects: Object = {};
         allAspects.forEach((aspect) => {
           activeAspects[aspect] = aspects.indexOf(aspect) !== -1;
         });

src/rules/control-has-associated-label.js

@@ -12,7 +12,11 @@
 import { getProp, getLiteralPropValue } from 'jsx-ast-utils';
 import type { JSXElement } from 'ast-types-flow';
 import { generateObjSchema, arraySchema } from '../util/schemas';
-import type { ESLintConfig, ESLintContext, ESLintVisitorSelectorConfig } from '../../flow/eslint';
+import type {
+  ESLintConfig,
+  ESLintContext,
+  ESLintVisitorSelectorConfig,
+} from "../../flow/eslint";
 import getElementType from '../util/getElementType';
 import isDOMElement from '../util/isDOMElement';
 import isHiddenFromScreenReader from '../util/isHiddenFromScreenReader';

src/rules/label-has-associated-control.js

@@ -36,7 +36,7 @@ const schema = generateObjSchema({
   },
 });
 
-function validateID(node, context) {
+function validateID(node: Object, context: Object) {
   const { settings } = context;
   const htmlForAttributes = settings['jsx-a11y']?.attributes?.for ?? ['htmlFor'];
 

src/rules/media-has-caption.js

@@ -25,14 +25,14 @@ const schema = generateObjSchema({
   track: arraySchema,
 });
 
-const isMediaType = (context, type) => {
+const isMediaType = (context: Object, type: string) => {
   const options = context.options[0] || {};
   return MEDIA_TYPES
     .concat(MEDIA_TYPES.flatMap((mediaType) => options[mediaType]))
     .some((typeToCheck) => typeToCheck === type);
 };
 
-const isTrackType = (context, type) => {
+const isTrackType = (context: Object, type: string) => {
   const options = context.options[0] || {};
   return ['track'].concat(options.track || []).some((typeToCheck) => typeToCheck === type);
 };

src/rules/mouse-events-have-key-events.js

@@ -40,7 +40,7 @@ export default ({
   },
 
   create: (context: ESLintContext) => ({
-    JSXOpeningElement: (node) => {
+    JSXOpeningElement: (node: Object) => {
       const { name } = node.name;
 
       if (!dom.get(name)) {

src/rules/no-redundant-roles.js

@@ -17,7 +17,7 @@ import getImplicitRole from '../util/getImplicitRole';
 
 const { hasOwn } = Object;
 
-const errorMessage = (element, implicitRole) => (
+const errorMessage = (element: string, implicitRole: string) => (
   `The element ${element} has an implicit role of ${implicitRole}. Defining this explicitly is redundant and should be avoided.`
 );
 
@@ -46,7 +46,7 @@ export default ({
     const elementType = getElementType(context);
     return {
       JSXOpeningElement: (node: JSXOpeningElement) => {
-        const type = elementType(node);
+        const type: any = elementType(node);
         const implicitRole = getImplicitRole(type, node.attributes);
         const explicitRole = getExplicitRole(type, node.attributes);