@bathiran212/esm-patient-chart-app 7.0.0

package/src/clinical-views/utils/helpers.ts

@@ -0,0 +1,226 @@
+import { age, formatDate, launchWorkspace2, parseDate, type Visit } from '@openmrs/esm-framework';
+import { launchStartVisitPrompt } from '@openmrs/esm-patient-common-lib';
+import type {
+  ConfigConcepts,
+  Encounter,
+  EncounterPropertyType,
+  EncounterTileColumn,
+  Form,
+  GetObsFromEncounterParams,
+  Observation,
+} from '../types';
+import type { TFunction } from 'i18next';
+
+export type LaunchAction = 'add' | 'view' | 'edit' | 'embedded-view';
+
+export function launchEncounterForm(
+  form: Form,
+  action: LaunchAction = 'add',
+  intent: string = '*',
+  requireActiveVisitForEncounterTile: boolean = true,
+  visit?: Visit,
+  encounterUuid?: string,
+) {
+  if (!visit && requireActiveVisitForEncounterTile) {
+    launchStartVisitPrompt();
+  } else {
+    launchWorkspace2('patient-form-entry-workspace', {
+      workspaceTitle: form?.display ?? form?.name,
+      form,
+      encounterUuid,
+      additionalProps: {
+        mode: action === 'add' ? 'enter' : action,
+        formSessionIntent: intent,
+        openClinicalFormsWorkspaceOnFormClose: false,
+      },
+    });
+  }
+}
+
+export function getEncounterValues(encounter: Encounter, param: string, isDate?: boolean) {
+  if (isDate) return formatDate(encounter[param]);
+  else return encounter[param] ?? '--';
+}
+
+export function obsArrayDateComparator(left: Observation, right: Observation) {
+  return new Date(right.obsDatetime).getTime() - new Date(left.obsDatetime).getTime();
+}
+
+export function findObs(encounter: Encounter, obsConcept: string): Observation {
+  const allObs = encounter?.obs?.filter((observation) => observation.concept.uuid === obsConcept) || [];
+  return allObs?.length == 1 ? allObs[0] : allObs.sort(obsArrayDateComparator)[0];
+}
+
+export function getObsFromEncounters(encounters: Encounter, obsConcept: string, config: ConfigConcepts) {
+  const filteredEnc = encounters?.find((enc) => enc.obs.find((obs) => obs.concept.uuid === obsConcept));
+  return getObsFromEncounter({ encounter: filteredEnc, obsConcept: obsConcept, config: config });
+}
+
+export function resolveValueUsingMappings(encounter: Encounter, concept: string, mappings, t: TFunction) {
+  const obs = findObs(encounter, concept);
+  for (const key in mappings) {
+    if (typeof obs?.value === 'object' && 'uuid' in obs.value && mappings[key] === obs?.value?.uuid) {
+      return t(key);
+    }
+  }
+  return '--';
+}
+
+export function getConditionalConceptValue(
+  encounter: Encounter,
+  conditionalConceptMappings,
+  isDate: boolean,
+  config: ConfigConcepts,
+) {
+  const { trueConcept, nonTrueConcept, dependantConcept, conditionalConcept } = conditionalConceptMappings;
+  const dependantValue = findObs(encounter, dependantConcept)?.value;
+  const dependantUuid =
+    typeof dependantValue === 'object' && 'uuid' in dependantValue ? dependantValue.uuid : undefined;
+  const finalConcept = dependantUuid === conditionalConcept ? trueConcept : nonTrueConcept;
+  return getObsFromEncounter({
+    encounter: encounter,
+    obsConcept: finalConcept,
+    isDate: isDate,
+    isTrueFalseConcept: false,
+    config: config,
+  });
+}
+
+export function getConceptFromMappings(encounter: Encounter, concepts: Array<string>) {
+  for (const concept of concepts) {
+    const obs = findObs(encounter, concept);
+    if (obs && obs.value) {
+      return concept;
+    }
+  }
+  return null;
+}
+
+export function getMultipleObsFromEncounter(encounter: Encounter, obsConcepts: Array<string>, config: ConfigConcepts) {
+  let observations = [];
+  obsConcepts.map((concept) => {
+    const obs = getObsFromEncounter({ encounter: encounter, obsConcept: concept, config: config });
+    if (obs !== '--') {
+      observations.push(obs);
+    }
+  });
+
+  return observations.length ? observations.join(', ') : '--';
+}
+
+/**
+ * Retrieves and formats an observation from an encounter based on the provided concept and various options.
+ *
+ * @param encounter - The encounter object from which observations will be extracted.
+ * @param obsConcept - The main concept to search for in the encounter's observations.
+ * @param isDate - Optional flag to indicate if the observation value should be treated as a date.
+ * @param isTrueFalseConcept - Optional flag to check if the observation concept represents a true/false value.
+ * @param type - Optional property type for filtering or fetching additional encounter properties.
+ * @param fallbackConcepts - Optional list of alternative concepts to use if the primary concept is not found.
+ * @param secondaryConcept - Optional secondary concept to check if the primary value matches a specific condition.
+ * @param t - Optional translation function.
+ * @returns The value of the observation, formatted appropriately, or '--' if not found or applicable.
+ */
+export function getObsFromEncounter({
+  encounter,
+  obsConcept,
+  isDate = false,
+  isTrueFalseConcept = false,
+  type,
+  fallbackConcepts = [],
+  secondaryConcept,
+  config,
+}: GetObsFromEncounterParams) {
+  let obs = findObs(encounter, obsConcept);
+
+  if (!encounter && !obsConcept) {
+    return '--';
+  }
+
+  if (isTrueFalseConcept) {
+    if (typeof obs?.value === 'object') {
+      return obs?.value?.name?.name;
+    }
+  }
+
+  // handles things like location, provider, visit type, etc. that are not in the encounter
+  if (type) {
+    return getEncounterProperty(encounter, type);
+  }
+
+  if (secondaryConcept && typeof obs.value === 'object' && obs.value.names) {
+    const primaryValue = obs.value.name.display;
+    if (primaryValue === config.otherConceptUuid) {
+      const secondaryObs = findObs(encounter, secondaryConcept);
+      return secondaryObs ? secondaryObs.value : '--';
+    }
+  }
+
+  if (!obs && fallbackConcepts?.length) {
+    const concept = fallbackConcepts.find((c) => findObs(encounter, c) != null);
+    obs = findObs(encounter, concept);
+  }
+
+  if (!obs) {
+    return '--';
+  }
+
+  // format format obs date or datetime based on the obs value's type
+  if (isDate) {
+    if (typeof obs.value === 'object' && obs.value?.names) {
+      return formatDate(parseDate(obs.obsDatetime), { mode: 'wide', time: false });
+    } else if (typeof obs.value === 'string') {
+      return formatDate(parseDate(obs.value), { mode: 'wide', time: false });
+    }
+  }
+
+  if (typeof obs.value === 'object' && obs.value?.name) {
+    return obs.value?.name?.display ?? obs.value?.name?.name ?? '--';
+  }
+  return obs.value;
+}
+
+export const groupColumnsByEncounterType = (columns: EncounterTileColumn[]): Record<string, EncounterTileColumn[]> => {
+  return columns.reduce((acc: Record<string, EncounterTileColumn[]>, column) => {
+    if (!acc[column.encounterTypeUuid]) {
+      acc[column.encounterTypeUuid] = [];
+    }
+    acc[column.encounterTypeUuid].push(column);
+    return acc;
+  }, {});
+};
+
+export const getEncounterProperty = (encounter: Encounter, type: EncounterPropertyType) => {
+  if (type === 'location') {
+    return encounter.location.display;
+  }
+
+  if (type === 'provider') {
+    return encounter.encounterProviders.map((p) => p.provider.name).join(' | ');
+  }
+
+  if (type === 'encounterType') {
+    return encounter.encounterType.name;
+  }
+
+  if (type === 'ageAtEncounter') {
+    return age(encounter.patient.birthDate, encounter.encounterDatetime);
+  }
+
+  if (type === 'visitDate') {
+    if (encounter.visit?.startDatetime) {
+      return formatDate(parseDate(encounter.visit.startDatetime), { mode: 'wide' });
+    }
+    return '--';
+  }
+
+  if (type === 'visitType') {
+    return encounter.visit?.visitType?.display ?? '--';
+  }
+
+  if (type === 'encounterDatetime') {
+    return formatDate(parseDate(encounter.encounterDatetime), { mode: 'wide' });
+  }
+};
+
+export const filter = (encounter: Encounter, formUuid: string) => encounter?.form?.uuid === formUuid;

