maybe give an example for what value might be for each case. e.g. for onHover the value means hovered

Added some more docs! :)

Value seems a bit weird in this context. May be TabStateChanged

If this can only happen for one tab at a time should we change the function signature to just an index?

typedef TabChanged = ValueChanged<int?>;

This may be cleaning when, lets say changing the focus, you will only call this method once with the current affected index, instead of twice: one with true the other with false

If this can only happen for one tab at a time should we change the function signature to just an index?

Good question! It can happen for multiple tabs at once, like in the test cases here. If focus/hover moves directly from one tab to another, they both receive callbacks for the events of entering and exiting those states.

Value seems a bit weird in this context. May be TabStateChanged

I want to stick with value since it is consistently used for focus and hover callbacks across the framework. This is really similar to the ValueChanged callback that they all use: https://api.flutter.dev/flutter/foundation/ValueChanged.html

they both receive callbacks for the events of entering and exiting those states.

I was suggesting the callback can just have the current hovered/focused tab as input.

I imaging the use case is to change styling of Tab of hovered/focused tab. The current callback will be called twice when the focused tab change for example. It is unclear to me at which callback they should modify their Tabs.

My suggestion is to just call the callback with the current focused tab one time since the developer mostly likely only want to know which one is currently focused

bassically instead of

int? currentFocusedIndex;

onFocused: (bool state, int index) {
  if (!state) {
     if (currentFocusedIndex == index) {
        currentFocusedIndex = null;
     }
     return;
  }
  currentFocusedIndex = index
}

we should just provide api like this

int? currentFocusedIndex;

onFocused: (int? index) {
  currentFocusedIndex = index
}

The latter example does not account for focus being lost, or hover exiting. The developer wants to be able to respond to these states as well. Just passing the index does not supply the context of what the state is, and differs from current convention for these callbacks.

in case that no tab is hovered or focused, the callback will call with index equals to null, or -1 whichever we document on the callback.

Do we have existing convention for this kind of callback?

I don't think it would, if no tab is hovered or focused, no callback is not called. What would trigger the callback if no event has occurred?

Do we need to worry about cases where false is called after true?
for example switch from focus from tab 1-> tab2
whether tabs 1 false may be called after tab 2 true

If we don't we should probably document this on the api

Do we need to worry about cases where false is called after true?

I don't think so, I've tested it, I was curious about the same exact thing.

for focus it is probably fine.

for hover I looked at the code, onExit is called before onEnter

we should still document this on the api though

Ah gotcha! Added!