Skip to content

Build your personal knowledge base with Trilium Notes

test(menu): cover the keys and options the menus and lists handle at their edges

Elian Doran494bfb9855d2
diff --git a/apps/client/src/widgets/react/Dropdown.spec.tsx b/apps/client/src/widgets/react/Dropdown.spec.tsx
index 5d3e181fba..17e5a0fbae 100644
--- a/apps/client/src/widgets/react/Dropdown.spec.tsx
+++ b/apps/client/src/widgets/react/Dropdown.spec.tsx
@@ -170,6 +170,50 @@ describe("Dropdown", () => {
await vi.waitFor(() => expect(popup()).toBeNull());
});
+ it("closes only on a click inside, or on neither, when asked to", async () => {
+ const outside = () => document.body.dispatchEvent(new PointerEvent("pointerdown", { bubbles: true }));
+ // A close is rendered after the fact, so a popup still there is checked a turn later.
+ const settle = () => new Promise((resolve) => setTimeout(resolve));
+ const { toggle } = renderDropdown({ autoClose: "inside" }, items);
+ click(toggle);
+ await vi.waitFor(() => expect(popup()).not.toBeNull());
+ outside();
+ await settle();
+ expect(popup()).not.toBeNull();
+ item("By title").click();
+ await vi.waitFor(() => expect(popup()).toBeNull());
+ render(null, host);
+
+ const { toggle: manual } = renderDropdown({ autoClose: false }, items);
+ click(manual);
+ await vi.waitFor(() => expect(popup()).not.toBeNull());
+ outside();
+ item("By title").click();
+ await settle();
+ expect(popup()).not.toBeNull();
+ // Escape and the toggle still close it.
+ popup()?.dispatchEvent(new KeyboardEvent("keydown", { key: "Escape", bubbles: true }));
+ await vi.waitFor(() => expect(popup()).toBeNull());
+ });
+
+ it("opens at its last item on Up from the toggle, and moves in from the toggle while open", async () => {
+ const { toggle } = renderDropdown({ panel: true }, items);
+ const key = (name: string) =>
+ toggle.dispatchEvent(new KeyboardEvent("keydown", { key: name, bubbles: true, cancelable: true }));
+
+ // Other keys are the toggle's own.
+ expect(key("a")).toBe(true);
+ expect(popup()).toBeNull();
+
+ toggle.focus();
+ key("ArrowUp");
+ await vi.waitFor(() => expect(document.activeElement?.textContent).toBe("By date"));
+
+ toggle.focus();
+ key("ArrowDown");
+ expect(document.activeElement?.textContent).toBe("By title");
+ });
+
it("opens above its toggle when asked to", async () => {
const { toggle } = renderDropdown({ placement: "top" });
vi.spyOn(toggle, "getBoundingClientRect").mockReturnValue(DOMRect.fromRect({ x: 100, y: 500, width: 80, height: 30 }));
diff --git a/apps/client/src/widgets/react/FormList.spec.tsx b/apps/client/src/widgets/react/FormList.spec.tsx
index 416985ef30..edea7d921d 100644
--- a/apps/client/src/widgets/react/FormList.spec.tsx
+++ b/apps/client/src/widgets/react/FormList.spec.tsx
@@ -6,7 +6,13 @@ vi.mock("bootstrap", () => ({
Tooltip: class { static getInstance() { return null; } }
}));
-import FormList, { FormDropdownDivider, FormDropdownSubmenu, FormListCustomItem, FormListHeader, FormListItem } from "./FormList";
+const help = vi.hoisted(() => ({ open: vi.fn() }));
+vi.mock("../../services/utils", async (importOriginal) => ({
+ ...(await importOriginal<typeof import("../../services/utils")>()),
+ openInAppHelpFromUrl: help.open
+}));
+
+import FormList, { focusListItem, FormDropdownDivider, FormDropdownSubmenu, FormListCustomItem, FormListHeader, FormListItem, FormListToggleableItem } from "./FormList";
describe("FormDropdownDivider", () => {
it("draws a separator among the rows, whose click closes no menu", () => {
@@ -150,6 +156,90 @@ describe("FormDropdownSubmenu", () => {
});
});
+describe("focusListItem", () => {
+ /** A list of three items, the middle one disabled, the last holding a nested list of its own. */
+ function list() {
+ const root = document.createElement("ul");
+ root.className = "dropdown-menu";
+ root.innerHTML = `
+ <li class="dropdown-item" tabindex="0">A</li>
+ <li class="dropdown-item disabled" tabindex="0">B</li>
+ <li class="dropdown-item" tabindex="0">C<ul class="dropdown-menu"><li class="dropdown-item" tabindex="0">Nested</li></ul></li>`;
+ document.body.append(root);
+ return root;
+ }
+ const focused = () => document.activeElement?.firstChild?.textContent;
+
+ it("focuses the list's own enabled items, from either end when none is current", () => {
+ const root = list();
+ focusListItem(root, "last");
+ expect(focused()).toBe("C");
+ focusListItem(root, "first");
+ expect(focused()).toBe("A");
+ focusListItem(root, "previous");
+ expect(focused()).toBe("C");
+ focusListItem(root, "next");
+ expect(focused()).toBe("A");
+ root.remove();
+ });
+
+ it("leaves focus alone in a list with no enabled item", () => {
+ const root = document.createElement("ul");
+ root.innerHTML = `<li class="dropdown-item disabled" tabindex="0">B</li>`;
+ document.body.append(root);
+ const before = document.activeElement;
+ focusListItem(root, "first");
+ expect(document.activeElement).toBe(before);
+ root.remove();
+ });
+});
+
+describe("FormListToggleableItem", () => {
+ function mountToggle(props: { onChange(value: boolean): void | Promise<void>, disabled?: boolean }) {
+ const pageHeard = vi.fn();
+ const container = mount(
+ <menu onClick={pageHeard}>
+ <FormListToggleableItem title="Shared" currentValue={false} helpPage="R9pX4DGra2Vt" {...props} />
+ </menu>
+ );
+ const row = container.querySelector<HTMLElement>("li.dropdown-item");
+ if (!row) throw new Error("expected the row");
+ return { row, pageHeard };
+ }
+
+ it("flips its value once per click, ignoring clicks while the change is still running", async () => {
+ let finish = () => {};
+ const onChange = vi.fn(() => new Promise<void>((resolve) => finish = resolve));
+ const { row, pageHeard } = mountToggle({ onChange });
+
+ row.click();
+ row.click();
+ expect(onChange).toHaveBeenCalledExactlyOnceWith(true);
+ // A menu around it stays open.
+ expect(pageHeard).not.toHaveBeenCalled();
+
+ finish();
+ await vi.waitFor(() => {
+ row.click();
+ expect(onChange).toHaveBeenCalledTimes(2);
+ });
+ });
+
+ it("does not change when disabled, and opens its help page without changing", () => {
+ const onChange = vi.fn();
+ const { row } = mountToggle({ onChange, disabled: true });
+ row.click();
+ expect(onChange).not.toHaveBeenCalled();
+
+ const { row: enabled } = mountToggle({ onChange });
+ const helpIcon = enabled.querySelector<HTMLElement>(".contextual-help");
+ if (!helpIcon) throw new Error("expected the help icon");
+ helpIcon.click();
+ expect(help.open).toHaveBeenCalledExactlyOnceWith("R9pX4DGra2Vt");
+ expect(onChange).not.toHaveBeenCalled();
+ });
+});
+
describe("FormList keyboard activation", () => {
it.each([ "Enter", " " ])("activates the focused item on %j like a click", (key) => {
const { container, onSelect } = renderList();
@@ -195,6 +285,22 @@ describe("FormList keyboard activation", () => {
expect(event.defaultPrevented).toBe(false);
});
+ it("leaves Enter on a control inside an item to that control", () => {
+ const onSelect = vi.fn();
+ const container = mount(
+ <FormList onSelect={onSelect}>
+ <FormListItem value="text"><button className="inner-action">Edit</button> Text</FormListItem>
+ </FormList>
+ );
+ const button = container.querySelector<HTMLButtonElement>(".inner-action");
+ if (!button) throw new Error("expected the inner button");
+
+ const event = press(button, "Enter");
+
+ expect(onSelect).not.toHaveBeenCalled();
+ expect(event.defaultPrevented).toBe(false);
+ });
+
it("moves focus over enabled items with Up and Down, stopping the keys", () => {
const container = mount(
<FormList>
diff --git a/apps/client/src/widgets/react/Menu.spec.tsx b/apps/client/src/widgets/react/Menu.spec.tsx
index fdd2cef8aa..296a49f758 100644
--- a/apps/client/src/widgets/react/Menu.spec.tsx
+++ b/apps/client/src/widgets/react/Menu.spec.tsx
@@ -2,7 +2,7 @@ import { render } from "preact";
import { afterEach, describe, expect, it, vi } from "vitest";
import { FormDropdownDivider, FormDropdownSubmenu, FormListHeader, FormListItem } from "./FormList";
-import Menu, { rowInNextColumn } from "./Menu";
+import Menu, { type MenuProps, rowInNextColumn } from "./Menu";
import { shouldDropStart } from "./menu_context";
/** A row 20px tall, `left` into the menu and `top` down it. */
@@ -71,7 +71,7 @@ describe("Menu with declared rows", () => {
* A menu written as components, with a submenu declared inside a component of its own, as the
* global menu declares its "Advanced" submenu.
*/
- function renderMenu() {
+ function renderMenu(props: Partial<MenuProps<unknown>> = {}) {
const calls: string[] = [];
const onClose = vi.fn(() => calls.push("close"));
function Advanced() {
@@ -83,7 +83,7 @@ describe("Menu with declared rows", () => {
);
}
render((
- <Menu anchor={{ x: 10, y: 10 }} onClose={onClose}>
+ <Menu anchor={{ x: 10, y: 10 }} onClose={onClose} {...props}>
<FormListHeader text="Note" />
<FormListItem onClick={() => calls.push("copy")}>Copy</FormListItem>
<FormListItem disabled onClick={() => calls.push("delete")}>Delete</FormListItem>
@@ -115,8 +115,9 @@ describe("Menu with declared rows", () => {
element.dispatchEvent(new MouseEvent("mousedown", { bubbles: true, cancelable: true, button: 0 }));
element.dispatchEvent(new MouseEvent("click", { bubbles: true, cancelable: true, button: 0 }));
};
- const key = (menu: HTMLElement, name: string) =>
- menu.dispatchEvent(new KeyboardEvent("keydown", { key: name, bubbles: true, cancelable: true }));
+ const key = (menu: HTMLElement, name: string, init: KeyboardEventInit = {}) =>
+ menu.dispatchEvent(new KeyboardEvent("keydown", { key: name, bubbles: true, cancelable: true, ...init }));
+ const activeTitle = (menu: HTMLElement) => menu.querySelector(".tn-menu-active > span")?.textContent;
it("draws the rows it is given in order, and opens a declared submenu as a layer beside the scroller", async () => {
const { menu, calls } = renderMenu();
@@ -175,6 +176,69 @@ describe("Menu with declared rows", () => {
expect(calls).toEqual([ "log", "close" ]);
});
+ it("does nothing with the keys that have nothing to act on", async () => {
+ const { menu, calls, onClose } = renderMenu();
+
+ // No row is active yet, so Enter runs nothing.
+ key(menu, "Enter");
+ // A letter with a modifier is a shortcut, not typeahead, and is left to the page.
+ expect(key(menu, "c", { ctrlKey: true })).toBe(true);
+ expect(activeTitle(menu)).toBeUndefined();
+
+ // Up with no active row goes to the last row that can run.
+ key(menu, "ArrowUp");
+ await vi.waitFor(() => expect(activeTitle(menu)).toBe("Advanced"));
+ // Left at the top level has no submenu to leave.
+ key(menu, "ArrowLeft");
+ // Tab keeps focus in the menu.
+ expect(key(menu, "Tab")).toBe(false);
+ expect(activeTitle(menu)).toBe("Advanced");
+ expect(layers(menu)).toEqual([]);
+ expect(calls).toEqual([]);
+ expect(onClose).not.toHaveBeenCalled();
+ });
+
+ it("starts at the last row when asked to, and takes no focus once it is no longer wanted", async () => {
+ const { menu } = renderMenu({ startAt: "last" });
+ await vi.waitFor(() => expect(activeTitle(menu)).toBe("Advanced"));
+ expect(document.activeElement).toBe(menu);
+ render(null, host);
+
+ const { menu: unwanted } = renderMenu({ startAt: "first", isWanted: () => false });
+ await vi.waitFor(() => expect(unwanted.style.visibility).toBe("visible"));
+ expect(document.activeElement).not.toBe(unwanted);
+ expect(activeTitle(unwanted)).toBeUndefined();
+ });
+
+ it("neither opens nor runs a disabled submenu row", async () => {
+ const toggled = vi.fn();
+ render((
+ <Menu anchor={{ x: 10, y: 10 }} onClose={vi.fn()}>
+ <FormListItem>Copy</FormListItem>
+ <FormDropdownSubmenu title="Export" icon="bx bx-export" disabled onDropdownToggleClicked={toggled}>
+ <FormListItem>As PDF</FormListItem>
+ </FormDropdownSubmenu>
+ </Menu>
+ ), host);
+ const menu = document.querySelector<HTMLElement>(".tn-popup.tn-menu");
+ if (!menu) throw new Error("expected the menu to render");
+ const exportRow = rowTitled("Export");
+ expect(exportRow.getAttribute("aria-disabled")).toBe("true");
+
+ exportRow.dispatchEvent(new PointerEvent("pointerenter"));
+ press(exportRow);
+ // Anything opened is rendered after the fact, so the layers are checked a turn later.
+ await new Promise((resolve) => setTimeout(resolve));
+ expect(layers(menu)).toEqual([]);
+ expect(toggled).not.toHaveBeenCalled();
+
+ // The keys pass over it.
+ key(menu, "ArrowDown");
+ await vi.waitFor(() => expect(activeTitle(menu)).toBe("Copy"));
+ key(menu, "ArrowDown");
+ expect(activeTitle(menu)).toBe("Copy");
+ });
+
it("opens submenus towards the start, arrows too, when the end has no room", async () => {
// The menus and their rows are 120px wide, at the right edge of a 1024px viewport.
vi.spyOn(document.documentElement, "clientWidth", "get").mockReturnValue(1024);