package/src/clinical-views/utils/index.ts

@@ -0,0 +1,90 @@
+import { getConceptFromMappings, getObsFromEncounter } from './helpers';
+import type { Encounter, ColumnDefinition, ConfigConcepts, EncounterTileColumn, MenuCardProps } from '../types';
+import dayjs from 'dayjs';
+
+const calculateDateDifferenceInDate = (givenDate: string): string => {
+  return `${Math.abs(dayjs().diff(dayjs(givenDate), 'days'))} days`;
+};
+
+export const getEncounterTileColumns = (tileDefinition: MenuCardProps, config: ConfigConcepts) => {
+  const columns: Array<EncounterTileColumn> = tileDefinition.columns?.map((column: ColumnDefinition) => ({
+    key: column.title,
+    header: column.title,
+    concept: column.concept,
+    encounterTypeUuid: column.encounterType,
+    hasSummary: column.hasSummary || false,
+    summaryConcept: column.summaryConcept,
+    getObsValue: (encounter: Encounter) => {
+      let obsValue;
+      if (column.conceptMappings) {
+        const concept = getConceptFromMappings(encounter, column.conceptMappings);
+        obsValue = getObsFromEncounter({
+          encounter: encounter,
+          obsConcept: concept,
+          isDate: column.isDate,
+          isTrueFalseConcept: column.isTrueFalseConcept,
+          type: column.type,
+          fallbackConcepts: column.fallbackConcepts,
+          secondaryConcept: column.summaryConcept?.secondaryConcept,
+          config: config,
+        });
+      } else {
+        obsValue = getObsFromEncounter({
+          encounter: encounter,
+          obsConcept: column.concept,
+          isDate: column.isDate,
+          config: config,
+        });
+      }
+      return typeof obsValue === 'string' || (typeof obsValue === 'number' && !isNaN(obsValue))
+        ? obsValue
+        : obsValue?.name?.name ?? '--';
+    },
+    getSummaryObsValue: column.hasSummary
+      ? (encounter: Encounter) => {
+          let summaryValue;
+
+          if (column.summaryConcept?.secondaryConcept) {
+            const primaryConceptType = getObsFromEncounter({
+              encounter: encounter,
+              obsConcept: column.summaryConcept.primaryConcept,
+              config: config,
+            });
+
+            if (primaryConceptType !== '--') {
+              summaryValue = primaryConceptType;
+            } else {
+              summaryValue = getObsFromEncounter({
+                encounter: encounter,
+                obsConcept: column.summaryConcept.secondaryConcept,
+                config: config,
+              });
+            }
+          } else if (column.summaryConcept?.hasCalculatedDate) {
+            const primaryDate = getObsFromEncounter({
+              encounter: encounter,
+              obsConcept: column.summaryConcept.primaryConcept,
+              isDate: false,
+              config,
+            });
+
+            if (typeof primaryDate === 'string' && primaryDate !== '--') {
+              summaryValue = calculateDateDifferenceInDate(primaryDate);
+            } else {
+              summaryValue = '--';
+            }
+          } else {
+            summaryValue = getObsFromEncounter({
+              encounter: encounter,
+              obsConcept: column.summaryConcept?.primaryConcept,
+              isDate: column.summaryConcept?.isDate,
+              config: config,
+              type: column.summaryConcept?.type,
+            });
+          }
+          return typeof summaryValue === 'string' ? summaryValue : summaryValue?.name?.name || '--';
+        }
+      : null,
+  }));
+  return columns;
+};

