@openmrs/esm-react-utils 5.8.2-pre.2324 → 5.8.2-pre.2341

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openmrs/esm-react-utils",
-  "version": "5.8.2-pre.2324",
+  "version": "5.8.2-pre.2341",
   "license": "MPL-2.0",
   "description": "React utilities for OpenMRS.",
   "browser": "dist/openmrs-esm-react-utils.js",
@@ -61,15 +61,15 @@
     "swr": "2.x"
   },
   "devDependencies": {
-    "@openmrs/esm-api": "5.8.2-pre.2324",
-    "@openmrs/esm-config": "5.8.2-pre.2324",
-    "@openmrs/esm-context": "5.8.2-pre.2324",
-    "@openmrs/esm-error-handling": "5.8.2-pre.2324",
-    "@openmrs/esm-extensions": "5.8.2-pre.2324",
-    "@openmrs/esm-feature-flags": "5.8.2-pre.2324",
-    "@openmrs/esm-globals": "5.8.2-pre.2324",
-    "@openmrs/esm-navigation": "5.8.2-pre.2324",
-    "@openmrs/esm-utils": "5.8.2-pre.2324",
+    "@openmrs/esm-api": "5.8.2-pre.2341",
+    "@openmrs/esm-config": "5.8.2-pre.2341",
+    "@openmrs/esm-context": "5.8.2-pre.2341",
+    "@openmrs/esm-error-handling": "5.8.2-pre.2341",
+    "@openmrs/esm-extensions": "5.8.2-pre.2341",
+    "@openmrs/esm-feature-flags": "5.8.2-pre.2341",
+    "@openmrs/esm-globals": "5.8.2-pre.2341",
+    "@openmrs/esm-navigation": "5.8.2-pre.2341",
+    "@openmrs/esm-utils": "5.8.2-pre.2341",
     "dayjs": "^1.10.8",
     "i18next": "^21.10.0",
     "react": "^18.1.0",

package/src/usePatient.ts

@@ -1,86 +1,15 @@
 /** @module @category API */
-import { useEffect, useReducer } from 'react';
-import type { PatientUuid } from '@openmrs/esm-api';
+import { useEffect, useMemo, useState } from 'react';
+import useSWR from 'swr';
 import { fetchCurrentPatient } from '@openmrs/esm-api';
 
 export type NullablePatient = fhir.Patient | null;
 
-export interface CurrentPatientState {
-  patientUuid: string | null;
-  patient: NullablePatient;
-  isPendingUuid: boolean;
-  isLoadingPatient: boolean;
-  err: Error | null;
-}
-
-interface LoadPatient {
-  type: ActionTypes.loadPatient;
-  patientUuid: string | null;
-}
-
-interface NewPatient {
-  type: ActionTypes.newPatient;
-  patient: NullablePatient;
-}
-
-interface PatientLoadError {
-  type: ActionTypes.loadError;
-  err: Error | null;
-}
-
-type Action = LoadPatient | NewPatient | PatientLoadError;
-
-enum ActionTypes {
-  loadPatient = 'loadPatient',
-  newPatient = 'newPatient',
-  loadError = 'patientLoadError',
-}
-
-const initialState: CurrentPatientState = {
-  patientUuid: null,
-  patient: null,
-  isPendingUuid: true,
-  isLoadingPatient: false,
-  err: null,
-};
-
-function getPatientUuidFromUrl(): PatientUuid {
+function getPatientUuidFromUrl() {
   const match = /\/patient\/([a-zA-Z0-9\-]+)\/?/.exec(location.pathname);
   return match && match[1];
 }
 
-function reducer(state: CurrentPatientState, action: Action): CurrentPatientState {
-  switch (action.type) {
-    case ActionTypes.loadPatient:
-      return {
-        ...state,
-        patientUuid: action.patientUuid,
-        patient: null,
-        isPendingUuid: false,
-        isLoadingPatient: true,
-        err: null,
-      };
-    case ActionTypes.newPatient:
-      return {
-        ...state,
-        patient: action.patient,
-        isPendingUuid: false,
-        isLoadingPatient: false,
-        err: null,
-      };
-    case ActionTypes.loadError:
-      return {
-        ...state,
-        patient: null,
-        isPendingUuid: false,
-        isLoadingPatient: false,
-        err: action.err,
-      };
-    default:
-      return state;
-  }
-}
-
 /**
  * This React hook returns a patient object. If the `patientUuid` is provided
  * as a parameter, then the patient for that UUID is returned. If the parameter
@@ -88,66 +17,35 @@ function reducer(state: CurrentPatientState, action: Action): CurrentPatientStat
  * a route listener is set up to update the patient whenever the route changes.
  */
 export function usePatient(patientUuid?: string) {
-  const [state, dispatch] = useReducer(reducer, {
-    ...initialState,
-    patientUuid: patientUuid ?? null,
-    isPendingUuid: !patientUuid,
-    isLoadingPatient: !!patientUuid,
-  });
-
-  useEffect(() => {
-    if (state.isPendingUuid) {
-      const patientUuidFromUrl = getPatientUuidFromUrl();
-      if (patientUuidFromUrl) {
-        dispatch({
-          type: ActionTypes.loadPatient,
-          patientUuid: patientUuidFromUrl,
-        });
-      } else {
-        dispatch({ type: ActionTypes.newPatient, patient: null });
-      }
-    }
+  const [currentPatientUuid, setCurrentPatientUuid] = useState(patientUuid ?? getPatientUuidFromUrl());
 
-    let active = true;
-    if (state.isLoadingPatient && state.patientUuid) {
-      fetchCurrentPatient(state.patientUuid).then(
-        (patient) =>
-          active &&
-          dispatch({
-            patient: patient,
-            type: ActionTypes.newPatient,
-          }),
-        (err) =>
-          active &&
-          dispatch({
-            err,
-            type: ActionTypes.loadError,
-          }),
-      );
-    }
-    return () => {
-      active = false;
-    };
-  }, [state.isPendingUuid, state.isLoadingPatient, state.patientUuid]);
+  const {
+    data: patient,
+    error,
+    isValidating,
+  } = useSWR<NullablePatient, Error | null>(currentPatientUuid ? ['patient', currentPatientUuid] : null, () =>
+    fetchCurrentPatient(currentPatientUuid!, {}),
+  );
 
   useEffect(() => {
-    const handleRouteUpdate = (evt) => {
+    const handleRouteUpdate = () => {
       const newPatientUuid = getPatientUuidFromUrl();
-      if (newPatientUuid != state.patientUuid) {
-        dispatch({
-          type: ActionTypes.loadPatient,
-          patientUuid: newPatientUuid,
-        });
+      if (newPatientUuid !== currentPatientUuid) {
+        setCurrentPatientUuid(newPatientUuid);
       }
     };
+
     window.addEventListener('single-spa:routing-event', handleRouteUpdate);
     return () => window.removeEventListener('single-spa:routing-event', handleRouteUpdate);
-  }, [state.patientUuid]);
-
-  return {
-    isLoading: state.isPendingUuid || state.isLoadingPatient,
-    patient: state.patient,
-    patientUuid: patientUuid ?? state.patientUuid,
-    error: state.err,
-  };
+  }, [currentPatientUuid]);
+
+  return useMemo(
+    () => ({
+      isLoading: isValidating && !error && !patient,
+      patient,
+      patientUuid: currentPatientUuid,
+      error,
+    }),
+    [isValidating, error, patient, currentPatientUuid],
+  );
 }