mirror of
https://github.com/binaricat/Netcatty.git
synced 2026-11-16 20:11:08 +00:00
* Fix select before connect in host collections * ci: retrigger lint-and-test (notes persistence flake unrelated to #4042) * chore: retrigger CI after unrelated NotesManager.persistence flake
210 lines
6.8 KiB
TypeScript
210 lines
6.8 KiB
TypeScript
import assert from "node:assert/strict";
|
|
import test from "node:test";
|
|
import React from "react";
|
|
import { renderToStaticMarkup } from "react-dom/server";
|
|
|
|
import {
|
|
getNextRaggedRowPosition,
|
|
getNextVirtualHostIndex,
|
|
resolveVirtualFocusRequest,
|
|
shouldApplyVirtualHostDomFocus,
|
|
VirtualizedGroupedHostCollection,
|
|
VirtualizedHostCollection,
|
|
} from "./VirtualizedHostCollection.tsx";
|
|
import { getVaultHostGridColumnCount } from "./vaultHostGridLayout.ts";
|
|
|
|
test("virtual focus retries when an active item enters a collection", () => {
|
|
assert.deepEqual(resolveVirtualFocusRequest({
|
|
activeItemKey: "host-1",
|
|
lastRequestedKey: "host-1",
|
|
itemIndexByKey: new Map(),
|
|
}), { status: "missing" });
|
|
|
|
assert.deepEqual(resolveVirtualFocusRequest({
|
|
activeItemKey: "host-1",
|
|
lastRequestedKey: null,
|
|
itemIndexByKey: new Map([["host-1", 3]]),
|
|
}), { status: "request", key: "host-1", index: 3 });
|
|
});
|
|
|
|
test("virtual host DOM focus does not steal from outside controls", () => {
|
|
const inside = { tagName: "BUTTON" } as unknown as Element;
|
|
const searchInput = { tagName: "INPUT" } as unknown as Element;
|
|
const body = { tagName: "BODY" } as unknown as Element;
|
|
const collectionRoot = {
|
|
contains(node: Node) {
|
|
return node === inside;
|
|
},
|
|
};
|
|
|
|
assert.equal(shouldApplyVirtualHostDomFocus({
|
|
collectionRoot,
|
|
activeElement: inside,
|
|
}), true);
|
|
assert.equal(shouldApplyVirtualHostDomFocus({
|
|
collectionRoot,
|
|
activeElement: searchInput,
|
|
}), false);
|
|
assert.equal(shouldApplyVirtualHostDomFocus({
|
|
collectionRoot,
|
|
activeElement: body,
|
|
}), true);
|
|
assert.equal(shouldApplyVirtualHostDomFocus({
|
|
collectionRoot: null,
|
|
activeElement: inside,
|
|
}), false);
|
|
});
|
|
|
|
test("host grids use the same fixed card-width column calculation", () => {
|
|
assert.equal(getVaultHostGridColumnCount(219), 1);
|
|
assert.equal(getVaultHostGridColumnCount(452), 2);
|
|
assert.equal(getVaultHostGridColumnCount(684), 3);
|
|
assert.equal(getVaultHostGridColumnCount(916), 4);
|
|
assert.equal(getVaultHostGridColumnCount(1600), 4);
|
|
});
|
|
|
|
test("virtualized host keyboard navigation crosses rows and collection edges", () => {
|
|
assert.equal(getNextVirtualHostIndex({
|
|
currentIndex: 1,
|
|
itemCount: 20,
|
|
columns: 4,
|
|
viewMode: "grid",
|
|
key: "ArrowDown",
|
|
}), 5);
|
|
assert.equal(getNextVirtualHostIndex({
|
|
currentIndex: 5,
|
|
itemCount: 20,
|
|
columns: 4,
|
|
viewMode: "grid",
|
|
key: "ArrowLeft",
|
|
}), 4);
|
|
assert.equal(getNextVirtualHostIndex({
|
|
currentIndex: 18,
|
|
itemCount: 20,
|
|
columns: 4,
|
|
viewMode: "list",
|
|
key: "End",
|
|
}), 19);
|
|
assert.equal(getNextVirtualHostIndex({
|
|
currentIndex: 0,
|
|
itemCount: 20,
|
|
columns: 1,
|
|
viewMode: "list",
|
|
key: "ArrowUp",
|
|
}), 0);
|
|
});
|
|
|
|
test("grouped grid navigation preserves the actual column across ragged rows", () => {
|
|
assert.deepEqual(getNextRaggedRowPosition({
|
|
rowLengths: [1, 3, 3],
|
|
currentRow: 0,
|
|
currentColumn: 0,
|
|
direction: 1,
|
|
}), { row: 1, column: 0 });
|
|
assert.deepEqual(getNextRaggedRowPosition({
|
|
rowLengths: [3, 1, 3],
|
|
currentRow: 0,
|
|
currentColumn: 2,
|
|
direction: 1,
|
|
}), { row: 1, column: 0 });
|
|
});
|
|
|
|
test("virtualized host grid renders only the viewport window for a large collection", () => {
|
|
const items = Array.from({ length: 8000 }, (_, index) => ({ id: `host-${index}` }));
|
|
const html = renderToStaticMarkup(
|
|
<VirtualizedHostCollection
|
|
items={items}
|
|
itemKey={(item) => item.id}
|
|
scrollRef={React.createRef<HTMLDivElement>()}
|
|
viewMode="grid"
|
|
ariaLabel="Hosts"
|
|
renderItem={(item) => <div data-host-id={item.id} />}
|
|
/>,
|
|
);
|
|
|
|
const renderedHosts = (html.match(/data-host-id=/g) ?? []).length;
|
|
assert.ok(renderedHosts > 0);
|
|
assert.ok(renderedHosts < 100);
|
|
assert.match(html, /data-vault-virtual-row=/);
|
|
assert.match(html, /role="grid"/);
|
|
assert.match(html, /aria-rowcount="2000"/);
|
|
assert.match(html, /role="gridcell"/);
|
|
});
|
|
|
|
test("virtualized host list keeps one fixed-height item per row", () => {
|
|
const items = Array.from({ length: 8000 }, (_, index) => ({ id: `host-${index}` }));
|
|
const html = renderToStaticMarkup(
|
|
<VirtualizedHostCollection
|
|
items={items}
|
|
itemKey={(item) => item.id}
|
|
scrollRef={React.createRef<HTMLDivElement>()}
|
|
viewMode="list"
|
|
ariaLabel="Hosts"
|
|
renderItem={(item) => <div data-host-id={item.id} />}
|
|
/>,
|
|
);
|
|
|
|
const renderedHosts = (html.match(/data-host-id=/g) ?? []).length;
|
|
assert.ok(renderedHosts > 0);
|
|
assert.ok(renderedHosts < 40);
|
|
assert.match(html, /grid-template-columns:repeat\(1, minmax\(0, 1fr\)\)/);
|
|
assert.match(html, /role="list"/);
|
|
assert.match(html, /aria-setsize="8000"/);
|
|
});
|
|
|
|
test("grouped host grid uses one virtual window across every group", () => {
|
|
const groups = Array.from({ length: 80 }, (_, groupIndex) => ({
|
|
name: `group-${groupIndex}`,
|
|
hosts: Array.from({ length: 100 }, (_, hostIndex) => ({
|
|
id: `host-${groupIndex}-${hostIndex}`,
|
|
})),
|
|
}));
|
|
const html = renderToStaticMarkup(
|
|
<VirtualizedGroupedHostCollection
|
|
groups={groups}
|
|
itemKey={(item) => item.id}
|
|
scrollRef={React.createRef<HTMLDivElement>()}
|
|
viewMode="grid"
|
|
ariaLabel="Hosts"
|
|
renderGroupHeader={(group) => <div data-group-name={group.name} />}
|
|
renderItem={(item) => <div data-host-id={item.id} />}
|
|
/>,
|
|
);
|
|
|
|
const renderedHosts = (html.match(/data-host-id=/g) ?? []).length;
|
|
assert.ok(renderedHosts > 0);
|
|
assert.ok(renderedHosts < 100);
|
|
assert.equal((html.match(/data-vault-virtual-grouped-collection=/g) ?? []).length, 1);
|
|
});
|
|
|
|
test("pointer focus does not preselect hosts in either collection", async () => {
|
|
const { act, create } = await import("react-test-renderer");
|
|
const items = [{ id: "one" }, { id: "two" }];
|
|
for (const grouped of [false, true]) {
|
|
const selected: string[] = [];
|
|
const common = {
|
|
itemKey: (item: { id: string }) => item.id,
|
|
scrollRef: React.createRef<HTMLDivElement>(),
|
|
viewMode: "list" as const,
|
|
onActiveItemChange: (item: { id: string }) => selected.push(item.id),
|
|
renderItem: (item: { id: string }) => <div>{item.id}</div>,
|
|
};
|
|
let renderer: ReturnType<typeof create>;
|
|
await act(() => {
|
|
renderer = create(grouped
|
|
? <VirtualizedGroupedHostCollection {...common} groups={[{ name: "group", hosts: items }]} renderGroupHeader={() => null} />
|
|
: <VirtualizedHostCollection {...common} items={items} />);
|
|
});
|
|
const root = renderer!.root.find((node) => Boolean(node.props.onFocusCapture));
|
|
const target = { closest: () => ({ dataset: { vaultItemKey: "one" } }) };
|
|
await act(() => {
|
|
root.props.onPointerDownCapture();
|
|
root.props.onFocusCapture({ target });
|
|
});
|
|
assert.deepEqual(selected, []);
|
|
await act(() => { root.props.onFocusCapture({ target }); });
|
|
assert.deepEqual(selected, ["one"]);
|
|
await act(() => { renderer!.unmount(); });
|
|
}
|
|
});
|