@openmrs/esm-react-utils 8.0.1-pre.3511 → 8.0.1-pre.3525

package/.turbo/turbo-build.log

@@ -1,3 +1,3 @@
-[0] Successfully compiled: 52 files with swc (161.87ms)
+[0] Successfully compiled: 52 files with swc (149.49ms)
 [0] swc --strip-leading-paths src -d dist exited with code 0
 [1] tsc --project tsconfig.build.json exited with code 0

package/dist/useVisit.js

@@ -70,6 +70,9 @@ dayjs.extend(isToday);
         retroMutate
     ]);
     useVisitContextStore(mutateVisit);
+    const waitingForData = Boolean(!activeData || retrospectiveVisitUuid && !retroData);
+    const hasRelevantError = Boolean(retrospectiveVisitUuid ? retroError : activeError);
+    const isLoading = waitingForData && !hasRelevantError;
     return {
         error: activeError || retroError,
         mutate: mutateVisit,
@@ -77,6 +80,6 @@ dayjs.extend(isToday);
         activeVisit,
         currentVisit,
         currentVisitIsRetrospective: Boolean(retrospectiveVisitUuid),
-        isLoading: Boolean((!activeData || retrospectiveVisitUuid && !retroData) && (!activeError || !retroError))
+        isLoading
     };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openmrs/esm-react-utils",
-  "version": "8.0.1-pre.3511",
+  "version": "8.0.1-pre.3525",
   "license": "MPL-2.0",
   "description": "React utilities for OpenMRS.",
   "type": "module",
@@ -23,6 +23,7 @@
   "source": true,
   "scripts": {
     "test": "cross-env TZ=UTC vitest run --passWithNoTests",
+    "coverage": "cross-env TZ=UTC vitest run --coverage --passWithNoTests",
     "build": "rimraf dist && concurrently \"swc --strip-leading-paths src -d dist\" \"tsc --project tsconfig.build.json\"",
     "build:development": "rimraf dist && concurrently \"swc --strip-leading-paths src -d dist\" \"tsc --project tsconfig.build.json\"",
     "typescript": "tsc --project tsconfig.build.json",
@@ -78,19 +79,20 @@
     "swr": "2.x"
   },
   "devDependencies": {
-    "@openmrs/esm-api": "8.0.1-pre.3511",
-    "@openmrs/esm-config": "8.0.1-pre.3511",
-    "@openmrs/esm-context": "8.0.1-pre.3511",
-    "@openmrs/esm-emr-api": "8.0.1-pre.3511",
-    "@openmrs/esm-error-handling": "8.0.1-pre.3511",
-    "@openmrs/esm-extensions": "8.0.1-pre.3511",
-    "@openmrs/esm-feature-flags": "8.0.1-pre.3511",
-    "@openmrs/esm-globals": "8.0.1-pre.3511",
-    "@openmrs/esm-navigation": "8.0.1-pre.3511",
-    "@openmrs/esm-state": "8.0.1-pre.3511",
-    "@openmrs/esm-utils": "8.0.1-pre.3511",
+    "@openmrs/esm-api": "8.0.1-pre.3525",
+    "@openmrs/esm-config": "8.0.1-pre.3525",
+    "@openmrs/esm-context": "8.0.1-pre.3525",
+    "@openmrs/esm-emr-api": "8.0.1-pre.3525",
+    "@openmrs/esm-error-handling": "8.0.1-pre.3525",
+    "@openmrs/esm-extensions": "8.0.1-pre.3525",
+    "@openmrs/esm-feature-flags": "8.0.1-pre.3525",
+    "@openmrs/esm-globals": "8.0.1-pre.3525",
+    "@openmrs/esm-navigation": "8.0.1-pre.3525",
+    "@openmrs/esm-state": "8.0.1-pre.3525",
+    "@openmrs/esm-utils": "8.0.1-pre.3525",
     "@swc/cli": "^0.7.7",
     "@swc/core": "^1.11.29",
+    "@vitest/coverage-v8": "^4.0.7",
     "concurrently": "^9.1.2",
     "cross-env": "^7.0.3",
     "dayjs": "^1.11.13",
@@ -102,7 +104,7 @@
     "rimraf": "^6.0.1",
     "rxjs": "^6.5.3",
     "swr": "2.2.5",
-    "vitest": "^3.1.4"
+    "vitest": "^4.0.7"
   },
   "stableVersion": "8.0.0"
 }

package/src/UserHasAccess.test.tsx

