Skip to content

A local-first personal finance app

[AI] Fix transaction row context-menu listener rebinding on every render (#8606)

youngcw7a67eff1e026
diff --git a/packages/desktop-client/src/hooks/useContextMenu.ts b/packages/desktop-client/src/hooks/useContextMenu.ts
index 759f3a7005..70e480b172 100644
--- a/packages/desktop-client/src/hooks/useContextMenu.ts
+++ b/packages/desktop-client/src/hooks/useContextMenu.ts
@@ -1,4 +1,4 @@
-import { useCallback, useRef } from 'react';
+import { useCallback } from 'react';
import type { RefObject } from 'react';
import type { Falsy } from '@actual-app/core/types/util';
@@ -24,10 +24,6 @@ export function useContextMenu({
}: UseContextMenuProps) {
const dispatch = useDispatch();
- // Store actions in a ref to avoid re-binding the event listener on every render
- const actionsRef = useRef(items);
- actionsRef.current = items;
-
const processedItems = items.filter(
item => item && (typeof item === 'symbol' || !item.hidden),
) as ContextMenuItem[];
diff --git a/packages/desktop-client/src/hooks/useRefEventListener.test.ts b/packages/desktop-client/src/hooks/useRefEventListener.test.ts
new file mode 100644
index 0000000000..2cee4f1114
--- /dev/null
+++ b/packages/desktop-client/src/hooks/useRefEventListener.test.ts
@@ -0,0 +1,97 @@
+import type { RefObject } from 'react';
+
+import { renderHook } from '@testing-library/react';
+import { describe, expect, it, vi } from 'vitest';
+
+import { useRefEventListener } from './useRefEventListener';
+
+describe('useRefEventListener', () => {
+ function makeMockElement() {
+ return {
+ addEventListener: vi.fn(),
+ removeEventListener: vi.fn(),
+ };
+ }
+
+ it('registers the listener once on mount', () => {
+ const el = makeMockElement();
+ const ref = { current: el } as unknown as RefObject<HTMLElement | null>;
+
+ renderHook(() => useRefEventListener(ref, 'click', vi.fn()));
+
+ expect(el.addEventListener).toHaveBeenCalledTimes(1);
+ expect(el.addEventListener).toHaveBeenCalledWith(
+ 'click',
+ expect.any(Function),
+ );
+ });
+
+ it('does not re-bind the native listener when only the callback identity changes', () => {
+ const el = makeMockElement();
+ const ref = { current: el } as unknown as RefObject<HTMLElement | null>;
+
+ const { rerender } = renderHook(
+ ({ callback }) => useRefEventListener(ref, 'click', callback),
+ { initialProps: { callback: vi.fn() } },
+ );
+
+ expect(el.addEventListener).toHaveBeenCalledTimes(1);
+ expect(el.removeEventListener).not.toHaveBeenCalled();
+
+ // Simulate a caller passing a brand-new inline function every render.
+ rerender({ callback: vi.fn() });
+ rerender({ callback: vi.fn() });
+
+ expect(el.addEventListener).toHaveBeenCalledTimes(1);
+ expect(el.removeEventListener).not.toHaveBeenCalled();
+ });
+
+ it('always invokes the latest callback, even after a re-render', () => {
+ const el = makeMockElement();
+ const ref = { current: el } as unknown as RefObject<HTMLElement | null>;
+ const firstCallback = vi.fn();
+ const secondCallback = vi.fn();
+
+ const { rerender } = renderHook(
+ ({ callback }) => useRefEventListener(ref, 'click', callback),
+ { initialProps: { callback: firstCallback } },
+ );
+
+ rerender({ callback: secondCallback });
+
+ const registeredListener = el.addEventListener.mock.calls[0][1];
+ const event = { type: 'click' };
+ registeredListener(event);
+
+ expect(firstCallback).not.toHaveBeenCalled();
+ expect(secondCallback).toHaveBeenCalledWith(event);
+ });
+
+ it('rebinds when the event name changes', () => {
+ const el = makeMockElement();
+ const ref = { current: el } as unknown as RefObject<HTMLElement | null>;
+
+ const { rerender } = renderHook<void, { event: 'click' | 'keyup' }>(
+ ({ event }) => useRefEventListener(ref, event, vi.fn()),
+ { initialProps: { event: 'click' } },
+ );
+
+ rerender({ event: 'keyup' });
+
+ expect(el.addEventListener).toHaveBeenCalledTimes(2);
+ expect(el.removeEventListener).toHaveBeenCalledTimes(1);
+ });
+
+ it('removes the listener on unmount', () => {
+ const el = makeMockElement();
+ const ref = { current: el } as unknown as RefObject<HTMLElement | null>;
+
+ const { unmount } = renderHook(() =>
+ useRefEventListener(ref, 'click', vi.fn()),
+ );
+
+ unmount();
+
+ expect(el.removeEventListener).toHaveBeenCalledTimes(1);
+ });
+});
diff --git a/packages/desktop-client/src/hooks/useRefEventListener.ts b/packages/desktop-client/src/hooks/useRefEventListener.ts
index 684c5d3266..36c6c0bc3f 100644
--- a/packages/desktop-client/src/hooks/useRefEventListener.ts
+++ b/packages/desktop-client/src/hooks/useRefEventListener.ts
@@ -1,4 +1,4 @@
-import { useEffect } from 'react';
+import { useEffect, useRef } from 'react';
import type { RefObject } from 'react';
export function useRefEventListener<
@@ -10,16 +10,26 @@ export function useRefEventListener<
// oxlint-disable-next-line typescript/no-explicit-any
callback: (this: ElementType, ev: HTMLElementEventMap[EventType]) => any,
) {
- // oxlint-disable-next-line eslint-plugin-react-hooks/exhaustive-deps
+ // Keep the latest callback in a ref so the effect below doesn't need to
+ // depend on it. Callers routinely pass a new inline function every render,
+ // which would otherwise tear down and re-add the native listener on every
+ // render instead of only when `ref`/`event` change.
+ const callbackRef = useRef(callback);
+ callbackRef.current = callback;
+
useEffect(() => {
const el =
ref instanceof Document || ref instanceof Window ? ref : ref.current;
if (!el) return;
- const callbackRef = callback as EventListener; // closure?
- el.addEventListener(event, callbackRef);
+ const listener: EventListener = e =>
+ callbackRef.current.call(
+ el as ElementType,
+ e as HTMLElementEventMap[EventType],
+ );
+ el.addEventListener(event, listener);
return () => {
- el.removeEventListener(event, callbackRef);
+ el.removeEventListener(event, listener);
};
- }, [ref, event, callback]);
+ }, [ref, event]);
}
diff --git a/upcoming-release-notes/fix-slow-transaction-context-menu-listener.md b/upcoming-release-notes/fix-slow-transaction-context-menu-listener.md
new file mode 100644
index 0000000000..67d171757b
--- /dev/null
+++ b/upcoming-release-notes/fix-slow-transaction-context-menu-listener.md
@@ -0,0 +1,6 @@
+---
+category: Maintenance
+authors: [youngcw]
+---
+
+Prevent context menu listeners from rebinding every render