baseui 10.10.0 → 10.11.0

package/select/types.js.flow

@@ -8,13 +8,14 @@ LICENSE file in the root directory of this source tree.
 
 import * as React from 'react';
 
-import type {OverrideT} from '../helpers/overrides.js';
-import {STATE_CHANGE_TYPE, SIZE, TYPE} from './constants.js';
-import type {OnItemSelectFnT} from '../menu/types.js';
+import type { OverrideT } from '../helpers/overrides.js';
+import { STATE_CHANGE_TYPE, SIZE, TYPE } from './constants.js';
+import type { OnItemSelectFnT } from '../menu/types.js';
 
 export type ChangeActionT = $Keys<typeof STATE_CHANGE_TYPE>;
 export type SizeT = $Keys<typeof SIZE>;
 export type TypeT = $Keys<typeof TYPE>;
+export type ReactRefT<T> = {| current: null | T |};
 
 export type OptionT = $ReadOnly<{
   id?: string | number,
@@ -23,12 +24,12 @@ export type OptionT = $ReadOnly<{
   clearableValue?: boolean,
   isCreatable?: boolean,
   __optgroup?: string,
-  // eslint-disable-next-line flowtype/no-weak-types
+  // flowlint-next-line unclear-type:off
   [string]: any,
 }>;
 
 export type ValueT = $ReadOnlyArray<OptionT>;
-export type OptgroupsT = {__ungrouped: ValueT, [string]: ValueT};
+export type OptgroupsT = { __ungrouped: ValueT, [string]: ValueT };
 export type OptionsT = ?ValueT | OptgroupsT;
 
 export type OnChangeParamsT = {
@@ -73,7 +74,7 @@ export type OverridesDropdownT = {
 };
 
 type ImperativeFnsT = {|
-  setDropdownOpen: boolean => mixed,
+  setDropdownOpen: (boolean) => mixed,
 |};
 export type MethodsRefT = {
   current: ImperativeFnsT | null,
@@ -112,7 +113,7 @@ export type PropsT = {
     options: ValueT,
     filterValue: string,
     excludeOptions: ?ValueT,
-    {valueKey: string, labelKey: string},
+    { valueKey: string, labelKey: string }
   ) => ValueT,
   /** Defines if currently selected options are filtered out in the dropdown options. */
   filterOutSelected: boolean,
@@ -126,13 +127,13 @@ export type PropsT = {
     },
   }) => React.Node,
   /** A custom method to get a display value for a selected option. */
-  getValueLabel: ?({option: OptionT}) => React.Node,
+  getValueLabel: ?({ option: OptionT }) => React.Node,
   /** Sets the id attribute of the internal input element. Allows for usage with labels. */
   id?: string,
   /** Defines if the comparison for a new creatable value should be case-insensitive. */
   ignoreCase?: boolean,
   /** A ref to access the input element powering the select if it's a search select, or the container div if it isn't. */
-  controlRef?: React.ElementRef<*>,
+  controlRef?: ReactRefT<HTMLElement>,
   /** Defines if the select is in a loading (async) state. */
   isLoading: boolean,
   /** Defines an option key for a default label value. */
@@ -183,7 +184,7 @@ export type PropsT = {
   /** A current selected value(s). If a selected value has a clearableValue
    * prop set to true it will be rendered as a disabled selected option that can't be cleared. */
   value: ValueT,
-  // eslint-disable-next-line flowtype/no-weak-types
+  // flowlint-next-line unclear-type:off
   valueComponent?: React.ComponentType<any>,
   /** Defines a key name for an option's unique identifier value.
    * The value of the `valueKey` prop is used to identify what options are selected
@@ -206,15 +207,11 @@ export type StateT = {
   value: ValueT,
 };
 
-export type StateReducerT = (
-  stateType: string,
-  nextState: StateT,
-  currentState: StateT,
-) => StateT;
+export type StateReducerT = (stateType: string, nextState: StateT, currentState: StateT) => StateT;
 
 export type StatefulContainerPropsT = {
   overrides: OverridesT,
-  children: PropsT => React$Node,
+  children: (PropsT) => React$Node,
   initialState: StateT,
   stateReducer: StateReducerT,
   onChange: (params: OnChangeParamsT) => mixed,
@@ -238,7 +235,7 @@ export type DropdownPropsT = {
     },
   }) => React.Node,
   id?: string,
-  innerRef: React.ElementRef<*>,
+  innerRef: ReactRefT<HTMLElement>,
   isLoading: boolean,
   labelKey: string,
   maxDropdownHeight: string,
@@ -255,7 +252,7 @@ export type DropdownPropsT = {
   value: ValueT,
   valueKey: string,
   width: ?number,
-  keyboardControlNode?: React.ElementRef<*>,
+  keyboardControlNode?: ReactRefT<HTMLElement>,
 };
 
 export type AutosizeInputOverridesT = {

package/select/utils/default-filter-options.js.flow

@@ -5,11 +5,11 @@ This source code is licensed under the MIT license found in the
 LICENSE file in the root directory of this source tree.
 */
 // @flow
-import type {OptionT, ValueT} from '../types.js';
+import type { OptionT, ValueT } from '../types.js';
 
-const escapeRegExp = str => str.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+const escapeRegExp = (str) => str.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
 
-const isValid = value => {
+const isValid = (value) => {
   return typeof value !== 'undefined' && value !== null && value !== '';
 };
 
@@ -37,7 +37,7 @@ const filterOptions = (
   options: ValueT,
   filterValue: string,
   excludeOptions: ?ValueT,
-  newProps: ?$Shape<defaultPropsT>,
+  newProps: ?$Shape<defaultPropsT>
 ) => {
   const props = {
     ...defaultProps,
@@ -59,14 +59,13 @@ const filterOptions = (
 
   const re = new RegExp(
     `${props.matchPos === 'start' ? '$' : ''}${escapeRegExp(filterValue)}`,
-    props.ignoreCase ? 'i' : '',
+    props.ignoreCase ? 'i' : ''
   );
 
   // $FlowFixMe
-  return options.filter(option => {
+  return options.filter((option) => {
     if (excludeValues.has(option[props.valueKey])) return false;
-    if (props.filterOption)
-      return props.filterOption.call(undefined, option, filterValue);
+    if (props.filterOption) return props.filterOption.call(undefined, option, filterValue);
     if (!filterValue) return true;
 
     const value = option[props.valueKey];

package/select/utils/index.js.flow

@@ -5,18 +5,18 @@ This source code is licensed under the MIT license found in the
 LICENSE file in the root directory of this source tree.
 */
 // @flow
-import type {PropsT, OptionT, OptionsT, OptgroupsT, ValueT} from '../types.js';
+import type { PropsT, OptionT, OptionsT, OptgroupsT, ValueT } from '../types.js';
 
 function groupedOptionsToArray(groupedOptions: OptgroupsT): ValueT {
   return Object.keys(groupedOptions).reduce((arr, optgroup) => {
     const optgroupOptions = groupedOptions[optgroup];
     return arr.concat(
-      optgroupOptions.map(option => {
+      optgroupOptions.map((option) => {
         return {
           ...option,
           __optgroup: optgroup,
         };
-      }),
+      })
     );
   }, []);
 }
@@ -33,19 +33,12 @@ export function normalizeOptions(options: OptionsT): ValueT {
   return [];
 }
 
-export const expandValue = (
-  // eslint-disable-next-line flowtype/no-weak-types
-  value: OptionT,
-  props: $Shape<PropsT>,
-): OptionT => {
+export const expandValue = (value: OptionT, props: $Shape<PropsT>): OptionT => {
   if (!props.options) return value;
 
   const normalizedOptions = normalizeOptions(props.options);
   for (let i = 0; i < normalizedOptions.length; i++) {
-    if (
-      String(normalizedOptions[i][props.valueKey]) ===
-      String(value[props.valueKey])
-    ) {
+    if (String(normalizedOptions[i][props.valueKey]) === String(value[props.valueKey])) {
       return normalizedOptions[i];
     }
   }

package/select/value.js

@@ -35,7 +35,7 @@ function _objectWithoutProperties(source, excluded) { if (source == null) return
 
 function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; }
 
-// eslint-disable-next-line flowtype/no-weak-types
+// flowlint-next-line unclear-type:off
 function Value(props) {
   var _props$overrides = props.overrides,
       overrides = _props$overrides === void 0 ? {} : _props$overrides,

package/select/value.js.flow

@@ -6,16 +6,13 @@ LICENSE file in the root directory of this source tree.
 */
 // @flow
 import * as React from 'react';
-import {StyledSingleValue} from './styled-components.js';
-import {getOverrides} from '../helpers/overrides.js';
+import { StyledSingleValue } from './styled-components.js';
+import { getOverrides } from '../helpers/overrides.js';
 
-// eslint-disable-next-line flowtype/no-weak-types
+// flowlint-next-line unclear-type:off
 export default function Value(props: any) {
-  const {overrides = {}, ...restProps} = props;
-  const [SingleValue, singleValueProps] = getOverrides(
-    overrides.SingleValue,
-    StyledSingleValue,
-  );
+  const { overrides = {}, ...restProps } = props;
+  const [SingleValue, singleValueProps] = getOverrides(overrides.SingleValue, StyledSingleValue);
   return (
     <SingleValue aria-selected="true" {...restProps} {...singleValueProps}>
       {props.children}

package/side-navigation/index.js.flow

@@ -5,8 +5,8 @@ This source code is licensed under the MIT license found in the
 LICENSE file in the root directory of this source tree.
 */
 // @flow
-export {default as Navigation} from './nav.js';
-export {default as NavItem} from './nav-item.js';
+export { default as Navigation } from './nav.js';
+export { default as NavItem } from './nav-item.js';
 // Styled elements
 export * from './styled-components.js';
 // Types

package/side-navigation/nav-item.js.flow

@@ -7,9 +7,9 @@ LICENSE file in the root directory of this source tree.
 // @flow
 
 import * as React from 'react';
-import {getOverrides} from '../helpers/overrides.js';
-import {StyledNavLink, StyledNavItem} from './styled-components.js';
-import type {NavItemPropsT} from './types.js';
+import { getOverrides } from '../helpers/overrides.js';
+import { StyledNavLink, StyledNavItem } from './styled-components.js';
+import type { NavItemPropsT } from './types.js';
 
 class NavItem extends React.Component<NavItemPropsT> {
   static defaultProps = {
@@ -18,28 +18,23 @@ class NavItem extends React.Component<NavItemPropsT> {
   };
 
   handleClick = (event: Event) => {
-    const {item, onSelect} = this.props;
+    const { item, onSelect } = this.props;
     if (typeof onSelect === 'function') {
-      onSelect({item, event});
+      onSelect({ item, event });
     }
   };
 
   handleKeyDown = (event: KeyboardEvent) => {
-    const {item, onSelect} = this.props;
+    const { item, onSelect } = this.props;
     if (event.key === 'Enter') {
       if (typeof onSelect === 'function') {
-        onSelect({item, event});
+        onSelect({ item, event });
       }
     }
   };
 
   render() {
-    const {
-      item,
-      overrides,
-      itemMemoizationComparator,
-      ...sharedProps
-    } = this.props;
+    const { item, overrides, itemMemoizationComparator, ...sharedProps } = this.props;
 
     const [NavItem, itemProps] = getOverrides(overrides.NavItem, StyledNavItem);
     const [NavLink, linkProps] = getOverrides(overrides.NavLink, StyledNavLink);

package/side-navigation/nav.js.flow

@@ -7,20 +7,13 @@ LICENSE file in the root directory of this source tree.
 // @flow
 
 import * as React from 'react';
-import {getOverrides} from '../helpers/overrides.js';
+import { getOverrides } from '../helpers/overrides.js';
 import NavItem from './nav-item.js';
-import {
-  StyledRoot,
-  StyledNavItemContainer,
-  StyledSubNavContainer,
-} from './styled-components.js';
-import type {NavPropsT, Item} from './types.js';
-import {isFocusVisible, forkFocus, forkBlur} from '../utils/focusVisible.js';
+import { StyledRoot, StyledNavItemContainer, StyledSubNavContainer } from './styled-components.js';
+import type { NavPropsT, Item } from './types.js';
+import { isFocusVisible, forkFocus, forkBlur } from '../utils/focusVisible.js';
 
-export default class SideNav extends React.Component<
-  NavPropsT,
-  {isFocusVisible: boolean},
-> {
+export default class SideNav extends React.Component<NavPropsT, { isFocusVisible: boolean }> {
   static defaultProps = {
     activeItemId: '/',
     activePredicate: null,
@@ -28,59 +21,50 @@ export default class SideNav extends React.Component<
     overrides: {},
     mapItem: null,
   };
-  state = {isFocusVisible: false};
+  state = { isFocusVisible: false };
 
   handleFocus = (event: SyntheticEvent<>) => {
     if (isFocusVisible(event)) {
-      this.setState({isFocusVisible: true});
+      this.setState({ isFocusVisible: true });
     }
   };
 
   handleBlur = (event: SyntheticEvent<>) => {
     if (this.state.isFocusVisible !== false) {
-      this.setState({isFocusVisible: false});
+      this.setState({ isFocusVisible: false });
     }
   };
 
   activePredicate = (item: Item) => item.itemId === this.props.activeItemId;
 
   render() {
-    const {
-      activeItemId,
-      activePredicate,
-      items,
-      onChange,
-      overrides,
-      mapItem,
-    } = this.props;
+    const { activeItemId, activePredicate, items, onChange, overrides, mapItem } = this.props;
     const navLevel = 1;
 
     const [Root, rootProps] = getOverrides(overrides.Root, StyledRoot);
     const [NavItemContainer, itemContainerProps] = getOverrides(
       overrides.NavItemContainer,
-      StyledNavItemContainer,
+      StyledNavItemContainer
     );
     const [SubNavContainer, subNavContainerProps] = getOverrides(
       overrides.SubNavContainer,
-      StyledSubNavContainer,
+      StyledSubNavContainer
     );
 
     const renderNavItem = (item: Item, level: number, index, mapItem) => {
       if (typeof mapItem === 'function') {
-        const recMapItem = item => {
+        const recMapItem = (item) => {
           let subNav = [];
           if (item.subNav) {
             subNav = item.subNav.map(recMapItem);
           }
-          return mapItem({...item, subNav});
+          return mapItem({ ...item, subNav });
         };
         item = recMapItem(item);
       }
 
       const sharedProps = {
-        $active: activePredicate
-          ? activePredicate(item, activeItemId)
-          : this.activePredicate(item),
+        $active: activePredicate ? activePredicate(item, activeItemId) : this.activePredicate(item),
         $level: level,
         $selectable: !!item.itemId,
         $disabled: item.disabled || false,
@@ -106,11 +90,7 @@ export default class SideNav extends React.Component<
               {...sharedProps}
             />
             {item.subNav ? (
-              <SubNavContainer
-                role="list"
-                {...sharedProps}
-                {...subNavContainerProps}
-              >
+              <SubNavContainer role="list" {...sharedProps} {...subNavContainerProps}>
                 {item.subNav.map((subitem, idx) => {
                   return renderNavItem(subitem, level + 1, index);
                 })}

package/side-navigation/stateful-container.js.flow

@@ -6,21 +6,12 @@ LICENSE file in the root directory of this source tree.
 */
 // @flow
 import * as React from 'react';
-import {STATE_CHANGE_TYPE} from './constants.js';
-import type {
-  StatefulContainerPropsT,
-  StateT,
-  StateReducerT,
-  StateTypeT,
-  Item,
-} from './types.js';
+import { STATE_CHANGE_TYPE } from './constants.js';
+import type { StatefulContainerPropsT, StateT, StateReducerT, StateTypeT, Item } from './types.js';
 
 const defaultStateReducer: StateReducerT = (type, nextState) => nextState;
 
-class StatefulContainer extends React.Component<
-  StatefulContainerPropsT,
-  StateT,
-> {
+class StatefulContainer extends React.Component<StatefulContainerPropsT, StateT> {
   static defaultProps = {
     initialState: {},
     stateReducer: defaultStateReducer,
@@ -32,18 +23,18 @@ class StatefulContainer extends React.Component<
     ...this.props.initialState,
   };
 
-  onChange = (params: {item: Item, event: Event | KeyboardEvent}) => {
-    const {onChange} = this.props;
+  onChange = (params: { item: Item, event: Event | KeyboardEvent }) => {
+    const { onChange } = this.props;
     this.internalSetState(STATE_CHANGE_TYPE.change, params.item);
     if (typeof onChange === 'function') {
       onChange(params);
     }
   };
-
-  internalSetState = (type: StateTypeT, item: *) => {
+  // flowlint-next-line unclear-type:off
+  internalSetState = (type: StateTypeT, item: any) => {
     let nextState = {};
     if (type === STATE_CHANGE_TYPE.change) {
-      nextState = {activeItemId: item.itemId};
+      nextState = { activeItemId: item.itemId };
     }
     const newState = this.props.stateReducer
       ? this.props.stateReducer(type, nextState, this.state)
@@ -53,8 +44,8 @@ class StatefulContainer extends React.Component<
 
   render() {
     // eslint-disable-next-line no-unused-vars
-    const {children, initialState, stateReducer, ...restProps} = this.props;
-    const {onChange} = this;
+    const { children, initialState, stateReducer, ...restProps } = this.props;
+    const { onChange } = this;
     // $FlowFixMe
     return children({
       ...restProps,

package/side-navigation/stateful-nav.js.flow

@@ -8,12 +8,12 @@ LICENSE file in the root directory of this source tree.
 import * as React from 'react';
 import StatefulContainer from './stateful-container.js';
 import Navigation from './nav.js';
-import type {StatefulNavPropsT} from './types.js';
+import type { StatefulNavPropsT } from './types.js';
 
 export default function StatefulNavigation(props: StatefulNavPropsT) {
   return (
     <StatefulContainer {...props}>
-      {childrenProps => <Navigation {...childrenProps} />}
+      {(childrenProps) => <Navigation {...childrenProps} />}
     </StatefulContainer>
   );
 }

package/side-navigation/styled-components.js.flow

@@ -6,12 +6,12 @@ LICENSE file in the root directory of this source tree.
 */
 // @flow
 import * as React from 'react';
-import {styled, hexToRgb, withWrapper} from '../styles/index.js';
-import type {SharedPropsT} from './types.js';
+import { styled, hexToRgb, withWrapper } from '../styles/index.js';
+import type { SharedPropsT } from './types.js';
 
-export const StyledRoot = styled<SharedPropsT>('nav', props => {
+export const StyledRoot = styled<SharedPropsT>('nav', (props) => {
   const {
-    $theme: {colors, typography},
+    $theme: { colors, typography },
   } = props;
   return {
     ...typography.font300,
@@ -30,9 +30,9 @@ export const StyledRoot = styled<SharedPropsT>('nav', props => {
 
 export const StyledNavItemContainer = styled('li', {});
 
-export const StyledNavLink = styled<{$isFocusVisible: boolean}>(
+export const StyledNavLink = styled<{ $isFocusVisible: boolean }>(
   'a',
-  ({$theme, $isFocusVisible}) => ({
+  ({ $theme, $isFocusVisible }) => ({
     color: 'inherit',
     outline: 'none',
     textDecoration: 'none',
@@ -45,18 +45,18 @@ export const StyledNavLink = styled<{$isFocusVisible: boolean}>(
           borderRightColor: 'transparent',
           borderBottomColor: 'transparent',
         }
-      : {outline: 'none'},
-  }),
+      : { outline: 'none' },
+  })
 );
 
-export const StyledNavItemElement = styled<SharedPropsT>('div', props => {
+export const StyledNavItemElement = styled<SharedPropsT>('div', (props) => {
   const {
     $active,
     $selectable,
     $level,
     $disabled,
     $theme,
-    $theme: {colors, sizing},
+    $theme: { colors, sizing },
   } = props;
   const bgImgGradient = hexToRgb(colors.backgroundPrimary, '0.92') || '';
   const borderWidthDir: string =
@@ -65,10 +65,8 @@ export const StyledNavItemElement = styled<SharedPropsT>('div', props => {
     $theme.direction === 'rtl' ? 'borderRightStyle' : 'borderLeftStyle';
   const borderColorDir: string =
     $theme.direction === 'rtl' ? 'borderRightColor' : 'borderLeftColor';
-  const paddingPrefixDir: string =
-    $theme.direction === 'rtl' ? 'paddingRight' : 'paddingLeft';
-  const paddingSuffixDir: string =
-    $theme.direction === 'rtl' ? 'paddingLeft' : 'paddingRight';
+  const paddingPrefixDir: string = $theme.direction === 'rtl' ? 'paddingRight' : 'paddingLeft';
+  const paddingSuffixDir: string = $theme.direction === 'rtl' ? 'paddingLeft' : 'paddingRight';
 
   let cursor = $selectable ? 'pointer' : 'default';
   let color = $active ? colors.primary : null;
@@ -82,9 +80,7 @@ export const StyledNavItemElement = styled<SharedPropsT>('div', props => {
 
   return ({
     backgroundColor: $active ? colors.backgroundInversePrimary : 'transparent',
-    backgroundImage: $active
-      ? `linear-gradient(0deg, ${bgImgGradient}, ${bgImgGradient})`
-      : null,
+    backgroundImage: $active ? `linear-gradient(0deg, ${bgImgGradient}, ${bgImgGradient})` : null,
     boxSizing: 'border-box',
     [borderWidthDir]: '4px',
     [borderStyleDir]: 'solid',
@@ -107,10 +103,10 @@ export const StyledNavItemElement = styled<SharedPropsT>('div', props => {
 
 export const StyledNavItem = withWrapper(
   StyledNavItemElement,
-  Styled =>
-    function StyledNav({item, ...restProps}) {
+  (Styled) =>
+    function StyledNav({ item, ...restProps }) {
       return <Styled {...restProps} />;
-    },
+    }
 );
 
 export const StyledSubNavContainer = styled('ul', {

package/side-navigation/types.js.flow

@@ -6,8 +6,8 @@ LICENSE file in the root directory of this source tree.
 */
 // @flow
 import * as React from 'react';
-import type {OverrideT} from '../helpers/overrides.js';
-import {STATE_CHANGE_TYPE} from './constants.js';
+import type { OverrideT } from '../helpers/overrides.js';
+import { STATE_CHANGE_TYPE } from './constants.js';
 
 const stateChangeType = Object.freeze(STATE_CHANGE_TYPE);
 export type StateTypeT = $Values<typeof stateChangeType>;
@@ -19,7 +19,7 @@ export type StateT = {
 export type StateReducerT = (
   stateType: StateTypeT,
   nextState: StateT,
-  currentState: StateT,
+  currentState: StateT
 ) => StateT;
 
 export type SharedPropsT = {
@@ -40,7 +40,7 @@ export type NavPropsT = {
     Is called on the nav item render to test if the item is currently selected.
     If returns true the item will be rendered as an active one
     */
-  activePredicate: ?(item: *, activeItemId: string) => boolean,
+  activePredicate: ?(item: Item, activeItemId: string) => boolean,
   /** List of navigation items */
   items: Item[],
   /** Used as a performance optimization if many nav items are rendered. Function provided to
@@ -48,7 +48,7 @@ export type NavPropsT = {
    */
   itemMemoizationComparator?: (NavItemPropsT, NavItemPropsT) => boolean,
   /** onChange handler that is called when a nav item is selected */
-  onChange?: ({item: *, event: Event | KeyboardEvent}) => mixed,
+  onChange?: ({ item: Item, event: Event | KeyboardEvent }) => mixed,
   /** Overrides for the internal elements and components */
   overrides: {
     Root?: OverrideT,
@@ -83,7 +83,7 @@ export type NavItemPropsT = SharedPropsT & {
    *  NavItem component's React.memo call.
    */
   itemMemoizationComparator?: (NavItemPropsT, NavItemPropsT) => boolean,
-  onSelect?: ({item: *, event: Event | KeyboardEvent}) => mixed,
+  onSelect?: ({ item: Item, event: Event | KeyboardEvent }) => mixed,
   overrides: {
     NavLink?: OverrideT,
     NavItem?: OverrideT,
@@ -91,16 +91,16 @@ export type NavItemPropsT = SharedPropsT & {
 };
 
 export type StatefulContainerPropsT = {
-  children: NavPropsT => React.Node,
+  children: (NavPropsT) => React.Node,
   /** Initial state of an uncontrolled component. */
   initialState?: StateT,
   /** A state change handler. Used to override default state transitions. */
   stateReducer?: StateReducerT,
-  onChange?: ({item: *, event: Event | KeyboardEvent}) => mixed,
+  onChange?: ({ item: Item, event: Event | KeyboardEvent }) => mixed,
 };
 
 type ExcludeT = {
-  children: NavPropsT => React.Node,
+  children: (NavPropsT) => React.Node,
 };
 
 export type StatefulNavPropsT = $Diff<StatefulContainerPropsT, ExcludeT>;

package/skeleton/index.js.flow

@@ -5,7 +5,7 @@ This source code is licensed under the MIT license found in the
 LICENSE file in the root directory of this source tree.
 */
 // @flow
-export {default as Skeleton} from './skeleton.js';
+export { default as Skeleton } from './skeleton.js';
 
 declare var __DEV__: boolean;
 declare var __NODE__: boolean;

package/skeleton/skeleton.js.flow

@@ -6,9 +6,9 @@ LICENSE file in the root directory of this source tree.
 */
 // @flow
 import * as React from 'react';
-import {getOverrides} from '../helpers/overrides.js';
-import type {SkeletonPropsT} from './types.js';
-import {StyledRoot, StyledRow} from './styled-components.js';
+import { getOverrides } from '../helpers/overrides.js';
+import type { SkeletonPropsT } from './types.js';
+import { StyledRoot, StyledRow } from './styled-components.js';
 
 class Skeleton extends React.Component<SkeletonPropsT> {
   static defaultProps: SkeletonPropsT = {
@@ -16,7 +16,7 @@ class Skeleton extends React.Component<SkeletonPropsT> {
     animation: false,
   };
   render() {
-    const {overrides = {}} = this.props;
+    const { overrides = {} } = this.props;
     const [Root, rootProps] = getOverrides(overrides.Root, StyledRoot);
     const [Row, rowProps] = getOverrides(overrides.Row, StyledRow);