Better keyboard navigation with progressive enhancement Monday, August 15th, 2016 at 10:45 am

When building interfaces, it is important to also consider those who can only use a keyboard to use your products. This is a basic accessibility need, and in most cases it isn’t hard to allow for a basic keyboard access. It means first and foremost using keyboard accessible elements for interaction:

anchors with a valid href attribute if you want the user to go somewhere

buttons when you want to execute your own code and stay in the document

You can make almost everything keyboard accessible using the roving tab index technique, but why bother when there are HTML elements that can do the same?

Making it visual

Using the right elements isn’t quite enough though; you also need to make it obvious where a keyboard user is in a collection of elements. Browsers do this by putting an outline around active elements. Whilst dead useful this has always been a thorn in the side of people who want to control the whole visual display of any interaction. You can remove this visual aid by setting the CSS outline property to none, which is a big accessibility issue unless you also provide an alternative.

By using the most obvious HTML elements for the job and some CSS to ensure that not only hover but also focus states are defined we can make it easy for our users to navigate a list of items by tabbing through them. Shift-Tab allows you to go backwards. You can try it here and the HTML is pretty straight forward.

<ul > <li > <button > 1 </button > </li > <li > <button > 2 </button > </li > <li > <button > 3 </button > </li > … <li > <button > 20 </button > </li > </ul > <ul> <li><button>1</button></li> <li><button>2</button></li> <li><button>3</button></li> … <li><button>20</button></li> </ul>

Using a list gives our elements a hierarchy and a way to navigate with accessible technology that a normal browser doesn’t have. It also gives us a lot of HTML elements to apply styling to. With a few styles, we can turn this into a grid, using less vertical space and allowing for more content in a small space.

