focus-group
Create a group of nodes with special focus-related powers.
Specifically, you can do the following with your focus group:
- Use different keybindings to move focus through the nodes
- Type (with letters) to jump focus to a specific node based on its text
Essentially, it mimics some of the essential keyboard interactions of a native <select>
.
These kinds of powers are useful for:
- Accessible menus, like react-aria-menubutton
- Any other widgets whose keyboard UX will improve by enabling arrow-key navigation and letter-key jumping
Concepts
A focus-group is composed of members.
The order of the members matters, because focus moves forwards and backwards through the group, in order.
Each member consists of a DOM node and some text associated with that node. The member's text will be used for letter-key jumping (a.k.a. string searching). Each member's text can be established in a few ways:
- It can be manually specified when adding the member to the group, via
setMembers()
oraddMember()
(see below). - If the member's node has a
data-focus-group-text
attribute, that value will serve as the member's text. - If neither of the above is provided, the member's text will be the
textContent
of its node.
Keyboard Interactions
When focus is inside the focus-group, the following things should happen:
- If you press one of your
next
keybindings
(the down arrow by default), focus moves from the currently focused member to the next member in the group (or wraps back to the front, according to thewrap
option). - If you press one of your
prev
keybindings
(the up arrow by default), focus moves from the currently focused member to the previous member in the group (or wraps around to the back, according to thewrap
option). - If you press a letter key, string searching begins (see below!).
String searching
If the option stringSearch
is true
and focus is within the group, the following things happen:
- When you start typing, focus moves to the first member whose registered text begins with whatever you've been typing.
- As long as each keystroke occurs within
stringSearchDelay
, the search string will extend (e.g.f
->fa
->far
->farm
) and focus will move accordingly. - If no text matches the search string, focus will not move.
- After you have not typed any letters for
stringSearchDelay
, the search string resets and you can start over (e.g. you typefa
then wait and typego
to matchgorge
).
This all mimics the native <select>
behavior.
Note that like the native <select>
, typing only matches the beginning of words. So you can't focus David Clark
by typing Clark
.
API
var focusGroup = createFocusGroup([options])
This is the function you get when you require()
or import
the module.
var createFocusGroup = ;var myMegaMenuFocusGroup = ;
Options
members { Array }: Designate initial members of the group. Can be any of the following:
- An array of DOM nodes (or a NodeList, like what's returned by
querySelectorAll()
) - An array of member objects, each object with the following properties:
node
(the DOM node), and (optionally)text
(the text that should be associated with that node for letter-navigation)
You can omit this option and add members later with addMember()
or setMembers()
. Default: []
.
keybindings { Object of 'next'
, 'prev'
, 'first'
, or 'last'
}:
Specify which key events should move the focus forward, back, to the first member, or to the last member through the group. Provide objects (or arrays of objects) that describe the requirements of a KeyboardEvent that should trigger that keybinding. Undesignated modifier keys are false by default. So when using something like { keyCode: 38 }
, that keybinding will be ignored if key 38 is combined with meta, ctrl, or alt.
Default:
next: keyCode: 40 // ArrowDownprev: keyCode: 38 // ArrowUp
Use arrays of objects for multiple key bindings:
next: key: 'ArrowDown' key: 'ArrowRight'prev: key: 'ArrowUp' key: 'ArrowLeft'
Even add modifiers or any valid event properties:
first: keyCode: 74 metaKey: truelast: keyCode: 75 metaKey: true
wrap { Boolean }:
If true
, when the arrow keys are moving focus they will wrap around the group. That is, when focus is on the last item and you move focus forward, the first item will focus; and when focus is on the first item and you move focus back, the last item will focus.
stringSearch { Boolean }:
If true
, string searching is enabled (see below).
Default: false
.
stringSearchDelay { Number }:
The number of milliseconds that should elapse between the user's last letter entry (with the keyboard)
and a refresh of the string search (see below).
Default: 800
.
focusGroup.activate()
Start this group listening to keyboard events and responding accordingly.
Returns the focus group instance.
focusGroup.deactivate()
Stop this group listening to keyboard events.
Returns the focus group instance.
focusGroup.addMember(member[, index])
Add a member to the group.
member
can be any of the following:
- A DOM node
- An object with the following properties:
node
(the node itself)- (optionally)
text
: Text that should be associated with that node for letter-navigation. If none is provided, focus-group will check for adata-focus-group-text
attribute or fallback to the node'stextContent.
If index
is provided, the member will be added at that index.
Otherwise, it will be added to the end of the group.
Returns the focus group instance.
focusGroup.removeMember(member)
Remove a member from the group.
member
can be any of the following:
- A DOM node
- An index for the member that should be removed.
Returns the focus group instance.
focusGroup.clearMembers()
Empty the focus group of members.
Returns the focus group instance.
focusGroup.setMembers(members)
Set the focus group's members (clearing any that already exist).
members
can be any of the following:
- An array of DOM nodes (or a NodeList, like what's returned by
querySelectorAll()
) - An array of member objects, each object with the following properties:
node
(the node itself)- (optionally)
text
: Text that should be associated with that node for letter-navigation. If none is provided, focus-group will check for adata-focus-group-text
attribute or fallback to the node's `textContent.
Returns the focus group instance.
focusGroup.getMembers()
Returns the focus group's current array of members.
Each item in the array is an object with node
and text
properties.
focusGroup.focusNodeAtIndex(index)
Focuses the node at a particular index in the focus group's member array.
If no member exists at that index, does nothing.
Returns the focus group instance.
focusGroup.moveFocusForward()
Moves the focus forward one member, if focus is already within the group.
If focus is not within the group, does nothing.
Returns the index of the newly focused member.
focusGroup.moveFocusBack()
Moves the focus back one member, if focus is already within the group.
If focus is not within the group, does nothing.
Returns the index of the newly focused member.
Contributing
Please note that this project is released with a Contributor Code of Conduct. By participating in this project you agree to abide by its terms.