Skip to content

A local-first personal finance app

fix: keep loading off-screen dashboard widgets after toggling edit mode (#9056)

Mohammed Yasin Zuhayra74830ff8b2e
diff --git a/packages/desktop-client/src/components/reports/ReportCard.test.tsx b/packages/desktop-client/src/components/reports/ReportCard.test.tsx
new file mode 100644
index 0000000000..074d260d57
--- /dev/null
+++ b/packages/desktop-client/src/components/reports/ReportCard.test.tsx
@@ -0,0 +1,111 @@
+import React from 'react';
+import { MemoryRouter } from 'react-router';
+
+import { act, render, screen } from '@testing-library/react';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+
+import { TestProviders } from '#mocks';
+
+import { ReportCard } from './ReportCard';
+
+type IntersectionCallback = (
+ entries: Array<Pick<IntersectionObserverEntry, 'isIntersecting' | 'target'>>,
+) => void;
+
+let observers: IntersectionObserverStub[] = [];
+
+// jsdom doesn't implement IntersectionObserver. This stub records what is
+// observed so a test can simulate the observed elements scrolling into view.
+class IntersectionObserverStub {
+ callback: IntersectionCallback;
+ observed: Element[] = [];
+ isDisconnected = false;
+
+ constructor(callback: IntersectionCallback) {
+ this.callback = callback;
+ observers.push(this);
+ }
+
+ observe(element: Element) {
+ this.observed.push(element);
+ }
+
+ unobserve() {
+ // no-op
+ }
+
+ disconnect() {
+ this.isDisconnected = true;
+ }
+}
+
+// Like a real IntersectionObserver, only elements that are still in the
+// document can intersect the viewport.
+function scrollCardsIntoView() {
+ act(() => {
+ observers
+ .filter(observer => !observer.isDisconnected)
+ .forEach(observer => {
+ const targets = observer.observed.filter(
+ element => element.isConnected,
+ );
+ if (targets.length > 0) {
+ observer.callback(
+ targets.map(target => ({ isIntersecting: true, target })),
+ );
+ }
+ });
+ });
+}
+
+function renderCard(isEditing: boolean) {
+ return (
+ <TestProviders>
+ <MemoryRouter>
+ <ReportCard
+ widgetId="widget-1"
+ to="/reports/net-worth/widget-1"
+ isEditing={isEditing}
+ >
+ <span>Widget content</span>
+ </ReportCard>
+ </MemoryRouter>
+ </TestProviders>
+ );
+}
+
+describe('ReportCard', () => {
+ beforeEach(() => {
+ observers = [];
+ vi.stubGlobal('IntersectionObserver', IntersectionObserverStub);
+ });
+
+ afterEach(() => {
+ vi.unstubAllGlobals();
+ });
+
+ it('renders its content once the card scrolls into view', () => {
+ render(renderCard(false));
+
+ expect(screen.queryByText('Widget content')).not.toBeInTheDocument();
+
+ scrollCardsIntoView();
+
+ expect(screen.getByText('Widget content')).toBeInTheDocument();
+ });
+
+ it('keeps loading off-screen cards after edit mode is toggled', () => {
+ const { rerender } = render(renderCard(false));
+
+ // Enter edit mode before the card has scrolled into view.
+ rerender(renderCard(true));
+ scrollCardsIntoView();
+
+ expect(screen.getByText('Widget content')).toBeInTheDocument();
+
+ // Finishing editing keeps the loaded content.
+ rerender(renderCard(false));
+
+ expect(screen.getByText('Widget content')).toBeInTheDocument();
+ });
+});
diff --git a/packages/desktop-client/src/components/reports/ReportCard.tsx b/packages/desktop-client/src/components/reports/ReportCard.tsx
index fa3b8c9316..cbec1b11c5 100644
--- a/packages/desktop-client/src/components/reports/ReportCard.tsx
+++ b/packages/desktop-client/src/components/reports/ReportCard.tsx
@@ -43,8 +43,11 @@ export function ReportCard({
onRename,
contextMenuTriggerRef,
}: ReportCardProps) {
- const ref = useRef(null);
- const isInViewport = useIsInViewport(ref);
+ // The card element is tracked as state (through a callback ref) so the
+ // viewport observer follows it when it is remounted, which happens when
+ // toggling edit mode swaps the clickable wrapper in and out.
+ const [cardElement, setCardElement] = useState<HTMLDivElement | null>(null);
+ const isInViewport = useIsInViewport(cardElement);
const [hasRendered, setHasRendered] = useState(false);
const navigate = useNavigate();
const { isNarrowWidth } = useResponsive();
@@ -67,7 +70,7 @@ export function ReportCard({
const content = (
<View
- ref={ref}
+ ref={setCardElement}
style={{
backgroundColor: theme.tableBackground,
borderBottomLeftRadius: 2,
diff --git a/packages/desktop-client/src/hooks/useIsInViewport.test.ts b/packages/desktop-client/src/hooks/useIsInViewport.test.ts
new file mode 100644
index 0000000000..bd64f08e13
--- /dev/null
+++ b/packages/desktop-client/src/hooks/useIsInViewport.test.ts
@@ -0,0 +1,99 @@
+import { act, renderHook } from '@testing-library/react';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+
+import { useIsInViewport } from './useIsInViewport';
+
+type IntersectionCallback = (
+ entries: Array<Pick<IntersectionObserverEntry, 'isIntersecting'>>,
+) => void;
+
+let observers: IntersectionObserverStub[] = [];
+
+// jsdom doesn't implement IntersectionObserver. This stub records what is
+// observed and lets a test report an intersection for the observed element.
+class IntersectionObserverStub {
+ callback: IntersectionCallback;
+ observed: Element[] = [];
+ isDisconnected = false;
+
+ constructor(callback: IntersectionCallback) {
+ this.callback = callback;
+ observers.push(this);
+ }
+
+ observe(element: Element) {
+ this.observed.push(element);
+ }
+
+ unobserve() {
+ // no-op
+ }
+
+ disconnect() {
+ this.isDisconnected = true;
+ }
+
+ intersect(isIntersecting: boolean) {
+ this.callback([{ isIntersecting }]);
+ }
+}
+
+describe('useIsInViewport', () => {
+ beforeEach(() => {
+ observers = [];
+ vi.stubGlobal('IntersectionObserver', IntersectionObserverStub);
+ });
+
+ afterEach(() => {
+ vi.unstubAllGlobals();
+ });
+
+ it('is false while there is no element to observe', () => {
+ const { result } = renderHook(() => useIsInViewport(null));
+
+ expect(result.current).toBe(false);
+ expect(observers).toHaveLength(0);
+ });
+
+ it('reports whether the observed element intersects the viewport', () => {
+ const element = document.createElement('div');
+ const { result } = renderHook(() => useIsInViewport(element));
+
+ expect(observers).toHaveLength(1);
+ expect(observers[0].observed).toEqual([element]);
+ expect(result.current).toBe(false);
+
+ act(() => observers[0].intersect(true));
+ expect(result.current).toBe(true);
+
+ act(() => observers[0].intersect(false));
+ expect(result.current).toBe(false);
+ });
+
+ it('observes the new element when the element changes', () => {
+ const first = document.createElement('div');
+ const second = document.createElement('div');
+ const { result, rerender } = renderHook(
+ ({ element }: { element: Element | null }) => useIsInViewport(element),
+ { initialProps: { element: first } },
+ );
+
+ rerender({ element: second });
+
+ expect(observers).toHaveLength(2);
+ expect(observers[0].isDisconnected).toBe(true);
+ expect(observers[1].observed).toEqual([second]);
+
+ act(() => observers[1].intersect(true));
+ expect(result.current).toBe(true);
+ });
+
+ it('disconnects the observer on unmount', () => {
+ const element = document.createElement('div');
+ const { unmount } = renderHook(() => useIsInViewport(element));
+
+ unmount();
+
+ expect(observers[0].isDisconnected).toBe(true);
+ });
+});
diff --git a/packages/desktop-client/src/hooks/useIsInViewport.ts b/packages/desktop-client/src/hooks/useIsInViewport.ts
index 4bde77a01b..c0eace1ee0 100644
--- a/packages/desktop-client/src/hooks/useIsInViewport.ts
+++ b/packages/desktop-client/src/hooks/useIsInViewport.ts
@@ -1,33 +1,29 @@
-import { useEffect, useMemo, useState } from 'react';
-import type { RefObject } from 'react';
+import { useEffect, useState } from 'react';
/**
- * Check if the given element (by ref) is visible in the viewport.
+ * Check if the given element is visible in the viewport.
+ *
+ * The element is passed directly (tracked as state through a callback ref)
+ * rather than as a ref object, so the observer follows the element when it is
+ * replaced, e.g. when a dashboard card is remounted on toggling edit mode.
*/
-export function useIsInViewport(ref: RefObject<Element | null>) {
+export function useIsInViewport(element: Element | null) {
const [isIntersecting, setIsIntersecting] = useState(false);
- const observer = useMemo(
- () =>
- new IntersectionObserver(([entry]) =>
- setIsIntersecting(entry.isIntersecting),
- ),
- [],
- );
-
useEffect(() => {
- const view = ref.current;
-
- if (!view) {
+ if (!element) {
return;
}
- observer.observe(view);
+ const observer = new IntersectionObserver(([entry]) =>
+ setIsIntersecting(entry.isIntersecting),
+ );
+ observer.observe(element);
return () => {
observer.disconnect();
};
- }, [ref, observer]);
+ }, [element]);
return isIntersecting;
}
diff --git a/upcoming-release-notes/dashboard-widgets-load-in-edit-mode.md b/upcoming-release-notes/dashboard-widgets-load-in-edit-mode.md
new file mode 100644
index 0000000000..81ce3ca330
--- /dev/null
+++ b/upcoming-release-notes/dashboard-widgets-load-in-edit-mode.md
@@ -0,0 +1,6 @@
+---
+category: Bugfix
+authors: [YasinzHyper]
+---
+
+Keep loading off-screen dashboard widgets after toggling "Edit Dashboard"