[flow] update flow so there are no errors

Author: talentlessguy

__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: 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: any))))],
       parserOptions,
       settings,
     };

flow/eslint.js

@@ -4,6 +4,7 @@
 export type ESLintReport = {
   node: any,
   message: string,
+  data?: any
 };
 
 export type ESLintSettings = {

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,7 +7,6 @@
 // ----------------------------------------------------------------------------
 // Rule Definition
 // ----------------------------------------------------------------------------
-
 import type { ESLintConfig, ESLintContext } from '../../flow/eslint';
 import { arraySchema, generateObjSchema } from '../util/schemas';
 import getAccessibleChildText from '../util/getAccessibleChildText';
@@ -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.

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);
 

src/util/getExplicitRole.js

@@ -15,7 +15,7 @@ export default function getExplicitRole(
   tag: string,
   attributes: Array<Node>,
 ): ?string {
-  const explicitRole = (function toLowerCase(role) {
+  const explicitRole = (function toLowerCase(role: any) {
     if (typeof role === 'string') {
       return role.toLowerCase();
     }

src/util/isInteractiveElement.js

@@ -57,8 +57,8 @@ const interactiveAXObjects = new Set(AXObjects.keys().filter((name) => AXObjects
 
 const interactiveElementAXObjectSchemas = [...elementAXObjects].flatMap(([elementSchema, AXObjectsArr]) => (AXObjectsArr.every((role): boolean => interactiveAXObjects.has(role)) ? [elementSchema] : []));
 
-function checkIsInteractiveElement(tagName, attributes): boolean {
-  function elementSchemaMatcher(elementSchema) {
+function checkIsInteractiveElement(tagName: string, attributes: Object): boolean {
+  function elementSchemaMatcher(elementSchema: Object) {
     return (
       tagName === elementSchema.name
       && attributesComparator(elementSchema.attributes, attributes)

src/util/isNonInteractiveElement.js

@@ -62,10 +62,10 @@ const nonInteractiveElementRoleSchemas = elementRoleEntries.flatMap(([elementSch
 
 const nonInteractiveAXObjects = new Set(AXObjects.keys().filter((name) => ['window', 'structure'].includes(AXObjects.get(name).type)));
 
-const nonInteractiveElementAXObjectSchemas = elementAXObjects.flatMap(([elementSchema, AXObjectsArr]) => (AXObjectsArr.every((role): boolean => nonInteractiveAXObjects.has(role)) ? [elementSchema] : []));
+const nonInteractiveElementAXObjectSchemas = [...elementAXObjects].flatMap(([elementSchema, AXObjectsArr]) => (AXObjectsArr.every((role): boolean => nonInteractiveAXObjects.has(role)) ? [elementSchema] : []));
 
-function checkIsNonInteractiveElement(tagName, attributes): boolean {
-  function elementSchemaMatcher(elementSchema) {
+function checkIsNonInteractiveElement(tagName: string, attributes: Object): boolean {
+  function elementSchemaMatcher(elementSchema: Object) {
     return (
       tagName === elementSchema.name
       && tagName !== 'td' // TODO: investigate why this is needed