@@ -0,0 +1,311 @@
+import { afterAll, beforeEach, describe, expect, it, vi } from 'vitest';
+import { render, screen, waitFor } from '@testing-library/react';
+import React from 'react';
+import { Observable, type Subscriber } from 'rxjs';
+import type { LoggedInUser, Privilege, Role } from '@openmrs/esm-api';
+// eslint-disable-next-line @typescript-eslint/consistent-type-imports
+import { getCurrentUser, userHasAccess } from '@openmrs/esm-api';
+import { UserHasAccess } from './UserHasAccess';
+
+// Mock getCurrentUser and userHasAccess
+const mockGetCurrentUser = vi.fn();
+const mockUserHasAccess = vi.fn();
+
+vi.mock('@openmrs/esm-api', () => ({
+  getCurrentUser: (...args: Parameters<typeof getCurrentUser>) => mockGetCurrentUser(...args),
+  userHasAccess: (...args: Parameters<typeof userHasAccess>) => mockUserHasAccess(...args),
+}));
+
+// Helper to create a mock user
+function createMockUser(privileges: string[] = [], roles: string[] = []): LoggedInUser {
+  return {
+    uuid: 'user-uuid',
+    display: 'Test User',
+    username: 'testuser',
+    systemId: 'testuser',
+    userProperties: {},
+    person: {
+      uuid: 'person-uuid',
+      display: 'Test User',
+    },
+    privileges: privileges.map((priv) => ({
+      uuid: `priv-${priv}`,
+      display: priv,
+    })) as Privilege[],
+    roles: roles.map((role) => ({
+      uuid: `role-${role}`,
+      display: role,
+    })) as Role[],
+    retired: false,
+    locale: 'en',
+    allowedLocales: ['en'],
+  };
+}
+
+describe('UserHasAccess', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  afterAll(() => {
+    vi.clearAllMocks();
+  });
+
+  describe('when user has required privilege', () => {
+    it('should render children for single privilege', () => {
+      const user = createMockUser(['Edit Patients']);
+
+      mockGetCurrentUser.mockReturnValue(new Observable((subscriber) => subscriber.next(user)));
+      mockUserHasAccess.mockReturnValue(true);
+
+      render(
+        <UserHasAccess privilege="Edit Patients">
+          <div>Protected Content</div>
+        </UserHasAccess>,
+      );
+
+      expect(screen.getByText('Protected Content')).toBeInTheDocument();
+      expect(mockUserHasAccess).toHaveBeenCalledWith('Edit Patients', user);
+    });
+
+    it('should render children for multiple privileges', () => {
+      const user = createMockUser(['Edit Patients', 'Delete Patients']);
+
+      mockGetCurrentUser.mockReturnValue(new Observable((subscriber) => subscriber.next(user)));
+      mockUserHasAccess.mockReturnValue(true);
+
+      render(
+        <UserHasAccess privilege={['Edit Patients', 'Delete Patients']}>
+          <div>Protected Content</div>
+        </UserHasAccess>,
+      );
+
+      expect(screen.getByText('Protected Content')).toBeInTheDocument();
+      expect(mockUserHasAccess).toHaveBeenCalledWith(['Edit Patients', 'Delete Patients'], user);
+    });
+
+    it('should render multiple children', () => {
+      const user = createMockUser(['Edit Patients']);
+
+      mockGetCurrentUser.mockReturnValue(new Observable((subscriber) => subscriber.next(user)));
+      mockUserHasAccess.mockReturnValue(true);
+
+      render(
+        <UserHasAccess privilege="Edit Patients">
+          <div>First Child</div>
+          <div>Second Child</div>
+        </UserHasAccess>,
+      );
+
+      expect(screen.getByText('First Child')).toBeInTheDocument();
+      expect(screen.getByText('Second Child')).toBeInTheDocument();
+    });
+  });
+
+  describe('when user does not have required privilege', () => {
+    it('should render nothing when no fallback provided', () => {
+      const user = createMockUser(['View Patients']);
+
+      mockGetCurrentUser.mockReturnValue(new Observable((subscriber) => subscriber.next(user)));
+      mockUserHasAccess.mockReturnValue(false);
+
+      const { container } = render(
+        <UserHasAccess privilege="Edit Patients">
+          <div>Protected Content</div>
+        </UserHasAccess>,
+      );
+
+      expect(screen.queryByText('Protected Content')).not.toBeInTheDocument();
+      // eslint-disable-next-line jest-dom/prefer-empty, testing-library/no-node-access
+      expect(container.firstChild).toBeNull();
+    });
+
+    it('should render fallback when provided', () => {
+      const user = createMockUser(['View Patients']);
+
+      mockGetCurrentUser.mockReturnValue(new Observable((subscriber) => subscriber.next(user)));
+      mockUserHasAccess.mockReturnValue(false);
+
+      render(
+        <UserHasAccess privilege="Edit Patients" fallback={<div>Access Denied</div>}>
+          <div>Protected Content</div>
+        </UserHasAccess>,
+      );
+
+      expect(screen.queryByText('Protected Content')).not.toBeInTheDocument();
+      expect(screen.getByText('Access Denied')).toBeInTheDocument();
+    });
+
+    it('should render fallback for missing privilege in array', () => {
+      const user = createMockUser(['Edit Patients']); // Has one but not both
+
+      mockGetCurrentUser.mockReturnValue(new Observable((subscriber) => subscriber.next(user)));
+      mockUserHasAccess.mockReturnValue(false);
+
+      render(
+        <UserHasAccess privilege={['Edit Patients', 'Delete Patients']} fallback={<div>Need all privileges</div>}>
+          <div>Protected Content</div>
+        </UserHasAccess>,
+      );
+
+      expect(screen.queryByText('Protected Content')).not.toBeInTheDocument();
+      expect(screen.getByText('Need all privileges')).toBeInTheDocument();
+    });
+  });
+
+  describe('when user is not logged in', () => {
+    it('should render nothing when no fallback provided', () => {
+      mockGetCurrentUser.mockReturnValue(new Observable((subscriber) => subscriber.next(null)));
+      mockUserHasAccess.mockReturnValue(false);
+
+      const { container } = render(
+        <UserHasAccess privilege="Edit Patients">
+          <div>Protected Content</div>
+        </UserHasAccess>,
+      );
+
+      expect(screen.queryByText('Protected Content')).not.toBeInTheDocument();
+      // eslint-disable-next-line jest-dom/prefer-empty, testing-library/no-node-access
+      expect(container.firstChild).toBeNull();
+    });
+
+    it('should render fallback when provided', () => {
+      mockGetCurrentUser.mockReturnValue(new Observable((subscriber) => subscriber.next(null)));
+      mockUserHasAccess.mockReturnValue(false);
+
+      render(
+        <UserHasAccess privilege="Edit Patients" fallback={<div>Please log in</div>}>
+          <div>Protected Content</div>
+        </UserHasAccess>,
+      );
+
+      expect(screen.queryByText('Protected Content')).not.toBeInTheDocument();
+      expect(screen.getByText('Please log in')).toBeInTheDocument();
+    });
+  });
+
+  describe('observable subscription management', () => {
+    it('should subscribe to getCurrentUser on mount', () => {
+      const user = createMockUser(['Edit Patients']);
+      const subscribeMock = vi.fn();
+
+      mockGetCurrentUser.mockReturnValue(
+        new Observable((subscriber) => {
+          subscribeMock();
+          subscriber.next(user);
+          return () => {};
+        }),
+      );
+      mockUserHasAccess.mockReturnValue(true);
+
+      render(
+        <UserHasAccess privilege="Edit Patients">
+          <div>Protected Content</div>
+        </UserHasAccess>,
+      );
+
+      expect(mockGetCurrentUser).toHaveBeenCalledWith({ includeAuthStatus: false });
+      expect(subscribeMock).toHaveBeenCalled();
+    });
+
+    it('should unsubscribe from getCurrentUser on unmount', () => {
+      const user = createMockUser(['Edit Patients']);
+      const unsubscribeMock = vi.fn();
+
+      mockGetCurrentUser.mockReturnValue(
+        new Observable((subscriber) => {
+          subscriber.next(user);
+          return unsubscribeMock;
+        }),
+      );
+      mockUserHasAccess.mockReturnValue(true);
+
+      const { unmount } = render(
+        <UserHasAccess privilege="Edit Patients">
+          <div>Protected Content</div>
+        </UserHasAccess>,
+      );
+
+      unmount();
+
+      expect(unsubscribeMock).toHaveBeenCalled();
+    });
+  });
+
+  describe('user updates', () => {
+    it('should update when user changes', async () => {
+      const user1 = createMockUser(['View Patients']);
+      const user2 = createMockUser(['Edit Patients']);
+
+      let subscriber: Subscriber<unknown> | undefined = undefined;
+      mockGetCurrentUser.mockReturnValue(
+        new Observable((sub) => {
+          subscriber = sub;
+          sub.next(user1);
+          return () => {};
+        }),
+      );
+
+      // Initially user doesn't have access
+      mockUserHasAccess.mockReturnValue(false);
+
+      const { rerender } = render(
+        <UserHasAccess privilege="Edit Patients" fallback={<div>No Access</div>}>
+          <div>Protected Content</div>
+        </UserHasAccess>,
+      );
+
+      expect(screen.queryByText('Protected Content')).not.toBeInTheDocument();
+      expect(screen.getByText('No Access')).toBeInTheDocument();
+
+      // User gains access
+      mockUserHasAccess.mockReturnValue(true);
+      (subscriber as unknown as Subscriber<unknown>)?.next(user2);
+
+      await waitFor(() => {
+        expect(screen.queryByText('No Access')).not.toBeInTheDocument();
+      });
+      expect(screen.getByText('Protected Content')).toBeInTheDocument();
+    });
+  });
+
+  describe('edge cases', () => {
+    it('should handle empty children gracefully', () => {
+      const user = createMockUser(['Edit Patients']);
+
+      mockGetCurrentUser.mockReturnValue(new Observable((subscriber) => subscriber.next(user)));
+      mockUserHasAccess.mockReturnValue(true);
+
+      const { container } = render(<UserHasAccess privilege="Edit Patients" />);
+
+      // Should render empty fragment
+      // eslint-disable-next-line jest-dom/prefer-empty, testing-library/no-node-access
+      expect(container.firstChild).toBeNull();
+    });
+
+    it('should handle complex fallback component', () => {
+      const user = createMockUser(['View Patients']);
+
+      mockGetCurrentUser.mockReturnValue(new Observable((subscriber) => subscriber.next(user)));
+      mockUserHasAccess.mockReturnValue(false);
+
+      render(
+        <UserHasAccess
+          privilege="Edit Patients"
+          fallback={
+            <div>
+              <h1>Access Denied</h1>
+              <p>Contact administrator</p>
+            </div>
+          }
+        >
+          <div>Protected Content</div>
+        </UserHasAccess>,
+      );
+
+      expect(screen.getByText('Access Denied')).toBeInTheDocument();
+      expect(screen.getByText('Contact administrator')).toBeInTheDocument();
+      expect(screen.queryByText('Protected Content')).not.toBeInTheDocument();
+    });
+  });
+});

