@openmrs/esm-patient-tests-app 11.3.1-pre.9277 → 11.3.1-pre.9280

package/src/test-results/loadPatientTestData/helpers.ts

@@ -7,6 +7,8 @@ import {
   type ObsMetaInfo,
   type OBSERVATION_INTERPRETATION,
 } from '@openmrs/esm-patient-common-lib';
+import type { FHIRObservationResource } from '../../types';
+import { type ReferenceRanges } from '../grouped-timeline/reference-range-helpers';
 
 const PAGE_SIZE = 300;
 const CHUNK_PREFETCH_COUNT = 1;
@@ -151,6 +153,118 @@ export function exist(...args: any[]): boolean {
   return true;
 }
 
+/**
+ * Extracts reference ranges from FHIR Observation referenceRange field.
+ * Handles different range types: normal, treatment, and absolute.
+ */
+export function extractObservationReferenceRanges(
+  resource: FHIRObservationResource | ObsRecord,
+): ReferenceRanges | undefined {
+  if (!resource.referenceRange || resource.referenceRange.length === 0) {
+    return undefined;
+  }
+
+  const ranges: ReferenceRanges = {
+    units: resource.valueQuantity?.unit,
+  };
+
+  resource.referenceRange.forEach((range) => {
+    const rangeType = range.type?.coding?.[0]?.code;
+    const rangeSystem = range.type?.coding?.[0]?.system;
+
+    if (rangeSystem === 'http://terminology.hl7.org/CodeSystem/referencerange-meaning') {
+      if (rangeType === 'normal') {
+        ranges.hiNormal = range.high?.value;
+        ranges.lowNormal = range.low?.value;
+      } else if (rangeType === 'treatment') {
+        ranges.hiCritical = range.high?.value;
+        ranges.lowCritical = range.low?.value;
+      }
+    } else if (rangeSystem === 'http://fhir.openmrs.org/ext/obs/reference-range' && rangeType === 'absolute') {
+      ranges.hiAbsolute = range.high?.value;
+      ranges.lowAbsolute = range.low?.value;
+    }
+  });
+
+  // Only return if we found at least one range value
+  if (
+    ranges.hiNormal !== undefined ||
+    ranges.lowNormal !== undefined ||
+    ranges.hiCritical !== undefined ||
+    ranges.lowCritical !== undefined ||
+    ranges.hiAbsolute !== undefined ||
+    ranges.lowAbsolute !== undefined
+  ) {
+    return ranges;
+  }
+
+  return undefined;
+}
+
+/**
+ * Extracts and maps FHIR Observation interpretation to OBSERVATION_INTERPRETATION.
+ * Supports both interpretation codes (e.g., "LL", "N", "H") and display values (e.g., "Critically Low", "Normal").
+ */
+export function extractObservationInterpretation(
+  resource: FHIRObservationResource | ObsRecord,
+): OBSERVATION_INTERPRETATION | undefined {
+  if (!resource.interpretation || resource.interpretation.length === 0) {
+    return undefined;
+  }
+
+  const interpretation = resource.interpretation[0];
+  const code = interpretation.coding?.[0]?.code;
+  const display = interpretation.coding?.[0]?.display || interpretation.text;
+
+  // Map FHIR interpretation codes (HL7 v3 ObservationInterpretation codes)
+  if (code) {
+    switch (code.toUpperCase()) {
+      case 'LL':
+        return 'CRITICALLY_LOW';
+      case 'HH':
+        return 'CRITICALLY_HIGH';
+      case 'L':
+        return 'LOW';
+      case 'H':
+        return 'HIGH';
+      case 'N':
+        return 'NORMAL';
+      case 'LU':
+        return 'OFF_SCALE_LOW';
+      case 'HU':
+        return 'OFF_SCALE_HIGH';
+      default:
+        // Fall through to display mapping
+        break;
+    }
+  }
+
+  // Map FHIR interpretation display values
+  if (display) {
+    const normalized = display.trim().toLowerCase();
+    switch (normalized) {
+      case 'critically low':
+        return 'CRITICALLY_LOW';
+      case 'critically high':
+        return 'CRITICALLY_HIGH';
+      case 'low':
+        return 'LOW';
+      case 'high':
+        return 'HIGH';
+      case 'normal':
+        return 'NORMAL';
+      case 'off scale low':
+        return 'OFF_SCALE_LOW';
+      case 'off scale high':
+        return 'OFF_SCALE_HIGH';
+      default:
+        return undefined;
+    }
+  }
+
+  return undefined;
+}
+
 export const assessValue =
   (meta: ObsMetaInfo) =>
   (value: string): OBSERVATION_INTERPRETATION => {

package/src/test-results/loadPatientTestData/loadPatientData.ts

@@ -7,13 +7,21 @@ import {
   type ObsMetaInfo,
 } from '@openmrs/esm-patient-common-lib';
 import {
+  addUserDataToCache,
+  assessValue,
+  extractMetaInformation,
+  extractObservationReferenceRanges,
+  extractObservationInterpretation,
   getEntryConceptClassUuid,
   getUserDataFromCache,
   loadObsEntries,
   loadPresentConcepts,
-  extractMetaInformation,
-  addUserDataToCache,
 } from './helpers';
+import {
+  selectReferenceRange,
+  formatReferenceRange,
+  type ReferenceRanges,
+} from '../grouped-timeline/reference-range-helpers';
 
 function parseSingleObsData(
   testConceptNameMap: Record<ConceptUuid, string>,
@@ -23,6 +31,11 @@ function parseSingleObsData(
   return (entry: ObsRecord) => {
     entry.conceptClass = getEntryConceptClassUuid(entry);
 
+    // Extract observation-level reference ranges from FHIR Observation referenceRange field
+    const observationRanges = extractObservationReferenceRanges(entry);
+    // Extract observation-level interpretation from FHIR Observation interpretation field
+    const observationInterpretation = extractObservationInterpretation(entry);
+
     if (entry.hasMember) {
       // is a panel
       entry.members = new Array(entry.hasMember.length);
@@ -31,17 +44,59 @@ function parseSingleObsData(
       });
     } else {
       // is a single test
-      entry.meta = metaInfomation[entry.conceptClass];
-    }
 
-    if (entry.valueQuantity) {
-      entry.value = entry.valueQuantity.value;
-      delete entry.valueQuantity;
-    }
+      // Extract value FIRST before computing interpretation
+      if (entry.valueQuantity) {
+        entry.value = String(entry.valueQuantity.value);
+        delete entry.valueQuantity;
+      } else if (entry.valueCodeableConcept) {
+        entry.value = entry.valueCodeableConcept.coding?.[0]?.display;
+        delete entry.valueCodeableConcept;
+      } else if (entry.valueString) {
+        entry.value = entry.valueString;
+        delete entry.valueString;
+      }
 
-    if (entry.valueCodeableConcept) {
-      entry.value = entry?.valueCodeableConcept.coding[0].display;
-      delete entry.valueCodeableConcept;
+      const conceptMeta = metaInfomation[entry.conceptClass];
+
+      // Node-level (concept-level) reference ranges
+      const nodeRanges: ReferenceRanges = {
+        hiAbsolute: conceptMeta.hiAbsolute,
+        hiCritical: conceptMeta.hiCritical,
+        hiNormal: conceptMeta.hiNormal,
+        lowAbsolute: conceptMeta.lowAbsolute,
+        lowCritical: conceptMeta.lowCritical,
+        lowNormal: conceptMeta.lowNormal,
+        units: conceptMeta.units,
+      };
+
+      // Merge observation-level and concept-level ranges (observation takes precedence)
+      const selectedRanges = selectReferenceRange(observationRanges, nodeRanges);
+
+      // Create merged meta with observation-level ranges taking precedence
+      const mergedMeta: ObsMetaInfo = {
+        ...conceptMeta,
+        // Update meta with merged ranges
+        hiAbsolute: selectedRanges?.hiAbsolute ?? conceptMeta.hiAbsolute,
+        hiCritical: selectedRanges?.hiCritical ?? conceptMeta.hiCritical,
+        hiNormal: selectedRanges?.hiNormal ?? conceptMeta.hiNormal,
+        lowAbsolute: selectedRanges?.lowAbsolute ?? conceptMeta.lowAbsolute,
+        lowCritical: selectedRanges?.lowCritical ?? conceptMeta.lowCritical,
+        lowNormal: selectedRanges?.lowNormal ?? conceptMeta.lowNormal,
+        units: selectedRanges?.units ?? conceptMeta.units,
+        // Update range string with merged ranges
+        range: selectedRanges ? formatReferenceRange(selectedRanges, selectedRanges.units) : conceptMeta.range,
+      };
+
+      // Always update assessValue to use merged ranges (computed after mergedMeta to avoid unsafe cast)
+      // This ensures assessValue is computed even when only concept-level ranges exist
+      mergedMeta.assessValue = assessValue(mergedMeta);
+
+      entry.meta = mergedMeta;
+
+      // Use observation-level interpretation if available, otherwise compute using merged ranges
+      entry.interpretation =
+        observationInterpretation ?? (mergedMeta.assessValue ? mergedMeta.assessValue(entry.value) : 'NORMAL');
     }
 
     entry.name = testConceptNameMap[entry.conceptClass];

package/src/test-results/overview/common-datatable.component.tsx

@@ -77,7 +77,7 @@ const CommonDataTable: React.FC<CommonDataTableProps> = ({ title, data, descript
               {rows.map((row, i) => (
                 <TypedTableRow
                   key={row.id}
-                  interpretation={data[i]?.value?.interpretation as OBSERVATION_INTERPRETATION}
+                  interpretation={data[i]?.interpretation as OBSERVATION_INTERPRETATION}
                   {...getRowProps({ row })}
                 >
                   {row.cells.map((cell) => {

package/src/test-results/overview/useOverviewData.ts

@@ -23,24 +23,36 @@ export type OverviewPanelEntry = [string, string, Array<OverviewPanelData>, Date
 
 export function parseSingleEntry(entry: ObsRecord, type: string, panelName: string): Array<OverviewPanelData> {
   if (type === 'Test') {
+    // Use observation-level interpretation set during data loading
+    const interpretation = entry.interpretation || 'NORMAL';
     return [
       {
         id: entry.id,
         name: panelName,
         range: entry.meta?.range || '--',
-        interpretation: entry.meta.assessValue ? entry.meta.assessValue(entry.value) : '--',
-        value: entry.value,
+        interpretation,
+        value: {
+          value: entry.value,
+          interpretation,
+        },
       },
     ];
   } else {
-    return entry.members.map((gm) => ({
-      id: gm.id,
-      key: gm.id,
-      name: gm.name,
-      range: gm.meta?.range || '--',
-      interpretation: gm.meta.assessValue(gm.value),
-      value: gm.value,
-    }));
+    return entry.members.map((member) => {
+      // Use observation-level interpretation set during data loading
+      const interpretation = member.interpretation || 'NORMAL';
+      return {
+        id: member.id,
+        key: member.id,
+        name: member.name,
+        range: member.meta?.range || '--',
+        interpretation,
+        value: {
+          value: member.value,
+          interpretation,
+        },
+      };
+    });
   }
 }
 

package/src/types.ts

@@ -67,6 +67,14 @@ export interface FHIRObservationResource {
   hasMember?: Array<{
     reference: string;
   }>;
+  interpretation?: Array<{
+    coding: Array<{
+      code: string;
+      display: string;
+      system?: string;
+    }>;
+    text?: string;
+  }>;
 }
 
 export interface Concept {
@@ -107,7 +115,7 @@ export interface ConceptMeta {
   range: string;
 }
 
-export interface ObsRecord extends FHIRObservationResource {
+export interface ObsRecord extends Omit<FHIRObservationResource, 'interpretation'> {
   conceptUuid: string;
   relatedObs: Array<ObsRecord>;
   meta: ConceptMeta;