Implement roving tab index context based magic thing and demo on LeftPanel

Signed-off-by: Michael Telatynski <7t3chguy@gmail.com>

src/contexts/RovingTabIndexContext.js

@@ -0,0 +1,193 @@
+/*
+ *
+ * Copyright 2019 Michael Telatynski <7t3chguy@gmail.com>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * /
+ */
+
+import React, {
+    createContext,
+    useCallback,
+    useContext,
+    useLayoutEffect,
+    useMemo,
+    useRef,
+    useReducer,
+} from "react";
+import PropTypes from "prop-types";
+import {Key} from "../Keyboard";
+
+const DOCUMENT_POSITION_PRECEDING = 2;
+const ANY = Symbol();
+
+const RovingTabIndexContext = createContext({
+    state: {
+        activeRef: null,
+        refs: [],
+    },
+    dispatch: () => {},
+});
+RovingTabIndexContext.displayName = "RovingTabIndexContext";
+
+// TODO use a TypeScript type here
+const types = {
+    REGISTER: "REGISTER",
+    UNREGISTER: "UNREGISTER",
+    SET_FOCUS: "SET_FOCUS",
+};
+
+const reducer = (state, action) => {
+    switch (action.type) {
+        case types.REGISTER: {
+            if (state.refs.length === 0) {
+                return {
+                    ...state,
+                    activeRef: action.payload.ref,
+                    refs: [action.payload.ref],
+                };
+            }
+
+            if (state.refs.includes(action.payload.ref)) {
+                return state; // already in refs, this should not happen
+            }
+
+            let newIndex = state.refs.findIndex(ref => {
+                return ref.current.compareDocumentPosition(action.payload.ref.current) & DOCUMENT_POSITION_PRECEDING;
+            });
+
+            if (newIndex < 0) {
+                newIndex = state.refs.length; // append to the end
+            }
+
+            return {
+                ...state,
+                refs: [
+                    ...state.refs.slice(0, newIndex),
+                    action.payload.ref,
+                    ...state.refs.slice(newIndex),
+                ],
+            };
+        }
+        case types.UNREGISTER: {
+            const refs = state.refs.filter(r => r !== action.payload.ref); // keep all other refs
+
+            if (refs.length === state.refs.length) {
+                return state; // already removed, this should not happen
+            }
+
+            if (state.activeRef === action.payload.ref) { // we just removed the active ref, need to replace it
+                const oldIndex = state.refs.findIndex(r => r === action.payload.ref);
+                return {
+                    ...state,
+                    activeRef: oldIndex >= refs.length ? refs[refs.length - 1] : refs[oldIndex],
+                    refs,
+                };
+            }
+
+            return {
+                ...state,
+                refs,
+            };
+        }
+        case types.SET_FOCUS: {
+            return {
+                ...state,
+                activeRef: action.payload.ref,
+            };
+        }
+        default:
+            return state;
+    }
+};
+
+export const RovingTabIndexContextWrapper = ({children}) => {
+    const [state, dispatch] = useReducer(reducer, {
+        activeRef: null,
+        refs: [],
+    });
+
+    const context = useMemo(() => ({state, dispatch}), [state]);
+
+    return <RovingTabIndexContext.Provider value={context}>
+        {children}
+    </RovingTabIndexContext.Provider>;
+};
+
+export const useRovingTabIndex = () => {
+    const ref = useRef(null);
+    const context = useContext(RovingTabIndexContext);
+
+    // setup/teardown
+    // add ref to the context
+    useLayoutEffect(() => {
+        context.dispatch({
+            type: types.REGISTER,
+            payload: {ref},
+        });
+        return () => {
+            context.dispatch({
+                type: types.UNREGISTER,
+                payload: {ref},
+            });
+        };
+    }, []); // eslint-disable-line react-hooks/exhaustive-deps
+
+    const onFocus = useCallback(() => {
+        context.dispatch({
+            type: types.SET_FOCUS,
+            payload: {ref},
+        });
+    }, [ref, context]);
+    const isActive = context.state.activeRef === ref || context.state.activeRef === ANY;
+    return [onFocus, isActive, ref];
+};
+
+export const RovingTabIndexGroup = ({children}) => {
+    const [onFocus, isActive, ref] = useRovingTabIndex();
+
+    // fake reducer dispatch to catch SET_FOCUS calls and pass them to parent as a focus of the group
+    const dispatch = useCallback(({type}) => {
+        if (type === types.SET_FOCUS) {
+            onFocus();
+        }
+    }, [onFocus]);
+
+    const context = useMemo(() => ({
+        state: {activeRef: isActive ? ANY : undefined},
+        dispatch,
+    }), [isActive, dispatch]);
+
+    return <div ref={ref}>
+        <RovingTabIndexContext.Provider value={context}>
+            {children}
+        </RovingTabIndexContext.Provider>
+    </div>;
+};
+
+// Wraps a given element to attach it to the roving context, props onFocus and tabIndex overridden
+export const RovingTabIndex = ({component: E, useInputRef, ...props}) => {
+    const [onFocus, isActive, ref] = useRovingTabIndex();
+    const refProps = {};
+    if (useInputRef) {
+        refProps.inputRef = ref;
+    } else {
+        refProps.ref = ref;
+    }
+    return <E {...props} {...refProps} onFocus={onFocus} tabIndex={isActive ? 0 : -1} />;
+};
+RovingTabIndex.propTypes = {
+    component: PropTypes.elementType.isRequired,
+    useInputRef: PropTypes.bool, // whether to pass inputRef instead of ref like for AccessibleButton
+};
+