package/src/config-schema.ts

@@ -0,0 +1,235 @@
+import { Type } from '@openmrs/esm-framework';
+
+export const esmPatientChartSchema = {
+  defaultFacilityUrl: {
+    _type: Type.String,
+    _default: '',
+    _description: 'Custom URL to load default facility if it is not in the session',
+  },
+  disableChangingVisitLocation: {
+    _type: Type.Boolean,
+    _description: 'Whether the visit location field in the Start Visit form should be view-only.',
+    _default: false,
+  },
+  disableEmptyTabs: {
+    _type: Type.Boolean,
+    _default: false,
+    _description: 'Disable notes/tests/medications/encounters tabs when empty',
+  },
+  encounterEditableDuration: {
+    _type: Type.Number,
+    _default: 0,
+    _description:
+      'The number of minutes an encounter is editable after it is created. 0 means the encounter is editable forever.',
+  },
+  encounterEditableDurationOverridePrivileges: {
+    _type: Type.Array,
+    _elements: {
+      _type: Type.String,
+    },
+    _default: [],
+    _description:
+      'The privileges that allow users to edit encounters even after the editable duration (set by `encounterEditableDuration`) has expired. Any privilege in the list is sufficient to edit the encounter.',
+  },
+  freeTextFieldConceptUuid: {
+    _type: Type.ConceptUuid,
+    _default: '5622AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA',
+  },
+  logo: {
+    alt: {
+      _type: Type.String,
+      _default: 'Logo',
+      _description: 'Alt text, shown on hover',
+    },
+    name: {
+      _type: Type.String,
+      _default: '',
+      _description: 'The organization name displayed when image is absent',
+    },
+    src: {
+      _type: Type.String,
+      _default: '',
+      _description: 'A path or URL to an image. Defaults to the OpenMRS SVG sprite.',
+    },
+  },
+  notesConceptUuids: {
+    _type: Type.Array,
+    _elements: {
+      _type: Type.ConceptUuid,
+    },
+    _default: ['162169AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'],
+  },
+  obsConceptUuidsToHide: {
+    _type: Type.Array,
+    _elements: {
+      _type: Type.ConceptUuid,
+    },
+    _description:
+      'An array of concept UUIDs. If an observation has a concept UUID that matches any of the ones in this array, it will be hidden from the observations list in the Encounters summary table.',
+    _default: [],
+  },
+  offlineVisitTypeUuid: {
+    _type: Type.UUID,
+    _description: 'The UUID of the visit type to be used for the automatically created offline visits.',
+    _default: 'a22733fa-3501-4020-a520-da024eeff088',
+  },
+  restrictByVisitLocationTag: {
+    _type: Type.Boolean,
+    _description:
+      'On the start visit form, whether to restrict the visit location to locations with the Visit Location tag',
+    _default: false,
+  },
+  showAllEncountersTab: {
+    _type: Type.Boolean,
+    _description: 'Shows the All Encounters Tab of Patient Visits section in Patient Chart',
+    _default: true,
+  },
+  showRecommendedVisitTypeTab: {
+    _type: Type.Boolean,
+    _description: 'Whether start visit form should display recommended visit type tab. Requires `visitTypeResourceUrl`',
+    _default: false,
+  },
+  showServiceQueueFields: {
+    _type: Type.Boolean,
+    _description: 'Whether start visit form should display service queue fields`',
+    _default: false,
+  },
+  showUpcomingAppointments: {
+    _type: Type.Boolean,
+    _description: 'Whether start visit form should display upcoming appointments',
+    _default: false,
+  },
+  visitAttributeTypes: {
+    _type: Type.Array,
+    _elements: {
+      _type: Type.Object,
+      uuid: {
+        _type: Type.UUID,
+        _description: 'UUID of the visit attribute type',
+      },
+      required: {
+        _type: Type.Boolean,
+        _description: 'Whether the attribute type field is required or not',
+        _default: false,
+      },
+      displayInThePatientBanner: {
+        _type: Type.Boolean,
+        _description: "Whether we should show this visit attribute's value in the patient banner",
+        _default: true,
+      },
+    },
+    _description: 'List of visit attribute types shown when filling the visit form',
+    _default: [
+      {
+        uuid: '57ea0cbb-064f-4d09-8cf4-e8228700491c',
+        required: false,
+        displayInThePatientBanner: true,
+      },
+      {
+        uuid: 'aac48226-d143-4274-80e0-264db4e368ee',
+        required: false,
+        displayInThePatientBanner: true,
+      },
+    ],
+  },
+  visitDiagnosisConceptUuid: {
+    _type: Type.ConceptUuid,
+    _default: '159947AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA',
+  },
+  visitTypeResourceUrl: {
+    _type: Type.String,
+    _default: '/etl-latest/etl/patient/',
+    _description: 'Custom URL to load resources required for showing recommended visit types',
+  },
+  trueConceptUuid: {
+    _type: Type.ConceptUuid,
+    _description: 'Default concept uuid for true in forms',
+    _default: '1065AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA',
+  },
+  falseConceptUuid: {
+    _type: Type.ConceptUuid,
+    _description: 'Default concept uuid for false in forms',
+    _default: '1066AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA',
+  },
+  otherConceptUuid: {
+    _type: Type.ConceptUuid,
+    _description: 'Default concept uuid for other in forms',
+    _default: '5622AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA',
+  },
+  tileDefinitions: {
+    _type: Type.Array,
+    _default: [
+      {
+        title: 'Weight and Height',
+        columns: [
+          {
+            title: 'Weight',
+            concept: '5089AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA',
+            encounterType: '67a71486-1a54-468f-ac3e-7091a9a79584',
+            hasSummary: true,
+          },
+          {
+            title: 'Height',
+            concept: '5090AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA',
+            encounterType: '67a71486-1a54-468f-ac3e-7091a9a79584',
+            hasSummary: true,
+          },
+        ],
+      },
+    ],
+    _description: 'Definitions for clinical summary tiles with their concepts and encounter types',
+  },
+  requireActiveVisitForEncounterTile: {
+    _type: Type.Boolean,
+    _description: 'Whether to require an active visit for the encounter tile',
+    _default: true,
+  },
+  drugOrderTypeUUID: {
+    _type: Type.UUID,
+    _description: "UUID for the 'Drug' order type to fetch medications",
+    _default: '131168f4-15f5-102d-96e4-000c29c2a5d7',
+  },
+};
+
+export interface ChartConfig {
+  defaultFacilityUrl: string;
+  disableChangingVisitLocation: boolean;
+  disableEmptyTabs: boolean;
+  encounterEditableDuration: number;
+  encounterEditableDurationOverridePrivileges: Array<string>;
+  freeTextFieldConceptUuid: string;
+  logo: {
+    alt: string;
+    name: string;
+    src: string;
+  };
+  notesConceptUuids: string[];
+  offlineVisitTypeUuid: string;
+  restrictByVisitLocationTag: boolean;
+  showAllEncountersTab: boolean;
+  showRecommendedVisitTypeTab: boolean;
+  showServiceQueueFields: boolean; // used by extension from esm-service-queues-app
+  showUpcomingAppointments: boolean; // used by extension from esm-appointments-app
+  visitTypeResourceUrl: string;
+  visitAttributeTypes: Array<{
+    displayInThePatientBanner: boolean;
+    required: boolean;
+    showWhenExpression?: string;
+    uuid: string;
+  }>;
+  visitDiagnosisConceptUuid: string;
+  requireActiveVisitForEncounterTile: boolean;
+  trueConceptUuid: string;
+  falseConceptUuid: string;
+  tileDefinitions: Array<{
+    title: string;
+    columns: Array<{
+      title: string;
+      concept: string;
+      encounterType: string;
+      hasSummary?: boolean;
+    }>;
+  }>;
+  otherConceptUuid: string;
+  drugOrderTypeUUID: string;
+}

