@geotab/zenith 3.0.0-beta.3 → 3.0.0

package/dist/selectList/selectList.test.js

@@ -0,0 +1,806 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const jsx_runtime_1 = require("react/jsx-runtime");
+const react_1 = __importStar(require("react"));
+const selectList_1 = require("./selectList");
+require("../testHelpers/geotab-axe");
+const checkboxState_1 = require("../checkbox/checkboxState");
+const reducerObj = __importStar(require("./selectList.reducer"));
+const selectListItemObj = __importStar(require("./selectListItem"));
+const selectList_helpers_1 = require("./selectList.helpers");
+const selectList_actionTypes_1 = require("./selectList.actionTypes");
+const isChildOf_1 = require("../utils/isChildOf");
+const react_2 = require("@testing-library/react");
+const iconCalendar_1 = require("../icons/iconCalendar");
+const items = [{
+        id: "a1",
+        children: "Item 1"
+    },
+    {
+        id: "a2",
+        children: "Item 2",
+        disabled: true
+    },
+    {
+        id: "a3",
+        className: "last-item",
+        children: (0, jsx_runtime_1.jsxs)("div", { className: "zen-caption", children: [(0, jsx_runtime_1.jsx)(iconCalendar_1.IconCalendar, { className: "zen-caption__pre-content" }), (0, jsx_runtime_1.jsx)("span", { className: "zen-caption__content", children: "Item 3" })] })
+    }];
+const value = new Map([["a1", checkboxState_1.CheckboxState.Off], ["a2", checkboxState_1.CheckboxState.Indeterminate], ["a3", checkboxState_1.CheckboxState.On]]);
+const initialState = {
+    itemsState: new Map(value),
+    isItemsStateChanged: false,
+    activeIndex: -1,
+    searchStr: "",
+    level: ""
+};
+const valueSingle = new Map([["a1", checkboxState_1.CheckboxState.Off], ["a2", checkboxState_1.CheckboxState.Indeterminate], ["a3", checkboxState_1.CheckboxState.Off]]);
+const initialStateSingle = {
+    itemsState: new Map(valueSingle),
+    isItemsStateChanged: false,
+    activeIndex: -1,
+    searchStr: "",
+    level: ""
+};
+jest.mock("./selectList.helpers", () => ({
+    updateItemState: jest.fn(),
+    getItemIdByIndex: jest.fn(),
+    getItemIndexById: jest.fn(),
+    getFirstIndex: jest.fn(),
+    getLastIndex: jest.fn(),
+    getNextIndex: jest.fn(),
+    getPrevIndex: jest.fn(),
+    searchItemIndex: jest.fn(),
+    getFirstActiveIndex: jest.fn(),
+    getInitialState: jest.fn()
+}));
+jest.mock("../utils/isChildOf", () => ({
+    isChildOf: jest.fn()
+}));
+jest.mock("./selectListItem");
+describe("selectList", () => {
+    const reducerSpy = jest.spyOn(reducerObj, "selectListReducer");
+    const selectlistItemSpy = selectListItemObj.SelectListItem;
+    const scrollIntoViewMock = jest.fn();
+    const getElement = (container) => container.querySelector(".zen-select-list");
+    beforeEach(() => {
+        jest.resetAllMocks();
+        Element.prototype.scrollIntoView = scrollIntoViewMock;
+        selectList_helpers_1.getInitialState.mockReturnValue({ ...initialState });
+    });
+    test("Test empty selectList", () => {
+        reducerSpy.mockReturnValue({ ...initialState, itemsState: new Map() });
+        selectList_helpers_1.getInitialState.mockReturnValue({ ...initialState, itemsState: new Map() });
+        const { container } = (0, react_2.render)((0, jsx_runtime_1.jsx)(selectList_1.SelectList, { title: "Select List", className: "selectList", id: "listId", items: [] }));
+        expect(getElement(container)).not.toBeNull();
+        expect(getElement(container)?.classList.contains("selectList")).toBeTruthy();
+        expect(selectlistItemSpy).not.toBeCalled(); // No items should be rendered
+    });
+    test("Test default state of selectList in singleselect mode", () => {
+        reducerSpy.mockReturnValue({ ...initialState });
+        const { container } = (0, react_2.render)((0, jsx_runtime_1.jsx)(selectList_1.SelectList, { title: "Select List", id: "listId", items: items, value: value }));
+        const el = getElement(container);
+        expect(el).not.toBeNull();
+        expect(el.getAttribute("aria-disabled")).toBeNull();
+        expect(el.tabIndex).toBe(0);
+        expect(selectlistItemSpy).toBeCalledTimes(items.length); // 3 items should be rendered
+        const calls = selectlistItemSpy.mock.calls;
+        expect(calls[0][0]).toEqual({ ...items[0], state: checkboxState_1.CheckboxState.Off, className: "zen-select-list__item", showCheckbox: false, focused: false, onChange: expect.anything() });
+        expect(calls[1][0]).toEqual({ ...items[1],
+            state: checkboxState_1.CheckboxState.Indeterminate, className: "zen-select-list__item", showCheckbox: false, focused: false, onChange: expect.anything() });
+        expect(calls[2][0]).toEqual({ ...items[2],
+            state: checkboxState_1.CheckboxState.On, className: "zen-select-list__item last-item", showCheckbox: false, focused: false, onChange: expect.anything() });
+    });
+    test("Test disabled mode", () => {
+        reducerSpy.mockReturnValue({ ...initialState });
+        const { container } = (0, react_2.render)((0, jsx_runtime_1.jsx)(selectList_1.SelectList, { title: "Select List", id: "listId", items: items, value: value, disabled: true }));
+        const el = getElement(container);
+        expect(el).not.toBeNull();
+        expect(el.getAttribute("aria-disabled")).toBe("true");
+        expect(el.tabIndex).toBe(-1);
+    });
+    test("Test default state of selectList in multiselect mode", () => {
+        reducerSpy.mockReturnValue({ ...initialState });
+        const { container } = (0, react_2.render)((0, jsx_runtime_1.jsx)(selectList_1.SelectList, { title: "Select List", id: "listId", items: items, value: value, multiselect: true }));
+        expect(getElement(container)).not.toBeNull();
+        expect(selectlistItemSpy).toBeCalledTimes(items.length); // 3 items should be rendered
+        const calls = selectlistItemSpy.mock.calls;
+        expect(calls[0][0]).toEqual({ ...items[0], state: checkboxState_1.CheckboxState.Off, className: "zen-select-list__item", showCheckbox: false, focused: false, onChange: expect.anything() });
+        expect(calls[1][0]).toEqual({ ...items[1],
+            state: checkboxState_1.CheckboxState.Indeterminate, className: "zen-select-list__item", showCheckbox: false, focused: false, onChange: expect.anything() });
+        expect(calls[2][0]).toEqual({ ...items[2],
+            state: checkboxState_1.CheckboxState.On, className: "zen-select-list__item last-item", showCheckbox: false, focused: false, onChange: expect.anything() });
+    });
+    test("Test keyboard navigation (ArrowUp)", async () => {
+        reducerSpy.mockReturnValue({ ...initialState });
+        selectList_helpers_1.getInitialState.mockReturnValue({ ...initialState });
+        const { container } = (0, react_2.render)((0, jsx_runtime_1.jsx)(selectList_1.SelectList, { title: "Select List", id: "listId", items: items, value: value, multiselect: true }));
+        const newState = { ...initialState, activeIndex: 1 };
+        selectlistItemSpy.mockClear();
+        reducerSpy.mockClear();
+        reducerSpy.mockReturnValue({ ...newState });
+        selectList_helpers_1.getInitialState.mockReturnValue({ ...newState });
+        const el = getElement(container);
+        await (0, react_1.act)(() => {
+            react_2.fireEvent.keyDown(el, { code: "ArrowUp" });
+            return Promise.resolve();
+        });
+        const calls = selectlistItemSpy.mock.calls;
+        // Only element with id="a2" should be re-rendered
+        expect(calls.length).toBe(1);
+        expect(calls[0][0].focused).toBeTruthy();
+        expect(calls[0][0].id).toBe("a2");
+        expect(reducerSpy).toBeCalledWith(initialState, { type: selectList_actionTypes_1.ListAction.FocusPrev, payload: { items } });
+    });
+    test("Test keyboard navigation (ArrowUp) in single-select mode", async () => {
+        const onChangeFn = jest.fn();
+        reducerSpy.mockReturnValue({ ...initialStateSingle });
+        selectList_helpers_1.getInitialState.mockReturnValue({ ...initialStateSingle });
+        const { container } = (0, react_2.render)((0, jsx_runtime_1.jsx)(selectList_1.SelectList, { title: "Select List", id: "listId", items: items, value: value, onChange: onChangeFn }));
+        const newItemsState = new Map([["a1", checkboxState_1.CheckboxState.Off], ["a2", checkboxState_1.CheckboxState.Off], ["a3", checkboxState_1.CheckboxState.On]]);
+        const newState = { ...initialStateSingle, isItemsStateChanged: true, itemsState: newItemsState, activeIndex: 2 };
+        selectlistItemSpy.mockClear();
+        reducerSpy.mockClear();
+        reducerSpy.mockReturnValue({ ...newState });
+        selectList_helpers_1.getInitialState.mockReturnValue({ ...newState });
+        const el = getElement(container);
+        await (0, react_1.act)(() => {
+            react_2.fireEvent.keyDown(el, { code: "ArrowUp" });
+            return Promise.resolve();
+        });
+        const calls = selectlistItemSpy.mock.calls;
+        expect(calls.length).toBe(2);
+        expect(calls[0][0].focused).toBeFalsy();
+        expect(calls[0][0].state).toBe(checkboxState_1.CheckboxState.Off);
+        expect(calls[0][0].id).toBe("a2");
+        expect(calls[1][0].focused).toBeTruthy();
+        expect(calls[1][0].state).toBe(checkboxState_1.CheckboxState.On);
+        expect(calls[1][0].id).toBe("a3");
+        expect(reducerSpy).toBeCalledWith(initialStateSingle, { type: selectList_actionTypes_1.ListAction.SelectPrev, payload: { items, multiselect: false } });
+        expect(onChangeFn).toBeCalled();
+    });
+    test("Test keyboard navigation (ArrowDown)", async () => {
+        reducerSpy.mockReturnValue({ ...initialState });
+        selectList_helpers_1.getInitialState.mockReturnValue({ ...initialState });
+        const { container } = (0, react_2.render)((0, jsx_runtime_1.jsx)(selectList_1.SelectList, { title: "Select List", id: "listId", items: items, value: value, multiselect: true }));
+        const newState = { ...initialState, activeIndex: 2 };
+        selectlistItemSpy.mockClear();
+        reducerSpy.mockClear();
+        reducerSpy.mockReturnValue({ ...newState });
+        selectList_helpers_1.getInitialState.mockReturnValue({ ...newState });
+        const el = getElement(container);
+        await (0, react_1.act)(() => {
+            react_2.fireEvent.keyDown(el, { code: "ArrowDown" });
+            return Promise.resolve();
+        });
+        const calls = selectlistItemSpy.mock.calls;
+        expect(calls.length).toBe(1);
+        expect(calls[0][0].focused).toBeTruthy();
+        expect(calls[0][0].id).toBe("a3");
+        expect(reducerSpy).toBeCalledWith(initialState, { type: selectList_actionTypes_1.ListAction.FocusNext, payload: { items } });
+    });
+    test("Test keyboard navigation (ArrowDown) in single-select mode", async () => {
+        const onChangeFn = jest.fn();
+        reducerSpy.mockReturnValue({ ...initialStateSingle });
+        selectList_helpers_1.getInitialState.mockReturnValue({ ...initialStateSingle });
+        const { container } = (0, react_2.render)((0, jsx_runtime_1.jsx)(selectList_1.SelectList, { title: "Select List", id: "listId", items: items, value: value, onChange: onChangeFn }));
+        const newItemsState = new Map([["a1", checkboxState_1.CheckboxState.Off], ["a2", checkboxState_1.CheckboxState.Off], ["a3", checkboxState_1.CheckboxState.On]]);
+        const newState = { ...initialStateSingle, itemsState: newItemsState, isItemsStateChanged: true, activeIndex: 1 };
+        selectlistItemSpy.mockClear();
+        reducerSpy.mockClear();
+        reducerSpy.mockReturnValue({ ...newState });
+        selectList_helpers_1.getInitialState.mockReturnValue({ ...newState });
+        const el = getElement(container);
+        await (0, react_1.act)(() => {
+            react_2.fireEvent.keyDown(el, { code: "ArrowDown" });
+            return Promise.resolve();
+        });
+        const calls = selectlistItemSpy.mock.calls;
+        expect(calls.length).toBe(2);
+        expect(calls[0][0].focused).toBeTruthy();
+        expect(calls[0][0].state).toBe(checkboxState_1.CheckboxState.Off);
+        expect(calls[0][0].id).toBe("a2");
+        expect(calls[1][0].focused).toBeFalsy();
+        expect(calls[1][0].state).toBe(checkboxState_1.CheckboxState.On);
+        expect(calls[1][0].id).toBe("a3");
+        expect(reducerSpy).toBeCalledWith(initialStateSingle, { type: selectList_actionTypes_1.ListAction.SelectNext, payload: { items, multiselect: false } });
+        expect(onChangeFn).toBeCalled();
+    });
+    test("Test keyboard navigation (Shift+Tab)", async () => {
+        reducerSpy.mockReturnValue({ ...initialState });
+        selectList_helpers_1.getInitialState.mockReturnValue({ ...initialState });
+        const { container } = (0, react_2.render)((0, jsx_runtime_1.jsx)(selectList_1.SelectList, { title: "Select List", id: "listId", items: items, value: value, multiselect: true }));
+        const newState = { ...initialState, activeIndex: 1 };
+        selectlistItemSpy.mockClear();
+        reducerSpy.mockClear();
+        reducerSpy.mockReturnValue({ ...newState });
+        selectList_helpers_1.getInitialState.mockReturnValue({ ...newState });
+        const el = getElement(container);
+        await (0, react_1.act)(() => {
+            react_2.fireEvent.keyDown(el, { code: "Shift+Tab" });
+            return Promise.resolve();
+        });
+        const calls = selectlistItemSpy.mock.calls;
+        // Only element with id="a2" should be re-rendered
+        expect(calls.length).toBe(1);
+        expect(calls[0][0].focused).toBeTruthy();
+        expect(calls[0][0].id).toBe("a2");
+        expect(reducerSpy).toBeCalledWith(initialState, { type: selectList_actionTypes_1.ListAction.FocusPrev, payload: { items } });
+    });
+    test("Test keyboard navigation (Shift+Tab) in single-select mode", async () => {
+        const onChangeFn = jest.fn();
+        reducerSpy.mockReturnValue({ ...initialStateSingle });
+        selectList_helpers_1.getInitialState.mockReturnValue({ ...initialStateSingle });
+        const { container } = (0, react_2.render)((0, jsx_runtime_1.jsx)(selectList_1.SelectList, { title: "Select List", id: "listId", items: items, value: value, onChange: onChangeFn }));
+        const newItemsState = new Map([["a1", checkboxState_1.CheckboxState.Off], ["a2", checkboxState_1.CheckboxState.Off], ["a3", checkboxState_1.CheckboxState.On]]);
+        const newState = { ...initialStateSingle, isItemsStateChanged: true, itemsState: newItemsState, activeIndex: 2 };
+        selectlistItemSpy.mockClear();
+        reducerSpy.mockClear();
+        reducerSpy.mockReturnValue({ ...newState });
+        selectList_helpers_1.getInitialState.mockReturnValue({ ...newState });
+        const el = getElement(container);
+        await (0, react_1.act)(() => {
+            react_2.fireEvent.keyDown(el, { code: "Shift+Tab" });
+            return Promise.resolve();
+        });
+        const calls = selectlistItemSpy.mock.calls;
+        expect(calls.length).toBe(2);
+        expect(calls[0][0].focused).toBeFalsy();
+        expect(calls[0][0].state).toBe(checkboxState_1.CheckboxState.Off);
+        expect(calls[0][0].id).toBe("a2");
+        expect(calls[1][0].focused).toBeTruthy();
+        expect(calls[1][0].state).toBe(checkboxState_1.CheckboxState.On);
+        expect(calls[1][0].id).toBe("a3");
+        expect(reducerSpy).toBeCalledWith(initialStateSingle, { type: selectList_actionTypes_1.ListAction.SelectPrev, payload: { items, multiselect: false } });
+        expect(onChangeFn).toBeCalled();
+    });
+    test("Test keyboard navigation (Tab)", async () => {
+        reducerSpy.mockReturnValue({ ...initialState });
+        selectList_helpers_1.getInitialState.mockReturnValue({ ...initialState });
+        const { container } = (0, react_2.render)((0, jsx_runtime_1.jsx)(selectList_1.SelectList, { title: "Select List", id: "listId", items: items, value: value, multiselect: true }));
+        const newState = { ...initialState, activeIndex: 1 };
+        selectlistItemSpy.mockClear();
+        reducerSpy.mockClear();
+        reducerSpy.mockReturnValue({ ...newState });
+        selectList_helpers_1.getInitialState.mockReturnValue({ ...newState });
+        const el = getElement(container);
+        await (0, react_1.act)(() => {
+            react_2.fireEvent.keyDown(el, { code: "Tab" });
+            return Promise.resolve();
+        });
+        const calls = selectlistItemSpy.mock.calls;
+        expect(calls.length).toBe(1);
+        expect(calls[0][0].focused).toBeTruthy();
+        expect(calls[0][0].id).toBe("a2");
+        expect(reducerSpy).toBeCalledWith(initialState, { type: selectList_actionTypes_1.ListAction.FocusNext, payload: { items } });
+    });
+    test("Test keyboard navigation (Tab) in single-select mode", async () => {
+        const onChangeFn = jest.fn();
+        reducerSpy.mockReturnValue({ ...initialStateSingle });
+        selectList_helpers_1.getInitialState.mockReturnValue({ ...initialStateSingle });
+        const { container } = (0, react_2.render)((0, jsx_runtime_1.jsx)(selectList_1.SelectList, { title: "Select List", id: "listId", items: items, value: value, onChange: onChangeFn }));
+        const newItemsState = new Map([["a1", checkboxState_1.CheckboxState.Off], ["a2", checkboxState_1.CheckboxState.Off], ["a3", checkboxState_1.CheckboxState.On]]);
+        const newState = { ...initialStateSingle, itemsState: newItemsState, isItemsStateChanged: true, activeIndex: 1 };
+        selectlistItemSpy.mockClear();
+        reducerSpy.mockClear();
+        reducerSpy.mockReturnValue({ ...newState });
+        selectList_helpers_1.getInitialState.mockReturnValue({ ...newState });
+        const el = getElement(container);
+        await (0, react_1.act)(() => {
+            react_2.fireEvent.keyDown(el, { code: "Tab" });
+            return Promise.resolve();
+        });
+        const calls = selectlistItemSpy.mock.calls;
+        expect(calls.length).toBe(2);
+        expect(calls[0][0].focused).toBeTruthy();
+        expect(calls[0][0].state).toBe(checkboxState_1.CheckboxState.Off);
+        expect(calls[0][0].id).toBe("a2");
+        expect(calls[1][0].focused).toBeFalsy();
+        expect(calls[1][0].state).toBe(checkboxState_1.CheckboxState.On);
+        expect(calls[1][0].id).toBe("a3");
+        expect(reducerSpy).toBeCalledWith(initialStateSingle, { type: selectList_actionTypes_1.ListAction.SelectNext, payload: { items, multiselect: false } });
+        expect(onChangeFn).toBeCalled();
+    });
+    test("Test keyboard navigation (Home)", async () => {
+        reducerSpy.mockReturnValue({ ...initialState });
+        selectList_helpers_1.getInitialState.mockReturnValue({ ...initialState });
+        const { container } = (0, react_2.render)((0, jsx_runtime_1.jsx)(selectList_1.SelectList, { title: "Select List", id: "listId", items: items, value: value, multiselect: true }));
+        const newState = { ...initialState, activeIndex: 0 };
+        selectlistItemSpy.mockClear();
+        reducerSpy.mockClear();
+        reducerSpy.mockReturnValue({ ...newState });
+        selectList_helpers_1.getInitialState.mockReturnValue({ ...newState });
+        const el = getElement(container);
+        await (0, react_1.act)(() => {
+            react_2.fireEvent.keyDown(el, { code: "Home" });
+            return Promise.resolve();
+        });
+        const calls = selectlistItemSpy.mock.calls;
+        expect(calls.length).toBe(1);
+        expect(calls[0][0].focused).toBeTruthy();
+        expect(calls[0][0].id).toBe("a1");
+        expect(reducerSpy).toBeCalledWith(initialState, { type: selectList_actionTypes_1.ListAction.FocusFirst, payload: { items } });
+    });
+    test("Test keyboard navigation (Home) in single-select mode", async () => {
+        const onChangeFn = jest.fn();
+        reducerSpy.mockReturnValue({ ...initialStateSingle });
+        selectList_helpers_1.getInitialState.mockReturnValue({ ...initialStateSingle });
+        const { container } = (0, react_2.render)((0, jsx_runtime_1.jsx)(selectList_1.SelectList, { title: "Select List", id: "listId", items: items, value: value, onChange: onChangeFn }));
+        const newItemsState = new Map([["a1", checkboxState_1.CheckboxState.Off], ["a2", checkboxState_1.CheckboxState.Indeterminate], ["a3", checkboxState_1.CheckboxState.On]]);
+        const newState = { ...initialStateSingle, itemsState: newItemsState, isItemsStateChanged: true, activeIndex: 1 };
+        selectlistItemSpy.mockClear();
+        reducerSpy.mockClear();
+        reducerSpy.mockReturnValue({ ...newState });
+        selectList_helpers_1.getInitialState.mockReturnValue({ ...newState });
+        const el = getElement(container);
+        await (0, react_1.act)(() => {
+            react_2.fireEvent.keyDown(el, { code: "Home" });
+            return Promise.resolve();
+        });
+        const calls = selectlistItemSpy.mock.calls;
+        expect(calls.length).toBe(2);
+        expect(calls[0][0].focused).toBeTruthy();
+        expect(calls[0][0].state).toBe(checkboxState_1.CheckboxState.Indeterminate);
+        expect(calls[0][0].id).toBe("a2");
+        expect(calls[1][0].focused).toBeFalsy();
+        expect(calls[1][0].state).toBe(checkboxState_1.CheckboxState.On);
+        expect(calls[1][0].id).toBe("a3");
+        expect(reducerSpy).toBeCalledWith(initialStateSingle, { type: selectList_actionTypes_1.ListAction.SelectFirst, payload: { items, multiselect: false } });
+        expect(onChangeFn).toBeCalled();
+    });
+    test("Test keyboard navigation (End)", async () => {
+        reducerSpy.mockReturnValue({ ...initialState });
+        selectList_helpers_1.getInitialState.mockReturnValue({ ...initialState });
+        const { container } = (0, react_2.render)((0, jsx_runtime_1.jsx)(selectList_1.SelectList, { title: "Select List", id: "listId", items: items, value: value, multiselect: true }));
+        const newState = { ...initialState, activeIndex: 1 };
+        selectlistItemSpy.mockClear();
+        reducerSpy.mockClear();
+        reducerSpy.mockReturnValue({ ...newState });
+        selectList_helpers_1.getInitialState.mockReturnValue({ ...newState });
+        const el = getElement(container);
+        await (0, react_1.act)(() => {
+            react_2.fireEvent.keyDown(el, { code: "End" });
+            return Promise.resolve();
+        });
+        const calls = selectlistItemSpy.mock.calls;
+        expect(calls.length).toBe(1);
+        expect(calls[0][0].focused).toBeTruthy();
+        expect(calls[0][0].id).toBe("a2");
+        expect(reducerSpy).toBeCalledWith(initialState, { type: selectList_actionTypes_1.ListAction.FocusLast, payload: { items } });
+    });
+    test("Test keyboard navigation (End) in single-select mode", async () => {
+        const onChangeFn = jest.fn();
+        reducerSpy.mockReturnValue({ ...initialStateSingle });
+        selectList_helpers_1.getInitialState.mockReturnValue({ ...initialStateSingle });
+        const { container } = (0, react_2.render)((0, jsx_runtime_1.jsx)(selectList_1.SelectList, { title: "Select List", id: "listId", items: items, value: value, onChange: onChangeFn }));
+        const newItemsState = new Map([["a1", checkboxState_1.CheckboxState.Off], ["a2", checkboxState_1.CheckboxState.Indeterminate], ["a3", checkboxState_1.CheckboxState.On]]);
+        const newState = { ...initialStateSingle, itemsState: newItemsState, isItemsStateChanged: true, activeIndex: 2 };
+        selectlistItemSpy.mockClear();
+        reducerSpy.mockClear();
+        reducerSpy.mockReturnValue({ ...newState });
+        selectList_helpers_1.getInitialState.mockReturnValue(newState);
+        const el = getElement(container);
+        await (0, react_1.act)(() => {
+            react_2.fireEvent.keyDown(el, { code: "End" });
+            return Promise.resolve();
+        });
+        const calls = selectlistItemSpy.mock.calls;
+        expect(calls.length).toBe(1);
+        expect(calls[0][0].focused).toBeTruthy();
+        expect(calls[0][0].state).toBe(checkboxState_1.CheckboxState.On);
+        expect(calls[0][0].id).toBe("a3");
+        expect(reducerSpy).toBeCalledWith(initialStateSingle, { type: selectList_actionTypes_1.ListAction.SelectLast, payload: { items, multiselect: false } });
+        expect(onChangeFn).toBeCalled();
+    });
+    test("Test keyboard navigation (Space)", async () => {
+        const onChangeFn = jest.fn();
+        reducerSpy.mockReturnValue({ ...initialState });
+        selectList_helpers_1.getInitialState.mockReturnValue({ ...initialState });
+        const { container } = (0, react_2.render)((0, jsx_runtime_1.jsx)(selectList_1.SelectList, { title: "Select List", id: "listId", items: items, value: value, multiselect: true, onChange: onChangeFn }));
+        const newState = { ...initialState, isItemsStateChanged: true, itemsState: new Map([["a1", checkboxState_1.CheckboxState.On], ["a2", checkboxState_1.CheckboxState.Indeterminate], ["a3", checkboxState_1.CheckboxState.On]]) };
+        selectlistItemSpy.mockClear();
+        reducerSpy.mockClear();
+        reducerSpy.mockReturnValue({ ...newState });
+        selectList_helpers_1.getInitialState.mockReturnValue(newState);
+        const el = getElement(container);
+        await (0, react_1.act)(() => {
+            react_2.fireEvent.keyDown(el, { code: "Space" });
+            return Promise.resolve();
+        });
+        const calls = selectlistItemSpy.mock.calls;
+        expect(calls.length).toBe(1);
+        expect(calls[0][0].state).toBe(checkboxState_1.CheckboxState.On);
+        expect(calls[0][0].id).toBe("a1");
+        expect(reducerSpy).toBeCalledWith(initialState, { type: selectList_actionTypes_1.ListAction.ToggleCurrent, payload: { multiselect: true } });
+        expect(onChangeFn).toBeCalledTimes(1);
+        expect(onChangeFn).toBeCalledWith(new Map([["a1", checkboxState_1.CheckboxState.On], ["a2", checkboxState_1.CheckboxState.Indeterminate], ["a3", checkboxState_1.CheckboxState.On]]));
+    });
+    test("Test keyboard navigation (Enter): no active item", async () => {
+        const onChangeFn = jest.fn();
+        reducerSpy.mockClear();
+        reducerSpy.mockReturnValue({ ...initialState });
+        selectList_helpers_1.getInitialState.mockReturnValue({ ...initialState });
+        const { container } = (0, react_2.render)((0, jsx_runtime_1.jsx)(selectList_1.SelectList, { title: "Select List", id: "listId", items: items, value: value, onChange: onChangeFn, selectItemOnFocus: false }));
+        reducerSpy.mockClear();
+        const el = getElement(container);
+        await (0, react_1.act)(() => {
+            react_2.fireEvent.keyDown(el, { code: "Enter" });
+            return Promise.resolve();
+        });
+        expect(reducerSpy).not.toBeCalled();
+    });
+    test("Test keyboard navigation (Enter)", async () => {
+        const onChangeFn = jest.fn();
+        const initial = {
+            ...initialState,
+            activeIndex: 0
+        };
+        reducerSpy.mockReturnValue({ ...initial });
+        selectList_helpers_1.getInitialState.mockReturnValue({ ...initial });
+        const { container } = (0, react_2.render)((0, jsx_runtime_1.jsx)(selectList_1.SelectList, { title: "Select List", id: "listId", items: items, value: value, onChange: onChangeFn, selectItemOnFocus: false }));
+        const el = getElement(container);
+        await (0, react_1.act)(() => {
+            react_2.fireEvent.keyDown(el, { code: "Enter" });
+            return Promise.resolve();
+        });
+        expect(reducerSpy).toBeCalledWith(initial, { type: selectList_actionTypes_1.ListAction.ChangeItemState, payload: { updatedId: "a1", updatedState: checkboxState_1.CheckboxState.On, multiselect: false } });
+    });
+    test("Test keyboard navigation (Shift+ArrowUp)", async () => {
+        const onChangeFn = jest.fn();
+        reducerSpy.mockReturnValue({ ...initialState });
+        selectList_helpers_1.getInitialState.mockReturnValue({ ...initialState });
+        const { container } = (0, react_2.render)((0, jsx_runtime_1.jsx)(selectList_1.SelectList, { title: "Select List", id: "listId", items: items, value: value, multiselect: true, onChange: onChangeFn }));
+        const newState = { ...initialState, isItemsStateChanged: true, itemsState: new Map([["a1", checkboxState_1.CheckboxState.On], ["a2", checkboxState_1.CheckboxState.Indeterminate], ["a3", checkboxState_1.CheckboxState.On]]) };
+        selectlistItemSpy.mockClear();
+        reducerSpy.mockClear();
+        reducerSpy.mockReturnValue({ ...newState });
+        selectList_helpers_1.getInitialState.mockReturnValue(newState);
+        const el = getElement(container);
+        await (0, react_1.act)(() => {
+            react_2.fireEvent.keyDown(el, { code: "ArrowUp", shiftKey: true });
+            return Promise.resolve();
+        });
+        const calls = selectlistItemSpy.mock.calls;
+        expect(calls.length).toBe(1);
+        expect(calls[0][0].state).toBe(checkboxState_1.CheckboxState.On);
+        expect(calls[0][0].id).toBe("a1");
+        expect(reducerSpy).toBeCalledWith(initialState, { type: selectList_actionTypes_1.ListAction.SelectPrev, payload: { items: items, multiselect: true } });
+        expect(onChangeFn).toBeCalledTimes(1);
+        expect(onChangeFn).toBeCalledWith(new Map([["a1", checkboxState_1.CheckboxState.On], ["a2", checkboxState_1.CheckboxState.Indeterminate], ["a3", checkboxState_1.CheckboxState.On]]));
+    });
+    test("Test keyboard navigation (Shift+ArrowUp) in single-select mode", async () => {
+        const onChangeFn = jest.fn();
+        reducerSpy.mockReturnValue({ ...initialStateSingle });
+        selectList_helpers_1.getInitialState.mockReturnValue({ ...initialStateSingle });
+        const { container } = (0, react_2.render)((0, jsx_runtime_1.jsx)(selectList_1.SelectList, { title: "Select List", id: "listId", items: items, value: value, onChange: onChangeFn }));
+        const newState = { ...initialStateSingle, isItemsStateChanged: true, itemsState: new Map([["a1", checkboxState_1.CheckboxState.On], ["a2", checkboxState_1.CheckboxState.Indeterminate], ["a3", checkboxState_1.CheckboxState.On]]) };
+        selectlistItemSpy.mockClear();
+        reducerSpy.mockClear();
+        reducerSpy.mockReturnValue({ ...newState });
+        selectList_helpers_1.getInitialState.mockReturnValue(newState);
+        const el = getElement(container);
+        await (0, react_1.act)(() => {
+            react_2.fireEvent.keyDown(el, { code: "ArrowUp", shiftKey: true });
+            return Promise.resolve();
+        });
+        expect(reducerSpy).not.toBeCalled();
+        expect(onChangeFn).not.toBeCalled();
+    });
+    test("Test keyboard navigation (Shift+ArrowDown)", async () => {
+        const onChangeFn = jest.fn();
+        reducerSpy.mockReturnValue({ ...initialState });
+        selectList_helpers_1.getInitialState.mockReturnValue({ ...initialState });
+        const { container } = (0, react_2.render)((0, jsx_runtime_1.jsx)(selectList_1.SelectList, { title: "Select List", id: "listId", items: items, value: value, multiselect: true, onChange: onChangeFn }));
+        const newState = { ...initialState, isItemsStateChanged: true, itemsState: new Map([["a1", checkboxState_1.CheckboxState.On], ["a2", checkboxState_1.CheckboxState.Indeterminate], ["a3", checkboxState_1.CheckboxState.On]]) };
+        selectlistItemSpy.mockClear();
+        reducerSpy.mockClear();
+        reducerSpy.mockReturnValue({ ...newState });
+        selectList_helpers_1.getInitialState.mockReturnValue(newState);
+        const el = getElement(container);
+        await (0, react_1.act)(() => {
+            react_2.fireEvent.keyDown(el, { code: "ArrowDown", shiftKey: true });
+            return Promise.resolve();
+        });
+        const calls = selectlistItemSpy.mock.calls;
+        expect(calls.length).toBe(1);
+        expect(calls[0][0].state).toBe(checkboxState_1.CheckboxState.On);
+        expect(calls[0][0].id).toBe("a1");
+        expect(reducerSpy).toBeCalledWith(initialState, { type: selectList_actionTypes_1.ListAction.SelectNext, payload: { items: items, multiselect: true } });
+        expect(onChangeFn).toBeCalledTimes(1);
+        expect(onChangeFn).toBeCalledWith(new Map([["a1", checkboxState_1.CheckboxState.On], ["a2", checkboxState_1.CheckboxState.Indeterminate], ["a3", checkboxState_1.CheckboxState.On]]));
+    });
+    test("Test keyboard navigation (Shift+ArrowDown) in single-select mode", async () => {
+        const onChangeFn = jest.fn();
+        reducerSpy.mockReturnValue({ ...initialStateSingle });
+        selectList_helpers_1.getInitialState.mockReturnValue({ ...initialStateSingle });
+        const { container } = (0, react_2.render)((0, jsx_runtime_1.jsx)(selectList_1.SelectList, { title: "Select List", id: "listId", items: items, value: value, onChange: onChangeFn }));
+        const newState = { ...initialStateSingle, isItemsStateChanged: true, itemsState: new Map([["a1", checkboxState_1.CheckboxState.On], ["a2", checkboxState_1.CheckboxState.Indeterminate], ["a3", checkboxState_1.CheckboxState.On]]) };
+        selectlistItemSpy.mockClear();
+        reducerSpy.mockClear();
+        reducerSpy.mockReturnValue({ ...newState });
+        selectList_helpers_1.getInitialState.mockReturnValue(newState);
+        const el = getElement(container);
+        await (0, react_1.act)(() => {
+            react_2.fireEvent.keyDown(el, { code: "ArrowDown", shiftKey: true });
+            return Promise.resolve();
+        });
+        expect(reducerSpy).not.toBeCalled();
+        expect(onChangeFn).not.toBeCalled();
+    });
+    test("Test keyboard navigation (Control+Shift+Home)", async () => {
+        const onChangeFn = jest.fn();
+        reducerSpy.mockReturnValue({ ...initialState });
+        selectList_helpers_1.getInitialState.mockReturnValue({ ...initialState });
+        const { container } = (0, react_2.render)((0, jsx_runtime_1.jsx)(selectList_1.SelectList, { title: "Select List", id: "listId", items: items, value: value, multiselect: true, onChange: onChangeFn }));
+        const newState = { ...initialState, isItemsStateChanged: true, itemsState: new Map([["a1", checkboxState_1.CheckboxState.On], ["a2", checkboxState_1.CheckboxState.Indeterminate], ["a3", checkboxState_1.CheckboxState.On]]) };
+        selectlistItemSpy.mockClear();
+        reducerSpy.mockClear();
+        reducerSpy.mockReturnValue({ ...newState });
+        selectList_helpers_1.getInitialState.mockReturnValue(newState);
+        const el = getElement(container);
+        await (0, react_1.act)(() => {
+            react_2.fireEvent.keyDown(el, { code: "Home", shiftKey: true, ctrlKey: true });
+            return Promise.resolve();
+        });
+        const calls = selectlistItemSpy.mock.calls;
+        expect(calls.length).toBe(1);
+        expect(calls[0][0].state).toBe(checkboxState_1.CheckboxState.On);
+        expect(calls[0][0].id).toBe("a1");
+        expect(reducerSpy).toBeCalledWith(initialState, { type: selectList_actionTypes_1.ListAction.SelectAllToTheBeginning, payload: { items: items, multiselect: true } });
+        expect(onChangeFn).toBeCalledTimes(1);
+        expect(onChangeFn).toBeCalledWith(new Map([["a1", checkboxState_1.CheckboxState.On], ["a2", checkboxState_1.CheckboxState.Indeterminate], ["a3", checkboxState_1.CheckboxState.On]]));
+    });
+    test("Test keyboard navigation (Control+Shift+Home) in single-select mode", async () => {
+        const onChangeFn = jest.fn();
+        reducerSpy.mockReturnValue({ ...initialStateSingle });
+        selectList_helpers_1.getInitialState.mockReturnValue({ ...initialStateSingle });
+        const { container } = (0, react_2.render)((0, jsx_runtime_1.jsx)(selectList_1.SelectList, { title: "Select List", id: "listId", items: items, value: value, onChange: onChangeFn }));
+        const newState = { ...initialStateSingle, isItemsStateChanged: true, itemsState: new Map([["a1", checkboxState_1.CheckboxState.On], ["a2", checkboxState_1.CheckboxState.Indeterminate], ["a3", checkboxState_1.CheckboxState.On]]) };
+        selectlistItemSpy.mockClear();
+        reducerSpy.mockClear();
+        reducerSpy.mockReturnValue({ ...newState });
+        selectList_helpers_1.getInitialState.mockReturnValue(newState);
+        const el = getElement(container);
+        await (0, react_1.act)(() => {
+            react_2.fireEvent.keyDown(el, { code: "Home", shiftKey: true, ctrlKey: true });
+            return Promise.resolve();
+        });
+        expect(reducerSpy).not.toBeCalled();
+        expect(onChangeFn).not.toBeCalled();
+    });
+    test("Test keyboard navigation (Control+Shift+End)", async () => {
+        const onChangeFn = jest.fn();
+        reducerSpy.mockReturnValue({ ...initialState });
+        selectList_helpers_1.getInitialState.mockReturnValue({ ...initialState });
+        const { container } = (0, react_2.render)((0, jsx_runtime_1.jsx)(selectList_1.SelectList, { title: "Select List", id: "listId", items: items, value: value, multiselect: true, onChange: onChangeFn }));
+        const newState = { ...initialState, isItemsStateChanged: true, itemsState: new Map([["a1", checkboxState_1.CheckboxState.On], ["a2", checkboxState_1.CheckboxState.Indeterminate], ["a3", checkboxState_1.CheckboxState.On]]) };
+        selectlistItemSpy.mockClear();
+        reducerSpy.mockClear();
+        reducerSpy.mockReturnValue({ ...newState });
+        selectList_helpers_1.getInitialState.mockReturnValue(newState);
+        const el = getElement(container);
+        await (0, react_1.act)(() => {
+            react_2.fireEvent.keyDown(el, { code: "End", shiftKey: true, ctrlKey: true });
+            return Promise.resolve();
+        });
+        const calls = selectlistItemSpy.mock.calls;
+        expect(calls.length).toBe(1);
+        expect(calls[0][0].state).toBe(checkboxState_1.CheckboxState.On);
+        expect(calls[0][0].id).toBe("a1");
+        expect(reducerSpy).toBeCalledWith(initialState, { type: selectList_actionTypes_1.ListAction.SelectAllToTheEnd, payload: { items: items, multiselect: true } });
+        expect(onChangeFn).toBeCalledTimes(1);
+        expect(onChangeFn).toBeCalledWith(new Map([["a1", checkboxState_1.CheckboxState.On], ["a2", checkboxState_1.CheckboxState.Indeterminate], ["a3", checkboxState_1.CheckboxState.On]]));
+    });
+    test("Test keyboard navigation (Control+Shift+End) in single-select mode", async () => {
+        const onChangeFn = jest.fn();
+        reducerSpy.mockReturnValue({ ...initialStateSingle });
+        selectList_helpers_1.getInitialState.mockReturnValue({ ...initialStateSingle });
+        const { container } = (0, react_2.render)((0, jsx_runtime_1.jsx)(selectList_1.SelectList, { title: "Select List", id: "listId", items: items, value: value, onChange: onChangeFn }));
+        const newState = { ...initialStateSingle, isItemsStateChanged: true, itemsState: new Map([["a1", checkboxState_1.CheckboxState.On], ["a2", checkboxState_1.CheckboxState.Indeterminate], ["a3", checkboxState_1.CheckboxState.On]]) };
+        selectlistItemSpy.mockClear();
+        reducerSpy.mockClear();
+        reducerSpy.mockReturnValue({ ...newState });
+        selectList_helpers_1.getInitialState.mockReturnValue(newState);
+        const el = getElement(container);
+        await (0, react_1.act)(() => {
+            react_2.fireEvent.keyDown(el, { code: "End", shiftKey: true, ctrlKey: true });
+            return Promise.resolve();
+        });
+        expect(reducerSpy).not.toBeCalled();
+        expect(onChangeFn).not.toBeCalled();
+    });
+    test("Test keyboard navigation (Control+A)", async () => {
+        const onChangeFn = jest.fn();
+        reducerSpy.mockReturnValue({ ...initialState });
+        selectList_helpers_1.getInitialState.mockReturnValue({ ...initialState });
+        const { container } = (0, react_2.render)((0, jsx_runtime_1.jsx)(selectList_1.SelectList, { title: "Select List", id: "listId", items: items, value: value, multiselect: true, onChange: onChangeFn }));
+        const newState = { ...initialState, isItemsStateChanged: true, itemsState: new Map([["a1", checkboxState_1.CheckboxState.On], ["a2", checkboxState_1.CheckboxState.Indeterminate], ["a3", checkboxState_1.CheckboxState.On]]) };
+        selectlistItemSpy.mockClear();
+        reducerSpy.mockClear();
+        reducerSpy.mockReturnValue({ ...newState });
+        selectList_helpers_1.getInitialState.mockReturnValue(newState);
+        const el = getElement(container);
+        await (0, react_1.act)(() => {
+            react_2.fireEvent.keyDown(el, { code: "KeyA", ctrlKey: true });
+            return Promise.resolve();
+        });
+        const calls = selectlistItemSpy.mock.calls;
+        expect(calls.length).toBe(1);
+        expect(calls[0][0].state).toBe(checkboxState_1.CheckboxState.On);
+        expect(calls[0][0].id).toBe("a1");
+        expect(reducerSpy).toBeCalledWith(initialState, { type: selectList_actionTypes_1.ListAction.ToggleAll, payload: { items: items, multiselect: true } });
+        expect(onChangeFn).toBeCalledTimes(1);
+        expect(onChangeFn).toBeCalledWith(new Map([["a1", checkboxState_1.CheckboxState.On], ["a2", checkboxState_1.CheckboxState.Indeterminate], ["a3", checkboxState_1.CheckboxState.On]]));
+    });
+    test("Test keyboard navigation (Control+A) in single-select mode", async () => {
+        const onChangeFn = jest.fn();
+        reducerSpy.mockReturnValue({ ...initialStateSingle });
+        selectList_helpers_1.getInitialState.mockReturnValue({ ...initialStateSingle });
+        const { container } = (0, react_2.render)((0, jsx_runtime_1.jsx)(selectList_1.SelectList, { title: "Select List", id: "listId", items: items, value: value, onChange: onChangeFn }));
+        const newState = { ...initialStateSingle, isItemsStateChanged: true, itemsState: new Map([["a1", checkboxState_1.CheckboxState.On], ["a2", checkboxState_1.CheckboxState.Indeterminate], ["a3", checkboxState_1.CheckboxState.On]]) };
+        selectlistItemSpy.mockClear();
+        reducerSpy.mockClear();
+        reducerSpy.mockReturnValue({ ...newState });
+        selectList_helpers_1.getInitialState.mockReturnValue(newState);
+        const el = getElement(container);
+        await (0, react_1.act)(() => {
+            react_2.fireEvent.keyDown(el, { code: "KeyA", ctrlKey: true });
+            return Promise.resolve();
+        });
+        expect(reducerSpy).not.toBeCalled();
+        expect(onChangeFn).not.toBeCalled();
+    });
+    test("Test keyboard navigation (another button)", async () => {
+        reducerSpy.mockReturnValue({ ...initialState });
+        selectList_helpers_1.getInitialState.mockReturnValue({ ...initialState });
+        const { container } = (0, react_2.render)((0, jsx_runtime_1.jsx)(selectList_1.SelectList, { title: "Select List", id: "listId", items: items, value: value, multiselect: true }));
+        const newState = { ...initialState, searchStr: "qWe", activeIndex: 2 };
+        selectlistItemSpy.mockClear();
+        reducerSpy.mockClear();
+        reducerSpy.mockReturnValue({ ...newState });
+        selectList_helpers_1.getInitialState.mockReturnValue(newState);
+        const el = getElement(container);
+        await (0, react_1.act)(() => {
+            react_2.fireEvent.keyDown(el, { code: "KeyQ" });
+            return Promise.resolve();
+        });
+        const calls = selectlistItemSpy.mock.calls;
+        expect(calls.length).toBe(1);
+        expect(calls[0][0].focused).toBeTruthy();
+        expect(calls[0][0].id).toBe("a3");
+        expect(reducerSpy).toBeCalledWith(initialState, expect.objectContaining({
+            type: selectList_actionTypes_1.ListAction.SearchItem,
+            payload: expect.objectContaining({ items })
+        }));
+    });
+    test("Test changing list item", async () => {
+        selectlistItemSpy.mockClear();
+        const onChangeFn = jest.fn();
+        reducerSpy.mockReturnValue({ ...initialState });
+        selectList_helpers_1.getInitialState.mockReturnValue({ ...initialState });
+        (0, react_2.render)((0, jsx_runtime_1.jsx)(selectList_1.SelectList, { title: "Select List", id: "listId", items: items, value: value, multiselect: true, onChange: onChangeFn }));
+        reducerSpy.mockClear();
+        reducerSpy.mockReturnValue({ ...initialState, isItemsStateChanged: true, itemsState: new Map([["a1", checkboxState_1.CheckboxState.Off], ["a2", checkboxState_1.CheckboxState.Indeterminate], ["a3", checkboxState_1.CheckboxState.Indeterminate]]) });
+        const onLastItemChange = selectlistItemSpy.mock.calls[2][0].onChange; // Simulate changing last item's state
+        await (0, react_1.act)(() => {
+            onLastItemChange && onLastItemChange("a3", checkboxState_1.CheckboxState.Indeterminate);
+            return Promise.resolve();
+        });
+        expect(reducerSpy).toBeCalledWith(initialState, { type: selectList_actionTypes_1.ListAction.ChangeItemState, payload: { updatedId: "a3", updatedState: checkboxState_1.CheckboxState.Indeterminate, multiselect: true } });
+        expect(onChangeFn).toBeCalledTimes(1);
+        expect(onChangeFn).toBeCalledWith(new Map([["a1", checkboxState_1.CheckboxState.Off], ["a2", checkboxState_1.CheckboxState.Indeterminate], ["a3", checkboxState_1.CheckboxState.Indeterminate]]));
+    });
+    test("Test focus list", async () => {
+        const onChangeFn = jest.fn();
+        reducerSpy.mockReturnValue({ ...initialState });
+        selectList_helpers_1.getInitialState.mockReturnValue({ ...initialState });
+        const { container } = (0, react_2.render)((0, jsx_runtime_1.jsx)(selectList_1.SelectList, { title: "Select List", id: "listId", items: items, value: value, multiselect: true, onChange: onChangeFn }));
+        reducerSpy.mockClear();
+        reducerSpy.mockReturnValue({ ...initialState, searchStr: "" });
+        const el = getElement(container);
+        await (0, react_1.act)(() => {
+            react_2.fireEvent.focus(el);
+            return Promise.resolve();
+        });
+        expect(reducerSpy).toBeCalledWith(initialState, { type: selectList_actionTypes_1.ListAction.Focus, payload: { items, multiselect: true } });
+        expect(onChangeFn).not.toBeCalled();
+    });
+    test("Test blur list", () => {
+        const onChangeFn = jest.fn();
+        reducerSpy.mockReturnValue({ ...initialState });
+        selectList_helpers_1.getInitialState.mockReturnValue({ ...initialState });
+        const { container } = (0, react_2.render)((0, jsx_runtime_1.jsx)(selectList_1.SelectList, { title: "Select List", id: "listId", items: items, value: value, multiselect: true, onChange: onChangeFn }));
+        reducerSpy.mockClear();
+        reducerSpy.mockReturnValue({ ...initialState, searchStr: "" });
+        const el = getElement(container);
+        react_2.fireEvent.blur(el);
+        expect(reducerSpy).toBeCalledWith(initialState, { type: selectList_actionTypes_1.ListAction.Blur, payload: { multiselect: true } });
+        expect(onChangeFn).not.toBeCalled();
+    });
+    test("Test scrolling to current active item", () => {
+        Object.defineProperty(document, "activeElement", {
+            get() { return document.body; },
+            set() { jest.fn(); }
+        });
+        const querySelectorFn = jest.fn().mockReturnValueOnce(document.body).mockReturnValue(null);
+        jest.spyOn(react_1.default, "useRef").mockReturnValue(Object.defineProperty({}, "current", {
+            get() {
+                return {
+                    querySelector: querySelectorFn
+                };
+            },
+            set() { jest.fn(); }
+        }));
+        isChildOf_1.isChildOf.mockReturnValue(true);
+        const newInitialState = { ...initialState, activeIndex: 0 };
+        reducerSpy.mockReturnValue({ ...newInitialState });
+        selectList_helpers_1.getInitialState.mockReturnValue({ ...newInitialState });
+        const { rerender } = (0, react_2.render)((0, jsx_runtime_1.jsx)(selectList_1.SelectList, { title: "Select List", id: "listId", items: items, value: value, multiselect: true }));
+        expect(scrollIntoViewMock).toBeCalled();
+        scrollIntoViewMock.mockClear();
+        rerender((0, jsx_runtime_1.jsx)(selectList_1.SelectList, { title: "Select List", id: "listId", items: items, value: value, multiselect: true }));
+        expect(scrollIntoViewMock).not.toBeCalled();
+    });
+    test("Test PassiveSelectList", () => {
+        const ref = jest.fn();
+        const { container } = (0, react_2.render)((0, jsx_runtime_1.jsx)(selectList_1.PassiveSelectList, { title: "Select List", id: "listId", items: items, ref: ref, value: value, size: 2 }));
+        const el = getElement(container);
+        expect(el.tabIndex).toBe(-1);
+        expect(el.getAttribute("aria-activedescendant")).toBeFalsy();
+        expect(el.style.height).toBe("");
+        expect(el.getAttribute("aria-disabled")).toBeNull();
+    });
+    test("Test disabled PassiveSelectList", () => {
+        const ref = jest.fn();
+        const { container } = (0, react_2.render)((0, jsx_runtime_1.jsx)(selectList_1.PassiveSelectList, { title: "Select List", id: "listId", items: items, ref: ref, value: value, size: 2, disabled: true }));
+        const el = getElement(container);
+        expect(el.tabIndex).toBe(-1);
+        expect(el.getAttribute("aria-disabled")).toBe("true");
+    });
+    test("Test selectList accessibility", async () => {
+        (selectlistItemSpy).mockImplementation(((args) => (0, jsx_runtime_1.jsx)("li", { id: args.id, role: "option", "aria-disabled": args.disabled, children: args.children })));
+        reducerSpy.mockReturnValue({ ...initialState });
+        selectList_helpers_1.getInitialState.mockReturnValue({ ...initialState });
+        const { container } = (0, react_2.render)((0, jsx_runtime_1.jsx)(selectList_1.SelectList, { title: "Select List", id: "listId", items: items, value: value }));
+        await expect(getElement(container)).toBeAccessible();
+    }, 10000);
+    test("Test PassiveSelectList accessibility", async () => {
+        const { container } = (0, react_2.render)((0, jsx_runtime_1.jsx)(selectList_1.PassiveSelectList, { title: "Select List", id: "listId", items: items, value: value, multiselect: true }));
+        await expect(getElement(container)).toBeAccessible();
+    }, 10000);
+    test("Test disable selectList accessibility", async () => {
+        (selectlistItemSpy).mockImplementation(((args) => (0, jsx_runtime_1.jsx)("li", { id: args.id, role: "option", "aria-disabled": args.disabled, children: args.children })));
+        reducerSpy.mockReturnValue({ ...initialState });
+        selectList_helpers_1.getInitialState.mockReturnValue({ ...initialState });
+        const { container } = (0, react_2.render)((0, jsx_runtime_1.jsx)(selectList_1.SelectList, { title: "Select List", id: "listId", items: items, value: value, disabled: true }));
+        await expect(getElement(container)).toBeAccessible();
+    }, 10000);
+    test("Test disabled PassiveSelectList accessibility", async () => {
+        const { container } = (0, react_2.render)((0, jsx_runtime_1.jsx)(selectList_1.PassiveSelectList, { title: "Select List", id: "listId", items: items, value: value, multiselect: true, disabled: true }));
+        await expect(getElement(container)).toBeAccessible();
+    }, 10000);
+});
+//# sourceMappingURL=selectList.test.js.map