Q:

How state of a react hook must update if it has Map?

I have multiple(more than 15) div tags as tiles. I need to emphasis each one if mouse hover on it. So each tag has onMouseEnter/Leave functions as bellow. 
<div
    key={key}
    onMouseEnter={onMouseEnter(key)}
    onMouseLeave={onMouseLeave(key)}
>
    ...
</div>

Also I put each tiles key in a Map data structure.
const onMouseEnter = key => {
    return function() {
        const newIsHover = new Map(isHover)
        newIsHover.set(key, true)
        setIsHover(newIsHover)
    }
}

const onMouseLeave = key => {
    return function() {
        const newIsHover = new Map(isHover)
        newIsHover.delete(key)
        setIsHover(newIsHover)
    }
}

Since component is hook it put its state in a useState.
const [isHover, setIsHover] = useState(new Map())

What is happening here:

Always I enter a tile: onMouseEnter function called and its key added to map (as expected)
When I leave a tile: always onMouseLeave called but sometimes key is removed (as expected) and tile turned back to its normal shape but sometimes it does not(problem is here, in this situation map updated at setIsHover in onMouseLeave but it does not changed in the component!).

I think map updated as expected but when I move on new tile it does not understand that yet. So it overwrite it with what it has.
PS: example added. Move between tiles with high speed!

A:

Like the class-based components, calls to update state are asynchronous and get queued up. Try using functional state updates to ensure these queued-up updates correctly update the previous state. This should fix race conditions between quick successive setIsHover calls with the same key. 
Notice if you move slowly enough between tiles they correctly highlight and unhighlight, but more quickly (like a swipe) and 2 or more can get stuck until you again slowly exit the tile.
const onMouseEnter = key => {
  return function() {
    setIsHover(prevIsHover => {
      const newIsHover = new Map(prevIsHover);
      newIsHover.set(key, true);
      return newIsHover;
    });
  }
}

const onMouseLeave = key => {
  return function() {
    setIsHover(prevIsHover => {
      const newIsHover = new Map(prevIsHover);
      newIsHover.delete(key);
      return newIsHover;
    });
  }
}

But I should note that this is a lot of leg work for simply applying some component styling, especially hovering. It could more simply be achieved using CSS.
tileStyles.css
.tile {
  background-color: lightgray;
  border: 3px solid black;
  height: 100px;
  line-height: 100px;
  margin: 10px;
  text-align: center;
  width: 100px;
}

.tile:hover {
  border-color: red;
}

tile.jsx
import React from "react";
import { withStyles } from "@material-ui/core";

import "./tileStyles.css";

const styles = {
  container: { display: "flex", width: "600px", flexWrap: "wrap" }
};

const Tiles = ({ classes: { container }, tiles }) => {
  return (
    <div className={container}>
      {tiles.map((tl, key) => {
        return (
          <div className="tile" key={key} name={key}>
            hi
          </div>
        );
      })}
    </div>
  );
};

export default withStyles(styles)(Tiles);

The normal and hovered styles are applied together (at the same time) and CSS/html will manage when it hovered or not. The component no longer requires event listeners and doesn't need to maintain internal state.

Explanation

what means "...calls to update state are asynchronous and get queued up."?

When you call this.setState or a useState update function the update doesn't happen synchronously right then and there, but they are queued up during the current render cycle and batch processed in the order in which they were queued. Perhaps this demo will help illustrate what happens. What confounds this issue is the fact that event processing is also asynchronous, meaning that, when events occur their registered callbacks are placed in the event queue to be processed.

