@openmrs/esm-patient-tests-app 11.3.1-patch.9064 → 11.3.1-patch.9508

package/src/test-results/filter/filter-types.ts

@@ -14,6 +14,7 @@ export interface TreeNode {
   flatName: string;
   subSets?: Array<TreeNode>;
   hasData?: boolean;
+  hiAbsolute?: number;
   hiCritical?: number;
   hiNormal?: number;
   lowAbsolute?: number;
@@ -52,7 +53,7 @@ export type LowestNode = Pick<TreeNode, 'display' | 'flatName'>;
 export interface ReducerState {
   checkboxes: TreeCheckboxes;
   parents: TreeParents;
-  roots: Array<LowestNode>;
+  roots: Array<TreeNode>;
   tests: TreeTests;
   lowestParents: Array<TreeNode>;
 }
@@ -75,6 +76,15 @@ export interface ObservationData {
   obsDatetime: string;
   value: string;
   interpretation: OBSERVATION_INTERPRETATION;
+  // Reference range fields from observation-level (criteria-based)
+  // Note: Units are only at the concept/node level, not observation-level
+  hiAbsolute?: number;
+  hiCritical?: number;
+  hiNormal?: number;
+  lowAbsolute?: number;
+  lowCritical?: number;
+  lowNormal?: number;
+  range?: string; // Formatted range string for display
 }
 
 export interface ParsedTimeType {
@@ -124,7 +134,20 @@ export interface RowData extends TreeNode {
         obsDatetime: string;
         value: string;
         interpretation: OBSERVATION_INTERPRETATION;
+        // Reference range fields from observation-level (criteria-based)
+        // Note: Units are only at the concept/node level, not observation-level
+        hiAbsolute?: number;
+        hiCritical?: number;
+        hiNormal?: number;
+        lowAbsolute?: number;
+        lowCritical?: number;
+        lowNormal?: number;
+        range?: string; // Formatted range string for display
       }
     | undefined
   >;
 }
+
+export interface EmptyStateProps {
+  clearFilter(): void;
+}

package/src/test-results/grouped-timeline/grid.component.tsx

@@ -1,12 +1,14 @@
 import React from 'react';
 import styles from './grid.scss';
 
-export const Grid: React.FC<{
+interface GridProps {
   children?: React.ReactNode;
   style: React.CSSProperties;
   padding?: boolean;
   dataColumns: number;
-}> = ({ dataColumns, style = {}, padding = false, ...props }) => {
+}
+
+export const Grid: React.FC<GridProps> = ({ dataColumns, style = {}, padding = false, ...props }) => {
   return (
     <div
       style={{

package/src/test-results/grouped-timeline/grouped-timeline.component.tsx

@@ -21,29 +21,27 @@ export const GroupedTimeline: React.FC<{ patientUuid: string }> = ({ patientUuid
 
   if (activeTests && timelineData && loaded && tableData) {
     return (
-      <div>
-        <div className={styles.timelineDataContainer}>
-          {tableData.map((panel, index) => {
-            // Filter rowData to only include tests that belong to this panel
-            const panelTestNames = panel.entries.map((entry) => entry.flatName);
-            const subRows = rowData?.filter((row: { flatName: string }) => panelTestNames.includes(row.flatName));
+      <div className={styles.timelineDataContainer}>
+        {tableData.map((panel, index) => {
+          // Filter rowData to only include tests that belong to this panel
+          const panelTestNames = panel.entries.map((entry) => entry.flatName);
+          const subRows = rowData?.filter((row: { flatName: string }) => panelTestNames.includes(row.flatName));
 
-            return (
-              subRows?.length > 0 && (
-                <div key={index}>
-                  <TimelineDataGroup
-                    groupNumber={index + 1}
-                    parent={{ display: panel.key, flatName: panel.key }}
-                    patientUuid={patientUuid}
-                    setXScroll={setXScroll}
-                    subRows={subRows}
-                    xScroll={xScroll}
-                  />
-                </div>
-              )
-            );
-          })}
-        </div>
+          return (
+            subRows?.length > 0 && (
+              <div key={index}>
+                <TimelineDataGroup
+                  groupNumber={index + 1}
+                  parent={{ display: panel.key, flatName: panel.key }}
+                  patientUuid={patientUuid}
+                  setXScroll={setXScroll}
+                  subRows={subRows}
+                  xScroll={xScroll}
+                />
+              </div>
+            )
+          );
+        })}
       </div>
     );
   }

package/src/test-results/grouped-timeline/grouped-timeline.test.tsx

@@ -1,6 +1,7 @@
 import React from 'react';
-import { render, screen } from '@testing-library/react';
 import userEvent from '@testing-library/user-event';
+import { render, screen } from '@testing-library/react';
+import { getByTextWithMarkup } from 'tools';
 import { showModal } from '@openmrs/esm-framework';
 import { mockGroupedResults } from '__mocks__';
 import { type FilterContextProps } from '../filter/filter-types';
@@ -61,7 +62,8 @@ describe('GroupedTimeline', () => {
     expect(screen.getByText('Nov 9')).toBeInTheDocument();
     expect(screen.getByText('01:39 AM')).toBeInTheDocument();
     expect(screen.getByText('Total bilirubin')).toBeInTheDocument();
-    expect(screen.getByText('umol/L')).toBeInTheDocument();
+    // Units are now combined with range, so if there's no range, units won't be displayed separately
+    // Total bilirubin doesn't have a range in timelineData, so units are not displayed
     expect(screen.getByText('261.9')).toBeInTheDocument();
     expect(screen.getByText('21.5')).toBeInTheDocument();
     expect(screen.getByText('Serum glutamic-pyruvic transaminase')).toBeInTheDocument();
@@ -70,6 +72,54 @@ describe('GroupedTimeline', () => {
     expect(screen.getByText('2.9')).toBeInTheDocument();
   });
 
+  it('displays most recent observation range when available', () => {
+    const contextWithObservationRanges = {
+      ...mockFilterContext,
+      timelineData: {
+        ...mockFilterContext.timelineData,
+        data: {
+          ...mockFilterContext.timelineData.data,
+          rowData: [
+            {
+              ...mockFilterContext.timelineData.data.rowData[0],
+              range: '0 – 50', // Node-level range
+              units: 'umol/L',
+              entries: [
+                {
+                  obsDatetime: '2024-05-31 01:39:03.0',
+                  value: '261.9',
+                  interpretation: 'NORMAL',
+                  lowNormal: 35,
+                  hiNormal: 50,
+                  range: '35 – 50', // Observation-level range (most recent)
+                  // Note: Units are only at the concept/node level, not observation-level
+                },
+                {
+                  obsDatetime: '2023-11-09 23:15:03.0',
+                  value: '21.5',
+                  interpretation: 'NORMAL',
+                  lowNormal: 20,
+                  hiNormal: 45,
+                  range: '20 – 45', // Older observation-level range
+                  // Note: Units are only at the concept/node level, not observation-level
+                },
+              ],
+            },
+          ],
+        },
+      },
+    };
+
+    renderGroupedTimeline(contextWithObservationRanges as FilterContextProps);
+
+    // Should display most recent observation's range (35 – 50) not node-level (0 – 50)
+    // Range and units are displayed separately in the same element
+    const rangeElement = getByTextWithMarkup(/35 – 50/);
+    expect(rangeElement).toBeInTheDocument();
+    // Verify that the same element also contains the units
+    expect(rangeElement).toHaveTextContent('35 – 50 umol/L');
+  });
+
   it('correctly filters rows based on checkbox selection when someChecked is true', () => {
     renderGroupedTimeline({
       ...mockFilterContext,

package/src/test-results/grouped-timeline/reference-range-helpers.test.ts

@@ -0,0 +1,308 @@
+import {
+  formatRangeWithUnits,
+  formatReferenceRange,
+  getMostRecentObservationWithRange,
+  rangeAlreadyHasUnits,
+  selectReferenceRange,
+  type ReferenceRanges,
+} from './reference-range-helpers';
+
+describe('Reference Range Helpers', () => {
+  describe('selectReferenceRange', () => {
+    it('returns null when both ranges are null', () => {
+      expect(selectReferenceRange(undefined, undefined)).toBeNull();
+    });
+
+    it('returns node-level range when observation range is not available', () => {
+      const nodeRanges: ReferenceRanges = {
+        lowNormal: 0,
+        hiNormal: 50,
+        units: 'mg/dL',
+      };
+
+      expect(selectReferenceRange(undefined, nodeRanges)).toEqual(nodeRanges);
+    });
+
+    it('returns observation-level range when node range is not available', () => {
+      const observationRanges: ReferenceRanges = {
+        lowNormal: 35,
+        hiNormal: 147,
+        units: 'U/L',
+      };
+
+      expect(selectReferenceRange(observationRanges, undefined)).toEqual(observationRanges);
+    });
+
+    it('merges ranges with observation taking precedence', () => {
+      const observationRanges: ReferenceRanges = {
+        lowNormal: 35,
+        hiNormal: 147,
+        lowCritical: 25,
+        units: 'U/L',
+      };
+
+      const nodeRanges: ReferenceRanges = {
+        lowNormal: 0,
+        hiNormal: 270,
+        hiCritical: 541,
+        units: 'U/L',
+      };
+
+      const result = selectReferenceRange(observationRanges, nodeRanges);
+
+      expect(result).toEqual({
+        lowNormal: 35, // From observation
+        hiNormal: 147, // From observation
+        lowCritical: 25, // From observation
+        hiCritical: 541, // From node (observation doesn't have it)
+        units: 'U/L',
+      });
+    });
+
+    it('handles partial observation ranges', () => {
+      const observationRanges: ReferenceRanges = {
+        hiNormal: 147,
+        // Missing lowNormal
+      };
+
+      const nodeRanges: ReferenceRanges = {
+        lowNormal: 0,
+        hiNormal: 270,
+        units: 'U/L',
+      };
+
+      const result = selectReferenceRange(observationRanges, nodeRanges);
+
+      expect(result).toEqual({
+        lowNormal: 0, // From node (observation doesn't have it)
+        hiNormal: 147, // From observation
+        units: 'U/L',
+      });
+    });
+  });
+
+  describe('formatReferenceRange', () => {
+    it('returns "--" when ranges is null', () => {
+      expect(formatReferenceRange(null)).toBe('--');
+    });
+
+    it('formats range with both lowNormal and hiNormal', () => {
+      const ranges: ReferenceRanges = {
+        lowNormal: 0,
+        hiNormal: 50,
+        units: 'mg/dL',
+      };
+
+      expect(formatReferenceRange(ranges)).toBe('0 – 50 mg/dL');
+    });
+
+    it('formats range without units', () => {
+      const ranges: ReferenceRanges = {
+        lowNormal: 0,
+        hiNormal: 50,
+      };
+
+      expect(formatReferenceRange(ranges)).toBe('0 – 50');
+    });
+
+    it('returns "--" when lowNormal or hiNormal is missing', () => {
+      const ranges1: ReferenceRanges = {
+        hiNormal: 50,
+      };
+
+      const ranges2: ReferenceRanges = {
+        lowNormal: 0,
+      };
+
+      expect(formatReferenceRange(ranges1)).toBe('--');
+      expect(formatReferenceRange(ranges2)).toBe('--');
+    });
+
+    it('uses provided units parameter when ranges.units is not available', () => {
+      const ranges: ReferenceRanges = {
+        lowNormal: 0,
+        hiNormal: 50,
+      };
+
+      expect(formatReferenceRange(ranges, 'mg/dL')).toBe('0 – 50 mg/dL');
+    });
+  });
+
+  describe('getMostRecentObservationWithRange', () => {
+    it('returns null when observations array is empty', () => {
+      expect(getMostRecentObservationWithRange([])).toBeNull();
+    });
+
+    it('returns null when no observations have range data', () => {
+      const observations = [
+        { obsDatetime: '2024-01-01', value: '10' },
+        { obsDatetime: '2024-01-02', value: '20' },
+      ];
+
+      expect(getMostRecentObservationWithRange(observations)).toBeNull();
+    });
+
+    it('returns the most recent observation with range data', () => {
+      const observations = [
+        {
+          obsDatetime: '2024-01-01',
+          value: '10',
+          lowNormal: 0,
+          hiNormal: 50,
+        },
+        {
+          obsDatetime: '2024-01-03',
+          value: '30',
+          lowNormal: 35,
+          hiNormal: 147,
+        },
+        {
+          obsDatetime: '2024-01-02',
+          value: '20',
+          // No range data
+        },
+      ];
+
+      const result = getMostRecentObservationWithRange(observations);
+
+      expect(result).toEqual({
+        obsDatetime: '2024-01-03',
+        value: '30',
+        lowNormal: 35,
+        hiNormal: 147,
+      });
+    });
+
+    it('handles observations with only lowNormal', () => {
+      const observations = [
+        {
+          obsDatetime: '2024-01-01',
+          value: '10',
+          lowNormal: 0,
+        },
+      ];
+
+      const result = getMostRecentObservationWithRange(observations);
+
+      expect(result).toEqual({
+        obsDatetime: '2024-01-01',
+        value: '10',
+        lowNormal: 0,
+      });
+    });
+
+    it('handles observations with only hiNormal', () => {
+      const observations = [
+        {
+          obsDatetime: '2024-01-01',
+          value: '10',
+          hiNormal: 50,
+        },
+      ];
+
+      const result = getMostRecentObservationWithRange(observations);
+
+      expect(result).toEqual({
+        obsDatetime: '2024-01-01',
+        value: '10',
+        hiNormal: 50,
+      });
+    });
+
+    it('filters out undefined entries', () => {
+      const observations = [
+        undefined,
+        {
+          obsDatetime: '2024-01-01',
+          value: '10',
+          lowNormal: 0,
+          hiNormal: 50,
+        },
+        undefined,
+      ];
+
+      const result = getMostRecentObservationWithRange(observations);
+
+      expect(result).toEqual({
+        obsDatetime: '2024-01-01',
+        value: '10',
+        lowNormal: 0,
+        hiNormal: 50,
+      });
+    });
+  });
+
+  describe('rangeAlreadyHasUnits', () => {
+    it('returns false when range is undefined', () => {
+      expect(rangeAlreadyHasUnits(undefined, 'U/L')).toBe(false);
+    });
+
+    it('returns false when units is undefined', () => {
+      expect(rangeAlreadyHasUnits('0 – 50', undefined)).toBe(false);
+    });
+
+    it('returns false when both are undefined', () => {
+      expect(rangeAlreadyHasUnits(undefined, undefined)).toBe(false);
+    });
+
+    it('returns true when range ends with units', () => {
+      expect(rangeAlreadyHasUnits('0 – 50 U/L', 'U/L')).toBe(true);
+    });
+
+    it('returns true when range ends with units with space', () => {
+      expect(rangeAlreadyHasUnits('0 – 50 U/L', 'U/L')).toBe(true);
+    });
+
+    it('returns false when range does not end with units', () => {
+      expect(rangeAlreadyHasUnits('0 – 50', 'U/L')).toBe(false);
+    });
+
+    it('returns false when units appear in the middle of range', () => {
+      expect(rangeAlreadyHasUnits('5 mg/dL value', 'mg/dL')).toBe(false);
+    });
+
+    it('handles trimmed strings correctly', () => {
+      expect(rangeAlreadyHasUnits('  0 – 50 U/L  ', '  U/L  ')).toBe(true);
+    });
+
+    it('returns false for empty strings', () => {
+      expect(rangeAlreadyHasUnits('', 'U/L')).toBe(false);
+      expect(rangeAlreadyHasUnits('0 – 50', '')).toBe(false);
+    });
+  });
+
+  describe('formatRangeWithUnits', () => {
+    it('returns "--" when range is undefined', () => {
+      expect(formatRangeWithUnits(undefined, 'U/L')).toBe('--');
+    });
+
+    it('returns "--" when range is empty string', () => {
+      expect(formatRangeWithUnits('', 'U/L')).toBe('--');
+    });
+
+    it('returns range as-is when range already includes units', () => {
+      expect(formatRangeWithUnits('0 – 50 U/L', 'U/L')).toBe('0 – 50 U/L');
+    });
+
+    it('appends units when range does not include units', () => {
+      expect(formatRangeWithUnits('0 – 50', 'U/L')).toBe('0 – 50 U/L');
+    });
+
+    it('returns range without units when units is undefined', () => {
+      expect(formatRangeWithUnits('0 – 50', undefined)).toBe('0 – 50');
+    });
+
+    it('returns range without units when units is empty', () => {
+      expect(formatRangeWithUnits('0 – 50', '')).toBe('0 – 50');
+    });
+
+    it('handles trimmed strings correctly', () => {
+      expect(formatRangeWithUnits('  0 – 50  ', '  U/L  ')).toBe('0 – 50 U/L');
+    });
+
+    it('handles range with units and different units parameter', () => {
+      // If range already has units, don't append different units
+      expect(formatRangeWithUnits('0 – 50 mg/dL', 'U/L')).toBe('0 – 50 mg/dL');
+    });
+  });
+});

package/src/test-results/grouped-timeline/reference-range-helpers.ts

@@ -0,0 +1,161 @@
+import { exist } from '../loadPatientTestData/helpers';
+
+export interface ReferenceRanges {
+  hiAbsolute?: number;
+  hiCritical?: number;
+  hiNormal?: number;
+  lowAbsolute?: number;
+  lowCritical?: number;
+  lowNormal?: number;
+  units?: string;
+}
+
+/**
+ * Merges observation-level and node-level reference ranges.
+ * Observation-level ranges take precedence when available.
+ */
+export function selectReferenceRange(
+  observationRanges?: ReferenceRanges,
+  nodeRanges?: ReferenceRanges,
+): ReferenceRanges | null {
+  if (!observationRanges && !nodeRanges) {
+    return null;
+  }
+
+  if (!observationRanges) {
+    return nodeRanges || null;
+  }
+
+  if (!nodeRanges) {
+    return observationRanges;
+  }
+
+  // Merge: observation takes precedence for available fields.
+  // Note: Units are only at the concept/node level, so units will always come from nodeRanges.
+  return {
+    hiAbsolute: observationRanges.hiAbsolute ?? nodeRanges.hiAbsolute,
+    hiCritical: observationRanges.hiCritical ?? nodeRanges.hiCritical,
+    hiNormal: observationRanges.hiNormal ?? nodeRanges.hiNormal,
+    lowAbsolute: observationRanges.lowAbsolute ?? nodeRanges.lowAbsolute,
+    lowCritical: observationRanges.lowCritical ?? nodeRanges.lowCritical,
+    lowNormal: observationRanges.lowNormal ?? nodeRanges.lowNormal,
+    units: observationRanges.units ?? nodeRanges.units,
+  };
+}
+
+/**
+ * Formats reference range string using lowNormal and hiNormal.
+ * Note: Display format using lowAbsolute/hiAbsolute with >/< is handled in a separate ticket.
+ */
+export function formatReferenceRange(ranges: ReferenceRanges | null, units?: string): string {
+  if (!ranges) {
+    return '--';
+  }
+
+  const { lowNormal, hiNormal } = ranges;
+  const displayUnits = ranges.units || units || '';
+
+  if (exist(lowNormal, hiNormal)) {
+    return `${lowNormal} – ${hiNormal}${displayUnits ? ` ${displayUnits}` : ''}`;
+  }
+
+  return '--';
+}
+
+/**
+ * Checks if a formatted range string already includes the units.
+ * This prevents duplicate units when appending units to a range that already has them.
+ * @param range The formatted range string (e.g., "0 – 50 U/L")
+ * @param units The units string (e.g., "U/L")
+ * @returns true if the range already ends with the units, false otherwise
+ */
+export function rangeAlreadyHasUnits(range: string | undefined, units: string | undefined): boolean {
+  if (!range || !units) {
+    return false;
+  }
+
+  // Check if range ends with units (with optional space before)
+  // This is more precise than includes() to avoid false positives
+  const trimmedRange = range.trim();
+  const trimmedUnits = units.trim();
+  return trimmedRange.endsWith(trimmedUnits) || trimmedRange.endsWith(` ${trimmedUnits}`);
+}
+
+/**
+ * Checks if a range string already contains any units (common unit patterns).
+ * This helps detect if a range already has units even if they differ from the parameter.
+ * @param range The formatted range string (e.g., "0 – 50 mg/dL")
+ * @returns true if the range appears to already contain units, false otherwise
+ */
+function rangeHasAnyUnits(range: string): boolean {
+  if (!range) {
+    return false;
+  }
+
+  const trimmedRange = range.trim();
+  // Common unit patterns: ends with common unit abbreviations or contains unit-like patterns
+  // This is a heuristic to detect if units are already present
+  const unitPattern = /\s+[a-zA-Z\/%°]+$/;
+  return unitPattern.test(trimmedRange);
+}
+
+/**
+ * Formats a reference range with units for display, avoiding duplicate units.
+ * @param range The formatted range string (may or may not include units)
+ * @param units The units string to append if not already present
+ * @returns Formatted string with range and units (e.g., "0 – 50 U/L")
+ */
+export function formatRangeWithUnits(range: string | undefined, units: string | undefined): string {
+  const trimmedRange = range?.trim() || '';
+  const trimmedUnits = units?.trim() || '';
+
+  // If range is empty, return '--' (even if units exist, we need a range to display)
+  if (!trimmedRange) {
+    return '--';
+  }
+
+  // Check if range already includes the specific units parameter
+  const hasSpecificUnits = rangeAlreadyHasUnits(trimmedRange, trimmedUnits);
+  if (hasSpecificUnits) {
+    return trimmedRange;
+  }
+
+  // Check if range already has any units (even if different from parameter)
+  // This prevents appending units when range already has different units (e.g., "0 – 50 mg/dL" with "U/L" parameter)
+  const hasAnyUnits = rangeHasAnyUnits(trimmedRange);
+  if (hasAnyUnits) {
+    return trimmedRange;
+  }
+
+  // Append units if not already present
+  return trimmedUnits ? `${trimmedRange} ${trimmedUnits}` : trimmedRange;
+}
+
+/**
+ * Finds the most recent observation that has reference range data.
+ */
+export function getMostRecentObservationWithRange<
+  T extends { obsDatetime: string; lowNormal?: number; hiNormal?: number },
+>(observations: Array<T | undefined>): T | null {
+  if (!observations || observations.length === 0) {
+    return null;
+  }
+
+  // Filter out undefined and find observations with range data
+  const validObservations = observations.filter(
+    (obs): obs is T => obs !== undefined && (obs.lowNormal !== undefined || obs.hiNormal !== undefined),
+  );
+
+  if (validObservations.length === 0) {
+    return null;
+  }
+
+  // Sort by obsDatetime descending (most recent first)
+  const sorted = [...validObservations].sort((a, b) => {
+    const dateA = new Date(a.obsDatetime).getTime();
+    const dateB = new Date(b.obsDatetime).getTime();
+    return dateB - dateA;
+  });
+
+  return sorted[0];
+}