package/src/constants.ts

@@ -0,0 +1,11 @@
+export const clinicalFormsWorkspace = 'clinical-forms-workspace';
+export const formEntryWorkspace = 'patient-form-entry-workspace';
+export const spaRoot = window['getOpenmrsSpaBase']();
+export const basePath = '/patient/:patientUuid/chart';
+export const dashboardPath = `${basePath}/:view/*`;
+export const spaBasePath = `${window.spaBase}${basePath}`;
+export const moduleName = '@openmrs/esm-patient-chart-app';
+export const patientChartWorkspaceSlot = 'patient-chart-workspace-slot';
+export const patientChartWorkspaceHeaderSlot = 'patient-chart-workspace-header-slot';
+export const omrsDateFormat = 'YYYY-MM-DDTHH:mm:ss.SSSZZ';
+export const jsonSchemaResourceName = 'JSON schema';

package/src/dashboard.meta.ts

@@ -0,0 +1,15 @@
+import { type DashboardLinkConfig } from '@openmrs/esm-patient-common-lib';
+
+export const summaryDashboardMeta: DashboardLinkConfig & { slot: string } = {
+  slot: 'patient-chart-summary-dashboard-slot',
+  path: 'patient-summary',
+  title: 'Patient Summary',
+  icon: 'omrs-icon-report',
+};
+
+export const encountersDashboardMeta: DashboardLinkConfig & { slot: string } = {
+  slot: 'patient-chart-encounters-dashboard-slot',
+  path: 'visits',
+  title: 'Visits',
+  icon: 'omrs-icon-calendar-heat-map',
+};