ul , li { margin : 0 ; padding : 0 ; list-style : none ; } button { border : none ; display : block ; background : goldenrod ; color : white ; width : 90% ; height : 30px ; margin : 5% ; transform : scale ( 0.8 ) ; transition : 300ms ; } button : hover , button : focus { transform : scale ( 1 ) ; outline : none ; background : powderblue ; color : #333 ; } li { float : left ; } /* grid magic by @heydonworks https://codepen.io/heydon/pen/bcdrl */ li { width : calc ( 100% / 4 ) ; } li : nth-child ( 4n + 1 ) : nth-last-child ( 1 ) { width : 100% ; } li : nth-child ( 4n + 1 ) : nth-last-child ( 1 ) ~ li { width : 100% ; } li : nth-child ( 4n + 1 ) : nth-last-child ( 2 ) { width : 50% ; } li : nth-child ( 4n + 1 ) : nth-last-child ( 2 ) ~ li { width : 50% ; } li : nth-child ( 4n + 1 ) : nth-last-child ( 3 ) { width : calc ( 100% / 4 ) ; } li : nth-child ( 4n + 1 ) : nth-last-child ( 3 ) ~ li { width : calc ( 100% / 4 ) ; } ul, li { margin: 0; padding: 0; list-style: none; } button { border: none; display: block; background: goldenrod; color: white; width: 90%; height: 30px; margin: 5%; transform: scale(0.8); transition: 300ms; } button:hover, button:focus { transform: scale(1); outline: none; background: powderblue; color: #333; } li { float: left; } /* grid magic by @heydonworks https://codepen.io/heydon/pen/bcdrl */ li { width: calc(100% / 4); } li:nth-child(4n+1):nth-last-child(1) { width: 100%; } li:nth-child(4n+1):nth-last-child(1) ~ li { width: 100%; } li:nth-child(4n+1):nth-last-child(2) { width: 50%; } li:nth-child(4n+1):nth-last-child(2) ~ li { width: 50%; } li:nth-child(4n+1):nth-last-child(3) { width: calc(100% / 4); } li:nth-child(4n+1):nth-last-child(3) ~ li { width: calc(100% / 4); }

The result looks pretty fancy and it is very obvious where we are in our journey through the list.

Enhancing the keyboard access – providing shortcuts

However, if I am in a grid, wouldn’t it be better if I could move in two directions with my keyboard?

Using a bit of JavaScript for progressive enhancement, we get this effect and can navigate the grid either with the cursor keys or by using WASD:

It is important to remember here that this is an enhancement. Our list is still fully accessible by tabbing and should JavaScript fail for any of the dozens of reasons it can, we lost a bit of convenience instead of having no interface at all.

I’ve packaged this up in a small open source, vanilla, dependency free JavaScript called gridnav and you can get it on GitHub. All you need to do is to call the script and give it a selector to reach your list of elements.

<ul id = "links" data-amount = "5" data-element = "a" > <li > <a href = "#" > 1 </a > </li > <li > <a href = "#" > 2 </a > </li > … <li > <a href = "#" > 25 </a > </li > </ul > <script src = "gridnav.js" > </script > <script > var linklist = new Gridnav('#links'); </script > <ul id="links" data-amount="5" data-element="a"> <li><a href="#">1</a></li> <li><a href="#">2</a></li> … <li><a href="#">25</a></li> </ul> <script src="gridnav.js"></script> <script> var linklist = new Gridnav('#links'); </script>

You define the amount of elements in each row and the keyboard accessible element as data attributes on the list element. These are optional, but make the script faster and less error prone. There’s an extensive README explaining how to use the script.

How does it work?

When I started to ponder how to do this, I started like any developer does: trying to tackle the most complex way. I thought I needed to navigate the DOM a lot using parent nodes and siblings with lots of comparing of positioning and using getBoundingClientRect.

Then I took a step back and realised that it doesn’t matter how we display the list. In the end, it is just a list and we need to navigate this one. And we don’t even need to navigate the DOM, as all we do is go from one element in a collection of buttons or anchors to another. All we need to do is to:

Find the element we are on (event.target gives us that). Get the key that was pressed Depending on the key move to the next, previous, or skip a few elements to get to the next row

Like this (you can try it out here):

The amount of elements we need to skip is defined by the amount of elements in a row. Going up is going n elements backwards and going down is n elements forwards in the collection.

The full code is pretty short if you use some tricks:

( function ( ) { var list = document. querySelector ( 'ul' ) ; var items = list. querySelectorAll ( 'button' ) ; var amount = Math . floor ( list. offsetWidth / list. firstElementChild . offsetWidth ) ; var codes = { 38 : - amount , 40 : amount , 39 : 1 , 37 : - 1 } ; for ( var i = 0 ; i < items. length ; i ++ ) { items [ i ] . index = i ; } function handlekeys ( ev ) { var keycode = ev. keyCode ; if ( codes [ keycode ] ) { var t = ev. target ; if ( t. index !== undefined ) { if ( items [ t. index + codes [ keycode ] ] ) { items [ t. index + codes [ keycode ] ] . focus ( ) ; } } } } list. addEventListener ( 'keyup' , handlekeys ) ; } ) ( ) ; (function(){ var list = document.querySelector('ul'); var items = list.querySelectorAll('button'); var amount = Math.floor( list.offsetWidth / list.firstElementChild.offsetWidth ); var codes = { 38: -amount, 40: amount, 39: 1, 37: -1 }; for (var i = 0; i < items.length; i++) { items[i].index = i; } function handlekeys(ev) { var keycode = ev.keyCode; if (codes[keycode]) { var t = ev.target; if (t.index !== undefined) { if (items[t.index + codes[keycode]]) { items[t.index + codes[keycode]].focus(); } } } } list.addEventListener('keyup', handlekeys); })();

What’s going on here?

We get a handle to the list and cache all the keyboard accessible elements to navigate through

var list = document. querySelector ( 'ul' ) ; var items = list. querySelectorAll ( 'button' ) ; var list = document.querySelector('ul'); var items = list.querySelectorAll('button');

We calculate the amount of elements to skip when going up and down by dividing the width of the list element by the width of the first child element that is an HTML element (in this case this will be the LI)

var amount = Math . floor ( list. offsetWidth / list. firstElementChild . offsetWidth ) ; var amount = Math.floor( list.offsetWidth / list.firstElementChild.offsetWidth );

Instead of creating a switch statement or lots of if statements for keyboard handling, I prefer to define a lookup table. In this case, it is called codes. They key code for up is 38, 40 is down, 39 is right and 37 is left. If we now get codes[37] for example, we get -1, which is the amount of elements to move in the list

var codes = { 38 : - amount , 40 : amount , 39 : 1 , 37 : - 1 } ; var codes = { 38: -amount, 40: amount, 39: 1, 37: -1 };

We can use event.target to get which button was pressed in the list, but we don’t know where in the list it is. To avoid having to loop through the list on each keystroke, it makes more sense to loop through all the buttons once and store their index in the list in an index property on the button itself.

for ( var i = 0 ; i < items. length ; i ++ ) { items [ i ] . index = i ; } for (var i = 0; i < items.length; i++) { items[i].index = i; }

The handlekeys() function does the rest. We read the code of the key pressed and compare it with the codes lookup table. This also means we only react to arrow keys in our function. We then get the current element the key was pressed on and check if it has an index property. If it has one, we check if an element exist in the collection that is in the direction we want to move. We do this by adding the index of the current element to the value returned from the lookup table. If the element exists, we focus on it.

function handlekeys ( ev ) { var keycode = ev. keyCode ; if ( codes [ keycode ] ) { var t = ev. target ; if ( t. index !== undefined ) { if ( items [ t. index + codes [ keycode ] ] ) { items [ t. index + codes [ keycode ] ] . focus ( ) ; } } } } function handlekeys(ev) { var keycode = ev.keyCode; if (codes[keycode]) { var t = ev.target; if (t.index !== undefined) { if (items[t.index + codes[keycode]]) { items[t.index + codes[keycode]].focus(); } } } }

We apply a keyup event listener to the list and we’re done :)

list. addEventListener ( 'keyup' , handlekeys ) ; list.addEventListener('keyup', handlekeys);

If you feel like following this along live, here’s a quick video tutorial of me explaining all the bits and bobs.

The video has a small bug in the final code as I am not comparing the count property to undefined, which means the keyboard functionality doesn’t work on the first item (as 0 is falsy).