package/src/usePatient.test.ts

@@ -0,0 +1,433 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import { act, renderHook } from '@testing-library/react';
+import { usePatient } from './usePatient';
+
+// Mock SWR
+const mockUseSWR = vi.fn();
+vi.mock('swr', () => ({
+  default: (...args: any[]) => mockUseSWR(...args),
+}));
+
+// Mock fetchCurrentPatient
+const mockFetchCurrentPatient = vi.fn();
+vi.mock('@openmrs/esm-emr-api', () => ({
+  fetchCurrentPatient: (...args: any[]) => mockFetchCurrentPatient(...args),
+}));
+
+// Helper to create a mock patient
+function createMockPatient(id: string): fhir.Patient {
+  return {
+    resourceType: 'Patient',
+    id,
+    name: [{ given: ['John'], family: 'Doe' }],
+    gender: 'male',
+    birthDate: '1990-01-01',
+  };
+}
+
+describe('usePatient', () => {
+  let originalLocation: Location;
+  let mockAddEventListener: ReturnType<typeof vi.fn>;
+  let mockRemoveEventListener: ReturnType<typeof vi.fn>;
+
+  beforeEach(() => {
+    // Store original location
+    originalLocation = window.location;
+
+    // Mock window.addEventListener and removeEventListener
+    mockAddEventListener = vi.fn();
+    mockRemoveEventListener = vi.fn();
+    window.addEventListener = mockAddEventListener;
+    window.removeEventListener = mockRemoveEventListener;
+
+    // Reset mocks
+    vi.clearAllMocks();
+  });
+
+  afterEach(() => {
+    // Restore original location
+    vi.unstubAllGlobals();
+  });
+
+  function mockLocation(pathname: string) {
+    vi.stubGlobal('location', { ...originalLocation, pathname });
+  }
+
+  describe('with patientUuid parameter', () => {
+    it('should fetch patient with provided UUID', () => {
+      const patientUuid = 'test-patient-123';
+      const mockPatient = createMockPatient(patientUuid);
+
+      mockUseSWR.mockReturnValue({
+        data: mockPatient,
+        error: null,
+        isValidating: false,
+      });
+
+      const { result } = renderHook(() => usePatient(patientUuid));
+
+      expect(mockUseSWR).toHaveBeenCalledWith(['patient', patientUuid], expect.any(Function));
+      expect(result.current.patient).toEqual(mockPatient);
+      expect(result.current.patientUuid).toBe(patientUuid);
+      expect(result.current.isLoading).toBe(false);
+      expect(result.current.error).toBeNull();
+    });
+
+    it('should show loading state while fetching', () => {
+      const patientUuid = 'loading-patient-123';
+
+      mockUseSWR.mockReturnValue({
+        data: undefined,
+        error: null,
+        isValidating: true,
+      });
+
+      const { result } = renderHook(() => usePatient(patientUuid));
+
+      expect(result.current.isLoading).toBe(true);
+      expect(result.current.patient).toBeUndefined();
+      expect(result.current.error).toBeNull();
+    });
+
+    it('should handle error state', () => {
+      const patientUuid = 'error-patient-123';
+      const mockError = new Error('Failed to fetch patient');
+
+      mockUseSWR.mockReturnValue({
+        data: undefined,
+        error: mockError,
+        isValidating: false,
+      });
+
+      const { result } = renderHook(() => usePatient(patientUuid));
+
+      expect(result.current.isLoading).toBe(false);
+      expect(result.current.patient).toBeUndefined();
+      expect(result.current.error).toBe(mockError);
+    });
+
+    it('should not show loading when error is present', () => {
+      const patientUuid = 'error-loading-patient-123';
+      const mockError = new Error('Network error');
+
+      mockUseSWR.mockReturnValue({
+        data: undefined,
+        error: mockError,
+        isValidating: true,
+      });
+
+      const { result } = renderHook(() => usePatient(patientUuid));
+
+      expect(result.current.isLoading).toBe(false);
+      expect(result.current.error).toBe(mockError);
+    });
+
+    it('should not show loading when patient data exists', () => {
+      const patientUuid = 'cached-patient-123';
+      const mockPatient = createMockPatient(patientUuid);
+
+      mockUseSWR.mockReturnValue({
+        data: mockPatient,
+        error: null,
+        isValidating: true,
+      });
+
+      const { result } = renderHook(() => usePatient(patientUuid));
+
+      expect(result.current.isLoading).toBe(false);
+      expect(result.current.patient).toEqual(mockPatient);
+    });
+  });
+
+  describe('without patientUuid parameter', () => {
+    it('should extract patient UUID from URL', () => {
+      mockLocation('/patient/url-patient-456/chart');
+
+      mockUseSWR.mockReturnValue({
+        data: null,
+        error: null,
+        isValidating: false,
+      });
+
+      const { result } = renderHook(() => usePatient());
+
+      expect(result.current.patientUuid).toBe('url-patient-456');
+      expect(mockUseSWR).toHaveBeenCalledWith(['patient', 'url-patient-456'], expect.any(Function));
+    });
+
+    it('should handle URL without patient UUID', () => {
+      mockLocation('/home/dashboard');
+
+      mockUseSWR.mockReturnValue({
+        data: null,
+        error: null,
+        isValidating: false,
+      });
+
+      const { result } = renderHook(() => usePatient());
+
+      expect(result.current.patientUuid).toBeNull();
+      expect(mockUseSWR).toHaveBeenCalledWith(null, expect.any(Function));
+    });
+
+    it('should handle patient UUID with dashes', () => {
+      mockLocation('/patient/abc-123-def-456/encounters');
+
+      mockUseSWR.mockReturnValue({
+        data: null,
+        error: null,
+        isValidating: false,
+      });
+
+      const { result } = renderHook(() => usePatient());
+
+      expect(result.current.patientUuid).toBe('abc-123-def-456');
+    });
+
+    it('should handle patient URL at root level', () => {
+      mockLocation('/patient/root-patient-789');
+
+      mockUseSWR.mockReturnValue({
+        data: null,
+        error: null,
+        isValidating: false,
+      });
+
+      const { result } = renderHook(() => usePatient());
+
+      expect(result.current.patientUuid).toBe('root-patient-789');
+    });
+
+    it('should handle patient URL with trailing slash', () => {
+      mockLocation('/patient/trailing-patient-101/');
+
+      mockUseSWR.mockReturnValue({
+        data: null,
+        error: null,
+        isValidating: false,
+      });
+
+      const { result } = renderHook(() => usePatient());
+
+      expect(result.current.patientUuid).toBe('trailing-patient-101');
+    });
+  });
+
+  describe('routing event handling', () => {
+    it('should register routing event listener on mount', () => {
+      mockLocation('/patient/initial-patient-111');
+
+      mockUseSWR.mockReturnValue({
+        data: null,
+        error: null,
+        isValidating: false,
+      });
+
+      renderHook(() => usePatient());
+
+      expect(mockAddEventListener).toHaveBeenCalledWith('single-spa:routing-event', expect.any(Function));
+    });
+
+    it('should unregister routing event listener on unmount', () => {
+      mockLocation('/patient/unmount-patient-222');
+
+      mockUseSWR.mockReturnValue({
+        data: null,
+        error: null,
+        isValidating: false,
+      });
+
+      const { unmount } = renderHook(() => usePatient());
+
+      const eventHandler = mockAddEventListener.mock.calls[0][1];
+
+      unmount();
+
+      expect(mockRemoveEventListener).toHaveBeenCalledWith('single-spa:routing-event', eventHandler);
+    });
+
+    it('should update patient UUID when route changes', () => {
+      mockLocation('/patient/first-patient-333');
+
+      mockUseSWR.mockReturnValue({
+        data: null,
+        error: null,
+        isValidating: false,
+      });
+
+      const { result } = renderHook(() => usePatient());
+
+      expect(result.current.patientUuid).toBe('first-patient-333');
+
+      // Get the registered event handler
+      const eventHandler = mockAddEventListener.mock.calls[0][1];
+
+      // Simulate route change
+      mockLocation('/patient/second-patient-444');
+      act(() => {
+        eventHandler();
+      });
+
+      expect(result.current.patientUuid).toBe('second-patient-444');
+    });
+
+    it('should not update if route changes to same patient UUID', () => {
+      mockLocation('/patient/same-patient-555/chart');
+
+      mockUseSWR.mockReturnValue({
+        data: null,
+        error: null,
+        isValidating: false,
+      });
+
+      const { result } = renderHook(() => usePatient());
+
+      const initialPatientUuid = result.current.patientUuid;
+      const eventHandler = mockAddEventListener.mock.calls[0][1];
+
+      // Change URL but keep same patient UUID
+      mockLocation('/patient/same-patient-555/encounters');
+      act(() => {
+        eventHandler();
+      });
+
+      expect(result.current.patientUuid).toBe(initialPatientUuid);
+    });
+
+    it('should update when route changes from patient to no patient', () => {
+      mockLocation('/patient/has-patient-666');
+
+      mockUseSWR.mockReturnValue({
+        data: null,
+        error: null,
+        isValidating: false,
+      });
+
+      const { result } = renderHook(() => usePatient());
+
+      expect(result.current.patientUuid).toBe('has-patient-666');
+
+      const eventHandler = mockAddEventListener.mock.calls[0][1];
+
+      // Change to non-patient route
+      mockLocation('/home/dashboard');
+      act(() => {
+        eventHandler();
+      });
+
+      expect(result.current.patientUuid).toBeNull();
+    });
+
+    it('should not listen to routing events when patientUuid is provided', () => {
+      mockLocation('/patient/ignored-patient-777');
+
+      mockUseSWR.mockReturnValue({
+        data: null,
+        error: null,
+        isValidating: false,
+      });
+
+      const { result } = renderHook(() => usePatient('explicit-patient-888'));
+
+      // Patient UUID should be from the parameter, not the URL
+      expect(result.current.patientUuid).toBe('explicit-patient-888');
+
+      // Event listener should still be registered for consistency
+      expect(mockAddEventListener).toHaveBeenCalled();
+    });
+  });
+
+  describe('SWR integration', () => {
+    it('should pass patient UUID to SWR key', () => {
+      const patientUuid = 'swr-patient-999';
+
+      mockUseSWR.mockReturnValue({
+        data: null,
+        error: null,
+        isValidating: false,
+      });
+
+      renderHook(() => usePatient(patientUuid));
+
+      expect(mockUseSWR).toHaveBeenCalledWith(['patient', patientUuid], expect.any(Function));
+    });
+
+    it('should pass null to SWR when no patient UUID', () => {
+      mockLocation('/home');
+
+      mockUseSWR.mockReturnValue({
+        data: null,
+        error: null,
+        isValidating: false,
+      });
+
+      renderHook(() => usePatient());
+
+      expect(mockUseSWR).toHaveBeenCalledWith(null, expect.any(Function));
+    });
+
+    it('should call fetchCurrentPatient when SWR fetcher is invoked', async () => {
+      const patientUuid = 'fetch-patient-1010';
+      const mockPatient = createMockPatient(patientUuid);
+
+      mockFetchCurrentPatient.mockResolvedValue(mockPatient);
+
+      let swrFetcher: any;
+      mockUseSWR.mockImplementation((key, fetcher) => {
+        swrFetcher = fetcher;
+        return {
+          data: null,
+          error: null,
+          isValidating: true,
+        };
+      });
+
+      renderHook(() => usePatient(patientUuid));
+
+      // Call the SWR fetcher
+      const result = await swrFetcher();
+
+      expect(mockFetchCurrentPatient).toHaveBeenCalledWith(patientUuid, {});
+      expect(result).toEqual(mockPatient);
+    });
+  });
+
+  describe('return value', () => {
+    it('should return all expected properties', () => {
+      const patientUuid = 'complete-patient-1111';
+      const mockPatient = createMockPatient(patientUuid);
+
+      mockUseSWR.mockReturnValue({
+        data: mockPatient,
+        error: null,
+        isValidating: false,
+      });
+
+      const { result } = renderHook(() => usePatient(patientUuid));
+
+      expect(result.current).toHaveProperty('isLoading');
+      expect(result.current).toHaveProperty('patient');
+      expect(result.current).toHaveProperty('patientUuid');
+      expect(result.current).toHaveProperty('error');
+    });
+
+    it('should memoize return value correctly', () => {
+      const patientUuid = 'memo-patient-1212';
+
+      mockUseSWR.mockReturnValue({
+        data: null,
+        error: null,
+        isValidating: false,
+      });
+
+      const { result, rerender } = renderHook(() => usePatient(patientUuid));
+
+      const firstResult = result.current;
+      rerender();
+      const secondResult = result.current;
+
+      // Should be the same object reference if values haven't changed
+      expect(firstResult).toBe(secondResult);
+    });
+  });
+});