package/src/data.resource.ts

@@ -0,0 +1,117 @@
+import { useMemo } from 'react';
+import useSWR from 'swr';
+import { openmrsFetch, restBaseUrl } from '@openmrs/esm-framework';
+
+interface CauseOfDeathFetchResponse {
+  uuid: string;
+  value: string;
+}
+
+export interface ConceptAnswer {
+  display: string;
+  name: string;
+  uuid: string;
+}
+
+interface ConceptAnswersResponse {
+  answers?: Array<ConceptAnswer>;
+}
+
+interface CauseOfDeathPayload {
+  causeOfDeath?: string;
+  causeOfDeathNonCoded?: string;
+  dead: boolean;
+  deathDate?: Date;
+}
+
+export function useCausesOfDeath() {
+  const { isCauseOfDeathLoading, isCauseOfDeathValidating, value: causeOfDeathConcept } = useCauseOfDeathConcept();
+  const { isConceptLoading, isConceptAnswerValidating, conceptAnswers } = useConceptAnswers(causeOfDeathConcept);
+
+  return {
+    causesOfDeath: conceptAnswers,
+    isLoading: isCauseOfDeathLoading || isConceptLoading,
+    isValidating: isConceptAnswerValidating || isCauseOfDeathValidating,
+  };
+}
+
+const changePatientDeathStatus = (personUuid: string, payload: CauseOfDeathPayload) => {
+  const abortController = new AbortController();
+
+  return openmrsFetch(`${restBaseUrl}/person/${personUuid}`, {
+    headers: {
+      'Content-type': 'application/json',
+    },
+    method: 'POST',
+    body: payload,
+    signal: abortController.signal,
+  });
+};
+
+export function markPatientDeceased(
+  deceasedDate: Date,
+  personUuid: string,
+  selectedCauseOfDeathValue: string | undefined,
+  nonCodedCauseOfDeath?: string | undefined,
+) {
+  const payload: CauseOfDeathPayload = {
+    dead: true,
+    deathDate: deceasedDate || null,
+    ...(nonCodedCauseOfDeath
+      ? { causeOfDeathNonCoded: nonCodedCauseOfDeath }
+      : {
+          causeOfDeath: selectedCauseOfDeathValue,
+        }),
+  };
+
+  return changePatientDeathStatus(personUuid, payload);
+}
+
+export function markPatientAlive(personUuid: string) {
+  return changePatientDeathStatus(personUuid, {
+    causeOfDeath: null,
+    causeOfDeathNonCoded: null,
+    dead: false,
+    deathDate: null,
+  });
+}
+
+export function useConceptAnswers(conceptUuid: string) {
+  const { data, error, isLoading, isValidating } = useSWR<{ data: ConceptAnswersResponse }, Error>(
+    `${restBaseUrl}/concept/${conceptUuid}`,
+    (url) => (conceptUuid ? openmrsFetch(url) : undefined),
+    {
+      shouldRetryOnError(err) {
+        return err instanceof Response && err.status !== 404;
+      },
+    },
+  );
+
+  return {
+    conceptAnswers: data?.data?.answers ?? ([] as ConceptAnswer[]),
+    isConceptLoading: isLoading,
+    conceptError: error,
+    isConceptAnswerValidating: isValidating,
+  };
+}
+
+export function useCauseOfDeathConcept() {
+  const { data, error, isLoading, isValidating } = useSWR<{ data: CauseOfDeathFetchResponse }, Error>(
+    `${restBaseUrl}/systemsetting/concept.causeOfDeath`,
+    openmrsFetch,
+    {
+      shouldRetryOnError(err) {
+        return err instanceof Response && err.status !== 404;
+      },
+    },
+  );
+  const result = useMemo(() => {
+    return {
+      value: data?.data?.value ?? undefined,
+      isCauseOfDeathLoading: isLoading,
+      isCauseOfDeathValidating: isValidating,
+      error,
+    };
+  }, [data?.data?.value, error, isLoading, isValidating]);
+  return result;
+}

package/src/declarations.d.ts

@@ -0,0 +1,4 @@
+declare module '*.scss' {
+  const content: { [className: string]: string };
+  export default content;
+}