package/src/useVisit.test.ts

@@ -0,0 +1,505 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import type useSWR from 'swr';
+import type { BareFetcher, Key } from 'swr';
+import { act, renderHook, waitFor } from '@testing-library/react';
+import { useVisit } from './useVisit';
+import type { Visit } from '@openmrs/esm-emr-api';
+
+// Mock openmrsFetch
+const mockOpenmrsFetch = vi.fn();
+vi.mock('@openmrs/esm-api', () => ({
+  openmrsFetch: (...args: any[]) => mockOpenmrsFetch(...args),
+  restBaseUrl: '/ws/rest/v1',
+}));
+
+// SWR mock state - will be inspected by mockUseSWR to return appropriate values
+let activeVisitMockState: {
+  data?: { data: { results: Array<Visit> } };
+  error?: Error | null;
+  mutate: () => void;
+  isValidating: boolean;
+};
+
+let retroVisitMockState: {
+  data?: { data: Visit };
+  error?: Error | null;
+  mutate: () => void;
+  isValidating: boolean;
+};
+
+// Mock SWR - inspects the key to determine which state to return
+// Accepts both key and fetcher to match SWR's signature, but only uses key for logic
+const mockUseSWR = vi.fn(<T = unknown>(key: Key, fetcher?: BareFetcher<T> | null) => {
+  if (key === null) {
+    return {
+      data: undefined,
+      error: null,
+      mutate: vi.fn(),
+      isValidating: false,
+    };
+  }
+
+  // Check if this is a retrospective visit call (has UUID in path like /visit/uuid-here)
+  if (typeof key === 'string' && key.includes('/visit/') && !key.includes('?patient=')) {
+    return retroVisitMockState;
+  }
+
+  // Otherwise it's an active visit call
+  return activeVisitMockState;
+});
+
+vi.mock('swr', () => ({
+  default: (...args: Parameters<typeof useSWR>) => mockUseSWR(args[0], args[1]),
+}));
+
+// Mock useVisitContextStore
+const mockSetVisitContext = vi.fn();
+const mockMutateVisit = vi.fn();
+let mockVisitStoreState = {
+  patientUuid: null as string | null,
+  manuallySetVisitUuid: null as string | null,
+};
+
+vi.mock('./useVisitContextStore', () => ({
+  useVisitContextStore: vi.fn((callback?: () => void) => {
+    return {
+      ...mockVisitStoreState,
+      setVisitContext: mockSetVisitContext,
+      mutateVisit: mockMutateVisit,
+    };
+  }),
+}));
+
+// Mock dayjs
+vi.mock('dayjs', () => {
+  const mockDayjs: any = vi.fn(() => ({
+    isToday: vi.fn(() => false),
+  }));
+  mockDayjs.extend = vi.fn();
+  return {
+    default: mockDayjs,
+  };
+});
+
+// Helper to create a mock visit
+function createMockVisit(uuid: string, overrides: Partial<Visit> = {}): Visit {
+  return {
+    uuid,
+    display: `Visit ${uuid}`,
+    startDatetime: '2025-11-03T10:00:00.000Z',
+    stopDatetime: null,
+    visitType: {
+      uuid: 'visit-type-1',
+      display: 'Facility Visit',
+    },
+    patient: {
+      uuid: 'patient-123',
+      display: 'John Doe',
+    },
+    ...overrides,
+  };
+}
+
+describe('useVisit', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+
+    // Reset mock states
+    mockVisitStoreState = {
+      patientUuid: null,
+      manuallySetVisitUuid: null,
+    };
+
+    activeVisitMockState = {
+      data: undefined,
+      error: null,
+      mutate: vi.fn(),
+      isValidating: false,
+    };
+
+    retroVisitMockState = {
+      data: undefined,
+      error: null,
+      mutate: vi.fn(),
+      isValidating: false,
+    };
+  });
+
+  afterEach(() => {
+    vi.clearAllMocks();
+  });
+
+  describe('without patientUuid', () => {
+    it('should not fetch visits when patientUuid is empty string', () => {
+      const { result } = renderHook(() => useVisit(''));
+
+      expect(mockUseSWR).toHaveBeenCalledWith(null, expect.any(Function));
+      expect(result.current.activeVisit).toBeNull();
+      expect(result.current.currentVisit).toBeNull();
+      // isLoading is true because there's no data when patientUuid is empty
+      expect(result.current.isLoading).toBe(true);
+      expect(result.current.error).toBeNull();
+    });
+  });
+
+  describe('with patientUuid - active visit', () => {
+    it('should use custom representation when provided', () => {
+      const customRep = 'custom:(uuid,display)';
+      const activeVisit = createMockVisit('visit-1', { stopDatetime: null });
+
+      activeVisitMockState.data = { data: { results: [activeVisit] } };
+
+      const { result } = renderHook(() => useVisit('patient-123', customRep));
+
+      // Verify the custom representation is used in the SWR call
+      expect(mockUseSWR).toHaveBeenCalledWith(expect.stringContaining(`v=${customRep}`), expect.any(Function));
+      // Verify the hook still returns the correct data
+      expect(result.current.activeVisit).toEqual(activeVisit);
+      expect(result.current.isLoading).toBe(false);
+    });
+
+    it('should return active visit when found', () => {
+      const activeVisit = createMockVisit('visit-1', { stopDatetime: null });
+      const endedVisit = createMockVisit('visit-2', { stopDatetime: '2025-11-02T18:00:00.000Z' });
+
+      activeVisitMockState.data = { data: { results: [activeVisit, endedVisit] } };
+
+      const { result } = renderHook(() => useVisit('patient-123'));
+
+      expect(result.current.activeVisit).toEqual(activeVisit);
+      expect(result.current.currentVisit).toBeNull();
+      expect(result.current.currentVisitIsRetrospective).toBe(false);
+      expect(result.current.isLoading).toBe(false);
+      expect(result.current.error).toBeNull();
+    });
+
+    it('should return null when no active visit exists', () => {
+      const endedVisit = createMockVisit('visit-1', { stopDatetime: '2025-11-02T18:00:00.000Z' });
+
+      activeVisitMockState.data = { data: { results: [endedVisit] } };
+
+      const { result } = renderHook(() => useVisit('patient-123'));
+
+      expect(result.current.activeVisit).toBeNull();
+      expect(result.current.currentVisit).toBeNull();
+      expect(result.current.isLoading).toBe(false);
+    });
+
+    it('should return null when visits array is empty', () => {
+      activeVisitMockState.data = { data: { results: [] } };
+
+      const { result } = renderHook(() => useVisit('patient-123'));
+
+      expect(result.current.activeVisit).toBeNull();
+      expect(result.current.currentVisit).toBeNull();
+      expect(result.current.isLoading).toBe(false);
+    });
+  });
+
+  describe('with retrospective visit', () => {
+    it('should not fetch retrospective visit for different patient', () => {
+      // Visit store has a retrospective visit set for a different patient
+      mockVisitStoreState.patientUuid = 'other-patient';
+      mockVisitStoreState.manuallySetVisitUuid = 'retro-visit-456';
+
+      activeVisitMockState.data = { data: { results: [] } };
+
+      const { result } = renderHook(() => useVisit('patient-123'));
+
+      // Should not fetch the retrospective visit (SWR called with null for retro)
+      expect(mockUseSWR).toHaveBeenCalledWith(null, expect.any(Function));
+      // Should not have a current visit
+      expect(result.current.currentVisit).toBeNull();
+      expect(result.current.currentVisitIsRetrospective).toBe(false);
+    });
+
+    it('should return retrospective visit as currentVisit', () => {
+      mockVisitStoreState.patientUuid = 'patient-123';
+      mockVisitStoreState.manuallySetVisitUuid = 'retro-visit-456';
+
+      const retroVisit = createMockVisit('retro-visit-456', {
+        stopDatetime: '2025-10-30T18:00:00.000Z',
+      });
+
+      activeVisitMockState.data = { data: { results: [] } };
+      retroVisitMockState.data = { data: retroVisit };
+
+      const { result } = renderHook(() => useVisit('patient-123'));
+
+      expect(result.current.activeVisit).toBeNull();
+      expect(result.current.currentVisit).toEqual(retroVisit);
+      expect(result.current.currentVisitIsRetrospective).toBe(true);
+      expect(result.current.isLoading).toBe(false);
+      expect(result.current.error).toBeNull();
+    });
+
+    it('should return null currentVisit when no retrospective visit set', () => {
+      mockVisitStoreState.patientUuid = 'patient-123';
+      mockVisitStoreState.manuallySetVisitUuid = null;
+
+      activeVisitMockState.data = { data: { results: [] } };
+
+      const { result } = renderHook(() => useVisit('patient-123'));
+
+      expect(result.current.currentVisit).toBeNull();
+      expect(result.current.currentVisitIsRetrospective).toBe(false);
+    });
+  });
+
+  describe('error handling', () => {
+    it('should return error from active visit fetch', () => {
+      const mockError = new Error('Failed to fetch active visits');
+
+      activeVisitMockState.data = { data: { results: [] } };
+      activeVisitMockState.error = mockError;
+
+      const { result } = renderHook(() => useVisit('patient-123'));
+
+      expect(result.current.error).toBe(mockError);
+      expect(result.current.activeVisit).toBeNull();
+      expect(result.current.isLoading).toBe(false);
+    });
+
+    it('should return error from retrospective visit fetch', () => {
+      mockVisitStoreState.patientUuid = 'patient-123';
+      mockVisitStoreState.manuallySetVisitUuid = 'retro-visit-456';
+
+      const mockError = new Error('Failed to fetch retrospective visit');
+
+      activeVisitMockState.data = { data: { results: [] } };
+      retroVisitMockState.data = { data: createMockVisit('retro-visit-456') };
+      retroVisitMockState.error = mockError;
+
+      const { result } = renderHook(() => useVisit('patient-123'));
+
+      expect(result.current.error).toBe(mockError);
+      expect(result.current.isLoading).toBe(false);
+    });
+
+    it('should prioritize active visit error over retrospective error', () => {
+      mockVisitStoreState.patientUuid = 'patient-123';
+      mockVisitStoreState.manuallySetVisitUuid = 'retro-visit-456';
+
+      const activeError = new Error('Active visit error');
+      const retroError = new Error('Retro visit error');
+
+      activeVisitMockState.error = activeError;
+      retroVisitMockState.error = retroError;
+
+      const { result } = renderHook(() => useVisit('patient-123'));
+
+      expect(result.current.error).toBe(activeError);
+    });
+  });
+
+  describe('loading and validation states', () => {
+    it('should show isValidating when active visit is loading', () => {
+      activeVisitMockState.isValidating = true;
+
+      const { result } = renderHook(() => useVisit('patient-123'));
+
+      expect(result.current.isValidating).toBe(true);
+    });
+
+    it('should show isValidating when retrospective visit is loading', () => {
+      mockVisitStoreState.patientUuid = 'patient-123';
+      mockVisitStoreState.manuallySetVisitUuid = 'retro-visit-456';
+
+      activeVisitMockState.data = { data: { results: [] } };
+      retroVisitMockState.isValidating = true;
+
+      const { result } = renderHook(() => useVisit('patient-123'));
+
+      expect(result.current.isValidating).toBe(true);
+    });
+
+    it('should show isLoading when no active data and no error', () => {
+      const { result } = renderHook(() => useVisit('patient-123'));
+
+      expect(result.current.isLoading).toBe(true);
+      expect(result.current.activeVisit).toBeNull();
+      expect(result.current.error).toBeNull();
+    });
+
+    it('should not show isLoading when active data is loaded', () => {
+      activeVisitMockState.data = { data: { results: [] } };
+
+      const { result } = renderHook(() => useVisit('patient-123'));
+
+      expect(result.current.isLoading).toBe(false);
+    });
+
+    it('should not show isLoading when active error exists and no retrospective visit', () => {
+      // When not viewing a retrospective visit, activeError should stop loading
+      const mockError = new Error('Network error');
+      activeVisitMockState.error = mockError;
+      // No data needed - error alone should stop loading
+
+      const { result } = renderHook(() => useVisit('patient-123'));
+
+      expect(result.current.isLoading).toBe(false);
+      expect(result.current.error).toBe(mockError);
+    });
+
+    it('should not show isLoading when retro error exists and retrospective visit is set', () => {
+      // When viewing a retrospective visit, retroError should stop loading
+      mockVisitStoreState.patientUuid = 'patient-123';
+      mockVisitStoreState.manuallySetVisitUuid = 'retro-visit-456';
+
+      const mockError = new Error('Failed to load retrospective visit');
+      activeVisitMockState.data = { data: { results: [] } };
+      retroVisitMockState.error = mockError;
+      // No retro data needed - error alone should stop loading
+
+      const { result } = renderHook(() => useVisit('patient-123'));
+
+      expect(result.current.isLoading).toBe(false);
+      expect(result.current.error).toBe(mockError);
+    });
+
+    it('should show isLoading when retrospective visit expected but not loaded', () => {
+      mockVisitStoreState.patientUuid = 'patient-123';
+      mockVisitStoreState.manuallySetVisitUuid = 'retro-visit-456';
+
+      activeVisitMockState.data = { data: { results: [] } };
+      // retroVisitMockState.data is undefined
+
+      const { result } = renderHook(() => useVisit('patient-123'));
+
+      expect(result.current.isLoading).toBe(true);
+    });
+  });
+
+  describe('mutate functionality', () => {
+    it('should call both mutate functions when mutate is invoked', () => {
+      // Set up retrospective visit so both SWR calls are made
+      mockVisitStoreState.patientUuid = 'patient-123';
+      mockVisitStoreState.manuallySetVisitUuid = 'retro-visit-456';
+
+      // Create stable mutate functions BEFORE setting up the hook
+      const activeMutate = vi.fn();
+      const retroMutate = vi.fn();
+
+      activeVisitMockState = {
+        data: { data: { results: [] } },
+        error: null,
+        mutate: activeMutate,
+        isValidating: false,
+      };
+
+      retroVisitMockState = {
+        data: { data: createMockVisit('retro-visit-456') },
+        error: null,
+        mutate: retroMutate,
+        isValidating: false,
+      };
+
+      const { result } = renderHook(() => useVisit('patient-123'));
+
+      act(() => {
+        result.current.mutate();
+      });
+
+      expect(activeMutate).toHaveBeenCalled();
+      expect(retroMutate).toHaveBeenCalled();
+    });
+  });
+
+  describe('visit context side effects', () => {
+    it('should set visit context when active visit exists and no manual visit set', async () => {
+      mockVisitStoreState.patientUuid = 'patient-123';
+      mockVisitStoreState.manuallySetVisitUuid = null;
+
+      const activeVisit = createMockVisit('visit-1', { stopDatetime: null });
+      activeVisitMockState.data = { data: { results: [activeVisit] } };
+
+      renderHook(() => useVisit('patient-123'));
+
+      await waitFor(() => {
+        expect(mockSetVisitContext).toHaveBeenCalledWith(activeVisit);
+      });
+    });
+
+    it('should not set visit context when manual visit is already set', async () => {
+      mockVisitStoreState.patientUuid = 'patient-123';
+      mockVisitStoreState.manuallySetVisitUuid = 'manual-visit';
+
+      const activeVisit = createMockVisit('visit-1', { stopDatetime: null });
+      activeVisitMockState.data = { data: { results: [activeVisit] } };
+
+      renderHook(() => useVisit('patient-123'));
+
+      await waitFor(() => {
+        expect(mockSetVisitContext).not.toHaveBeenCalled();
+      });
+    });
+
+    it('should not set visit context for different patient', async () => {
+      mockVisitStoreState.patientUuid = 'other-patient';
+      mockVisitStoreState.manuallySetVisitUuid = null;
+
+      const activeVisit = createMockVisit('visit-1', { stopDatetime: null });
+      activeVisitMockState.data = { data: { results: [activeVisit] } };
+
+      renderHook(() => useVisit('patient-123'));
+
+      await waitFor(() => {
+        expect(mockSetVisitContext).not.toHaveBeenCalled();
+      });
+    });
+
+    it('should clear visit context when current visit gets ended', async () => {
+      mockVisitStoreState.patientUuid = 'patient-123';
+      mockVisitStoreState.manuallySetVisitUuid = 'retro-visit-456';
+
+      const activeVisitInitial = createMockVisit('retro-visit-456', { stopDatetime: null });
+
+      activeVisitMockState.data = { data: { results: [] } };
+      retroVisitMockState.data = { data: activeVisitInitial };
+
+      const { rerender } = renderHook(() => useVisit('patient-123'));
+
+      await waitFor(() => {
+        expect(mockSetVisitContext).not.toHaveBeenCalled();
+      });
+
+      // Clear the mock to track new calls
+      mockSetVisitContext.mockClear();
+
+      // Update the visit to be ended
+      const activeVisitEnded = createMockVisit('retro-visit-456', {
+        stopDatetime: '2025-11-03T18:00:00.000Z',
+      });
+      retroVisitMockState.data = { data: activeVisitEnded };
+
+      rerender();
+
+      await waitFor(() => {
+        expect(mockSetVisitContext).toHaveBeenCalledWith(null);
+      });
+    });
+  });
+
+  describe('combined active and retrospective visits', () => {
+    it('should return both active and current visit when retrospective is set', () => {
+      mockVisitStoreState.patientUuid = 'patient-123';
+      mockVisitStoreState.manuallySetVisitUuid = 'retro-visit-456';
+
+      const activeVisit = createMockVisit('visit-1', { stopDatetime: null });
+      const retroVisit = createMockVisit('retro-visit-456', {
+        stopDatetime: '2025-10-30T18:00:00.000Z',
+      });
+
+      activeVisitMockState.data = { data: { results: [activeVisit] } };
+      retroVisitMockState.data = { data: retroVisit };
+
+      const { result } = renderHook(() => useVisit('patient-123'));
+
+      expect(result.current.activeVisit).toEqual(activeVisit);
+      expect(result.current.currentVisit).toEqual(retroVisit);
+      expect(result.current.currentVisitIsRetrospective).toBe(true);
+      expect(result.current.isLoading).toBe(false);
+      expect(result.current.error).toBeNull();
+    });
+  });
+});

package/src/useVisit.ts

@@ -103,6 +103,10 @@ export function useVisit(patientUuid: string, representation = defaultVisitCusto
 
   useVisitContextStore(mutateVisit);
 
+  const waitingForData = Boolean(!activeData || (retrospectiveVisitUuid && !retroData));
+  const hasRelevantError = Boolean(retrospectiveVisitUuid ? retroError : activeError);
+  const isLoading = waitingForData && !hasRelevantError;
+
   return {
     error: activeError || retroError,
     mutate: mutateVisit,
@@ -110,6 +114,6 @@ export function useVisit(patientUuid: string, representation = defaultVisitCusto
     activeVisit,
     currentVisit,
     currentVisitIsRetrospective: Boolean(retrospectiveVisitUuid),
-    isLoading: Boolean((!activeData || (retrospectiveVisitUuid && !retroData)) && (!activeError || !retroError)),
+    isLoading,
   };
 }