@openmrs/esm-patient-common-lib 11.3.1-patch.9508 → 11.3.1-pre.10001

package/src/orders/useOrders.ts

@@ -1,7 +1,7 @@
 import { useCallback, useMemo } from 'react';
 import useSWR, { useSWRConfig } from 'swr';
 import { type FetchResponse, openmrsFetch, restBaseUrl, translateFrom } from '@openmrs/esm-framework';
-import type { PatientOrderFetchResponse, PriorityOption } from './types';
+import type { Order, PatientOrderFetchResponse, PriorityOption } from './types';
 
 export type Status = 'ACTIVE' | 'any';
 export const careSettingUuid = '6f0c9a92-6f24-11e3-af88-005056821db0';
@@ -10,11 +10,14 @@ const patientChartAppModuleName = '@openmrs/esm-patient-chart-app';
 export const drugCustomRepresentation =
   'custom:(uuid,dosingType,orderNumber,accessionNumber,' +
   'patient:ref,action,careSetting:ref,previousOrder:ref,dateActivated,scheduledDate,dateStopped,autoExpireDate,' +
-  'orderType:ref,encounter:ref,orderer:(uuid,display,person:(display)),orderReason,orderReasonNonCoded,orderType,urgency,instructions,' +
+  'orderType:ref,encounter:(uuid,display,visit),orderer:(uuid,display,person:(display)),orderReason,orderReasonNonCoded,orderType,urgency,instructions,' +
   'commentToFulfiller,drug:(uuid,display,strength,dosageForm:(display,uuid),concept),dose,doseUnits:ref,' +
   'frequency:ref,asNeeded,asNeededCondition,quantity,quantityUnits:ref,numRefills,dosingInstructions,' +
   'duration,durationUnits:ref,route:ref,brandName,dispenseAsWritten)';
 
+export const orderCustomRepresentation =
+  'custom:(uuid,display,orderNumber,accessionNumber,patient,concept,action,careSetting,previousOrder,dateActivated,scheduledDate,dateStopped,autoExpireDate,encounter:(uuid,display,visit),orderer:ref,orderReason,orderReasonNonCoded,orderType,urgency,instructions,commentToFulfiller,fulfillerStatus)';
+
 export function usePatientOrders(
   patientUuid: string,
   status?: Status,
@@ -23,10 +26,11 @@ export function usePatientOrders(
   endDate?: string,
 ) {
   const { mutate } = useSWRConfig();
+  const activeStatusParams = status === 'ACTIVE' ? '&excludeCanceledAndExpired=true' : '';
   const baseOrdersUrl =
     startDate && endDate
-      ? `${restBaseUrl}/order?patient=${patientUuid}&careSetting=${careSettingUuid}&v=default&activatedOnOrAfterDate=${startDate}&activatedOnOrBeforeDate=${endDate}&excludeDiscontinueOrders=true`
-      : `${restBaseUrl}/order?patient=${patientUuid}&careSetting=${careSettingUuid}&v=default&status=${status}&excludeDiscontinueOrders=true`;
+      ? `${restBaseUrl}/order?patient=${patientUuid}&careSetting=${careSettingUuid}&v=${orderCustomRepresentation}&activatedOnOrAfterDate=${startDate}&activatedOnOrBeforeDate=${endDate}&excludeDiscontinueOrders=true${activeStatusParams}`
+      : `${restBaseUrl}/order?patient=${patientUuid}&careSetting=${careSettingUuid}&v=${orderCustomRepresentation}&status=${status}&excludeDiscontinueOrders=true`;
   const ordersUrl = orderType ? `${baseOrdersUrl}&orderTypes=${orderType}` : baseOrdersUrl;
 
   const { data, error, isLoading, isValidating } = useSWR<FetchResponse<PatientOrderFetchResponse>, Error>(
@@ -36,8 +40,12 @@ export function usePatientOrders(
 
   const mutateOrders = useCallback(
     () =>
-      mutate((key) => typeof key === 'string' && key.startsWith(`${restBaseUrl}/order?patient=${patientUuid}`), data),
-    [data, mutate, patientUuid],
+      mutate(
+        (key) => typeof key === 'string' && key.startsWith(`${restBaseUrl}/order?patient=${patientUuid}`),
+        undefined,
+        { revalidate: true },
+      ),
+    [mutate, patientUuid],
   );
 
   const orders = useMemo(
@@ -60,7 +68,20 @@ export function usePatientOrders(
 }
 
 export function getDrugOrderByUuid(orderUuid: string) {
-  return openmrsFetch(`${restBaseUrl}/order/${orderUuid}?v=${drugCustomRepresentation}`);
+  return openmrsFetch<Order>(`${restBaseUrl}/order/${orderUuid}?v=${drugCustomRepresentation}`);
+}
+
+export function useDrugOrderByUuid(orderUuid: string) {
+  const { data, error, isLoading } = useSWR<FetchResponse<Order>, Error>(
+    orderUuid ? `${restBaseUrl}/order/${orderUuid}?v=${drugCustomRepresentation}` : null,
+    openmrsFetch,
+  );
+
+  return {
+    data: data?.data ?? null,
+    error,
+    isLoading,
+  };
 }
 
 // See the Urgency enum in https://github.com/openmrs/openmrs-core/blob/492dcd35b85d48730bd19da48f6db146cc882c22/api/src/main/java/org/openmrs/Order.java

package/src/results/helpers.test.ts

@@ -0,0 +1,123 @@
+import { type ReferenceRanges } from '../types';
+import { exist, formatReferenceRange, assessValue } from './helpers';
+
+describe('exist', () => {
+  it('returns true when all values are defined', () => {
+    expect(exist(1, 2, 3)).toBe(true);
+    expect(exist(0)).toBe(true);
+    expect(exist('')).toBe(true);
+  });
+
+  it('returns false when any value is null or undefined', () => {
+    expect(exist(null)).toBe(false);
+    expect(exist(undefined)).toBe(false);
+    expect(exist(1, null, 3)).toBe(false);
+    expect(exist(1, undefined)).toBe(false);
+  });
+
+  it('returns true for empty arguments', () => {
+    expect(exist()).toBe(true);
+  });
+});
+
+describe('formatReferenceRange', () => {
+  it('returns formatted range with en-dash', () => {
+    expect(formatReferenceRange({ lowNormal: 35, hiNormal: 147 })).toBe('35 – 147');
+  });
+
+  it('appends units from ranges object', () => {
+    expect(formatReferenceRange({ lowNormal: 35, hiNormal: 147, units: 'U/L' })).toBe('35 – 147 U/L');
+  });
+
+  it('appends units from parameter when ranges.units is absent', () => {
+    expect(formatReferenceRange({ lowNormal: 35, hiNormal: 147 }, 'mg/dL')).toBe('35 – 147 mg/dL');
+  });
+
+  it('prefers ranges.units over the units parameter', () => {
+    expect(formatReferenceRange({ lowNormal: 35, hiNormal: 147, units: 'U/L' }, 'mg/dL')).toBe('35 – 147 U/L');
+  });
+
+  it('returns -- when ranges is null', () => {
+    expect(formatReferenceRange(null)).toBe('--');
+  });
+
+  it('returns -- when lowNormal or hiNormal is missing', () => {
+    expect(formatReferenceRange({ lowNormal: 35 })).toBe('--');
+    expect(formatReferenceRange({ hiNormal: 147 })).toBe('--');
+    expect(formatReferenceRange({})).toBe('--');
+  });
+
+  it('handles zero values correctly', () => {
+    expect(formatReferenceRange({ lowNormal: 0, hiNormal: 10 })).toBe('0 – 10');
+  });
+});
+
+describe('assessValue', () => {
+  const fullRanges: ReferenceRanges = {
+    lowAbsolute: 0,
+    lowCritical: 10,
+    lowNormal: 35,
+    hiNormal: 100,
+    hiCritical: 150,
+    hiAbsolute: 200,
+  };
+
+  it('returns NORMAL for values within range', () => {
+    expect(assessValue(50, fullRanges)).toBe('NORMAL');
+    expect(assessValue(70, fullRanges)).toBe('NORMAL');
+  });
+
+  it('returns NORMAL for NaN', () => {
+    expect(assessValue(NaN, fullRanges)).toBe('NORMAL');
+  });
+
+  it('returns HIGH when value exceeds hiNormal', () => {
+    expect(assessValue(101, fullRanges)).toBe('HIGH');
+    expect(assessValue(149, fullRanges)).toBe('HIGH');
+  });
+
+  it('returns CRITICALLY_HIGH when value reaches hiCritical (inclusive)', () => {
+    expect(assessValue(150, fullRanges)).toBe('CRITICALLY_HIGH');
+    expect(assessValue(175, fullRanges)).toBe('CRITICALLY_HIGH');
+  });
+
+  it('returns OFF_SCALE_HIGH when value reaches hiAbsolute (inclusive)', () => {
+    expect(assessValue(200, fullRanges)).toBe('OFF_SCALE_HIGH');
+    expect(assessValue(999, fullRanges)).toBe('OFF_SCALE_HIGH');
+  });
+
+  it('returns LOW when value is below lowNormal', () => {
+    expect(assessValue(34, fullRanges)).toBe('LOW');
+    expect(assessValue(11, fullRanges)).toBe('LOW');
+  });
+
+  it('returns CRITICALLY_LOW when value reaches lowCritical (inclusive)', () => {
+    expect(assessValue(10, fullRanges)).toBe('CRITICALLY_LOW');
+    expect(assessValue(5, fullRanges)).toBe('CRITICALLY_LOW');
+  });
+
+  it('returns OFF_SCALE_LOW when value reaches lowAbsolute (inclusive)', () => {
+    expect(assessValue(0, fullRanges)).toBe('OFF_SCALE_LOW');
+    expect(assessValue(-5, fullRanges)).toBe('OFF_SCALE_LOW');
+  });
+
+  // Boundary behavior: normal thresholds are exclusive, critical/absolute are inclusive
+  it('treats values at hiNormal as NORMAL (exclusive)', () => {
+    expect(assessValue(100, fullRanges)).toBe('NORMAL');
+  });
+
+  it('treats values at lowNormal as NORMAL (exclusive)', () => {
+    expect(assessValue(35, fullRanges)).toBe('NORMAL');
+  });
+
+  it('works with only normal thresholds', () => {
+    const normalOnly: ReferenceRanges = { lowNormal: 35, hiNormal: 100 };
+    expect(assessValue(50, normalOnly)).toBe('NORMAL');
+    expect(assessValue(101, normalOnly)).toBe('HIGH');
+    expect(assessValue(34, normalOnly)).toBe('LOW');
+  });
+
+  it('returns NORMAL when no thresholds are provided', () => {
+    expect(assessValue(50, {})).toBe('NORMAL');
+  });
+});

package/src/results/helpers.ts

@@ -0,0 +1,63 @@
+import { type OBSERVATION_INTERPRETATION, type ReferenceRanges } from '../types';
+
+/**
+ * Checks if all provided values exist (are not null or undefined).
+ */
+export function exist(...args: unknown[]): boolean {
+  return args.every((y) => y !== null && y !== undefined);
+}
+
+/**
+ * Formats reference range as a string with optional units.
+ * Uses en-dash (–) for range separator.
+ *
+ * @param ranges - The reference ranges object
+ * @param units - Optional units string to append
+ * @returns Formatted string like "35 – 147 U/L" or "--" if no valid range
+ */
+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 '--';
+}
+
+/**
+ * Determines the interpretation of a lab value based on reference ranges.
+ * Returns the appropriate interpretation level based on the value's
+ * relationship to normal, critical, and absolute thresholds.
+ *
+ * @param value - The numeric lab result value
+ * @param ranges - The reference ranges to compare against
+ * @returns The interpretation category
+ */
+export function assessValue(value: number, ranges: ReferenceRanges): OBSERVATION_INTERPRETATION {
+  if (isNaN(value)) {
+    return 'NORMAL';
+  }
+  // Critical and absolute thresholds use inclusive (>=, <=) comparisons
+  // because values at those boundaries should be flagged for clinical safety.
+  // Normal thresholds use exclusive (>, <) so values at the boundary are still normal.
+  if (exist(ranges.hiAbsolute) && value >= ranges.hiAbsolute!) {
+    return 'OFF_SCALE_HIGH';
+  }
+  if (exist(ranges.hiCritical) && value >= ranges.hiCritical!) {
+    return 'CRITICALLY_HIGH';
+  }
+  if (exist(ranges.hiNormal) && value > ranges.hiNormal!) {
+    return 'HIGH';
+  }
+  if (exist(ranges.lowAbsolute) && value <= ranges.lowAbsolute!) {
+    return 'OFF_SCALE_LOW';
+  }
+  if (exist(ranges.lowCritical) && value <= ranges.lowCritical!) {
+    return 'CRITICALLY_LOW';
+  }
+  if (exist(ranges.lowNormal) && value < ranges.lowNormal!) {
+    return 'LOW';
+  }
+  return 'NORMAL';
+}

package/src/results/index.ts

@@ -0,0 +1,3 @@
+export * from './helpers';
+export * from './useReferenceRanges';
+export { ReferenceRangeDisplay } from './reference-range-display.component';

package/src/results/reference-range-display.component.tsx

@@ -0,0 +1,25 @@
+import React from 'react';
+import { useTranslation } from 'react-i18next';
+import { type ReferenceRanges } from '../types';
+import { formatReferenceRange } from './helpers';
+import styles from './results.scss';
+
+interface ReferenceRangeDisplayProps {
+  ranges: ReferenceRanges | null;
+  units?: string;
+}
+
+/**
+ * Displays a formatted reference range with units.
+ * Shows "N/A" when no valid range is available.
+ */
+export const ReferenceRangeDisplay: React.FC<ReferenceRangeDisplayProps> = ({ ranges, units }) => {
+  const { t } = useTranslation();
+  const formatted = formatReferenceRange(ranges, units);
+
+  if (formatted === '--') {
+    return <span className={styles.noRange}>{t('notApplicable', 'N/A')}</span>;
+  }
+
+  return <span className={styles.referenceRange}>{formatted}</span>;
+};

package/src/results/results.scss

@@ -0,0 +1,11 @@
+@use '@carbon/colors';
+@use '@carbon/type';
+@use '@openmrs/esm-styleguide/src/vars' as *;
+
+.referenceRange {
+  @include type.type-style('body-compact-01');
+}
+
+.noRange {
+  color: colors.$gray-50;
+}

package/src/results/useReferenceRanges.ts

@@ -0,0 +1,72 @@
+import { useMemo } from 'react';
+import useSWR from 'swr';
+import { openmrsFetch, restBaseUrl, type FetchResponse } from '@openmrs/esm-framework';
+import { type ReferenceRanges } from '../types';
+
+interface ReferenceRangeResponse {
+  uuid: string;
+  concept: string;
+  lowNormal?: number;
+  hiNormal?: number;
+  lowAbsolute?: number;
+  hiAbsolute?: number;
+  lowCritical?: number;
+  hiCritical?: number;
+  units?: string;
+}
+
+export interface UseReferenceRangesResult {
+  ranges: Map<string, ReferenceRanges>;
+  isLoading: boolean;
+  error: Error | undefined;
+  mutate: () => void;
+}
+
+/**
+ * Fetches patient-specific reference ranges for given concepts.
+ * Uses the /conceptreferencerange REST API endpoint.
+ *
+ * @param patientUuid - The UUID of the patient (optional; when absent, no request is made)
+ * @param conceptUuids - Array of concept UUIDs to fetch ranges for
+ * @returns Object containing ranges map, loading state, error, and mutate function
+ */
+export function useReferenceRanges(
+  patientUuid: string | undefined,
+  conceptUuids: Array<string>,
+): UseReferenceRangesResult {
+  const conceptList = conceptUuids.filter(Boolean).join(',');
+  const apiUrl =
+    patientUuid && conceptList
+      ? `${restBaseUrl}/conceptreferencerange?patient=${patientUuid}&concept=${conceptList}&v=full`
+      : null;
+
+  const { data, error, isLoading, mutate } = useSWR<FetchResponse<{ results: Array<ReferenceRangeResponse> }>, Error>(
+    apiUrl,
+    openmrsFetch,
+  );
+
+  const rangesMap = useMemo(() => {
+    const map = new Map<string, ReferenceRanges>();
+    data?.data?.results?.forEach((range) => {
+      if (range.concept) {
+        map.set(range.concept, {
+          lowNormal: range.lowNormal,
+          hiNormal: range.hiNormal,
+          lowAbsolute: range.lowAbsolute,
+          hiAbsolute: range.hiAbsolute,
+          lowCritical: range.lowCritical,
+          hiCritical: range.hiCritical,
+          units: range.units,
+        });
+      }
+    });
+    return map;
+  }, [data]);
+
+  return {
+    ranges: rangesMap,
+    isLoading,
+    error,
+    mutate,
+  };
+}

package/src/types/test-results.ts

@@ -39,8 +39,19 @@ export type OBSERVATION_INTERPRETATION =
   | 'LOW'
   | 'CRITICALLY_LOW'
   | 'OFF_SCALE_LOW'
+  // Legacy sentinel for "no data"; avoid new usage and prefer undefined instead.
   | '--';
 
+export interface ReferenceRanges {
+  hiAbsolute?: number;
+  hiCritical?: number;
+  hiNormal?: number;
+  lowAbsolute?: number;
+  lowCritical?: number;
+  lowNormal?: number;
+  units?: string;
+}
+
 export interface ExternalOverviewProps {
   patientUuid: string;
   filter: (filterProps: PanelFilterProps) => boolean;

package/src/visit/revalidation-utils.test.ts

@@ -2,6 +2,7 @@ import {
   invalidateVisitHistory,
   invalidatePatientEncounters,
   invalidateVisitAndEncounterData,
+  invalidateCurrentVisit,
 } from './revalidation-utils';
 
 const mockMutate = jest.fn();
@@ -95,4 +96,30 @@ describe('revalidation-utils', () => {
       expect(encounterMatcherFn('/ws/rest/v1/encounter?patient=test-patient-123&v=custom')).toBe(true);
     });
   });
+
+  describe('invalidateCurrentVisit', () => {
+    it('should invalidate only current visit keys', () => {
+      const patientUuid = 'test-patient-123';
+
+      invalidateCurrentVisit(mockMutate, patientUuid);
+
+      expect(mockMutate).toHaveBeenCalledTimes(1);
+      expect(mockMutate).toHaveBeenCalledWith(expect.any(Function));
+
+      const matcherFn = mockMutate.mock.calls[0][0];
+
+      // Should match current visit key (includeInactive=false)
+      expect(matcherFn('/ws/rest/v1/visit?patient=test-patient-123&v=custom&includeInactive=false')).toBe(true);
+
+      // Should not match other visit keys
+      expect(matcherFn('/ws/rest/v1/visit?patient=test-patient-123&v=custom&includeInactive=true')).toBe(false);
+      expect(
+        matcherFn('/ws/rest/v1/visit?patient=test-patient-123&v=custom&limit=10&startIndex=0&totalCount=true'),
+      ).toBe(false);
+      expect(matcherFn('/ws/rest/v1/visit/test-patient-123')).toBe(false);
+
+      // Should not match encounter keys
+      expect(matcherFn('/ws/rest/v1/encounter?patient=test-patient-123&v=custom')).toBe(false);
+    });
+  });
 });

package/src/visit/revalidation-utils.ts

@@ -81,6 +81,24 @@ export function invalidatePatientEncounters(mutate: KeyedMutator<unknown>, patie
   });
 }
 
+/**
+ * Invalidates only the current (active) visit cache for a specific patient.
+ *
+ * This refreshes components using useVisit without triggering the visit revalidation cascade.
+ *
+ * @param mutate - SWR mutate function from useSWRConfig()
+ * @param patientUuid - Patient UUID to target current visit data for
+ */
+export function invalidateCurrentVisit(mutate: KeyedMutator<unknown>, patientUuid: string): void {
+  mutate((key) => {
+    return (
+      typeof key === 'string' &&
+      key.includes(`${restBaseUrl}/visit?patient=${patientUuid}`) &&
+      key.includes('includeInactive=false')
+    );
+  });
+}
+
 /**
  * Combination utility that invalidates both visit history and encounter data.
  *

package/src/visit/visit-mutations.ts

@@ -30,7 +30,7 @@ export function useOptimisticVisitMutations(patientUuid: string) {
     (visitUuid: string, updates: Partial<Visit>) => {
       // Update current visit SWR cache if it matches
       if (visitContext?.uuid === visitUuid) {
-        mutateVisitContext();
+        mutateVisitContext?.();
       }
 
       // Update visit lists across all hooks using regex pattern matching
@@ -82,7 +82,7 @@ export function useOptimisticVisitMutations(patientUuid: string) {
 
       // If deleted visit was current, revalidate current visit to get new state
       if (visitContext?.uuid === visitUuid) {
-        mutateVisitContext();
+        mutateVisitContext?.();
       }
     },
     [visitContext, mutateVisitContext, mutate, patientUuid],

package/src/workspaces.ts

@@ -1,23 +1,31 @@
 import { useCallback } from 'react';
 import {
-  type DefaultWorkspaceProps,
-  launchWorkspace,
-  navigateAndLaunchWorkspace,
+  launchWorkspace2,
+  navigate,
   showModal,
   useFeatureFlag,
   type Visit,
+  type Workspace2DefinitionProps,
 } from '@openmrs/esm-framework';
-import { launchStartVisitPrompt } from './launchStartVisitPrompt';
 import { usePatientChartStore } from './store/patient-chart-store';
 import { useSystemVisitSetting } from './useSystemVisitSetting';
 
-export interface DefaultPatientWorkspaceProps extends DefaultWorkspaceProps {
+export interface PatientWorkspaceGroupProps {
   patient: fhir.Patient;
   patientUuid: string;
   visitContext: Visit;
   mutateVisitContext: () => void;
 }
 
+export interface PatientChartWorkspaceActionButtonProps {
+  groupProps: PatientWorkspaceGroupProps;
+}
+
+export type PatientWorkspace2DefinitionProps<
+  WorkspaceProps extends object,
+  WindowProps extends object,
+> = Workspace2DefinitionProps<WorkspaceProps, WindowProps, PatientWorkspaceGroupProps>;
+
 export function launchPatientChartWithWorkspaceOpen({
   patientUuid,
   workspaceName,
@@ -29,37 +37,55 @@ export function launchPatientChartWithWorkspaceOpen({
   dashboardName?: string;
   additionalProps?: object;
 }) {
-  navigateAndLaunchWorkspace({
-    targetUrl: '${openmrsSpaBase}/patient/' + `${patientUuid}/chart` + (dashboardName ? `/${dashboardName}` : ''),
-    workspaceName: workspaceName,
-    contextKey: `patient/${patientUuid}`,
-    additionalProps,
-  });
+  launchWorkspace2(workspaceName, additionalProps);
+  navigate({ to: '${openmrsSpaBase}/patient/' + `${patientUuid}/chart` + (dashboardName ? `/${dashboardName}` : '') });
 }
 
 export function useLaunchWorkspaceRequiringVisit<T extends object>(patientUuid: string, workspaceName: string) {
+  const startVisitIfNeeded = useStartVisitIfNeeded(patientUuid);
+  const launchPatientWorkspaceCb = useCallback(
+    (workspaceProps?: T, windowProps?: any, groupProps?: any) => {
+      startVisitIfNeeded().then((didStartVisit) => {
+        if (didStartVisit) {
+          launchWorkspace2(workspaceName, workspaceProps, windowProps, groupProps);
+        }
+      });
+    },
+    [startVisitIfNeeded, workspaceName],
+  );
+  return launchPatientWorkspaceCb;
+}
+
+export function useStartVisitIfNeeded(patientUuid: string) {
   const { visitContext } = usePatientChartStore(patientUuid);
   const { systemVisitEnabled } = useSystemVisitSetting();
   const isRdeEnabled = useFeatureFlag('rde');
 
-  const launchPatientWorkspaceCb = useCallback(
-    (additionalProps?: T) => {
-      if (!systemVisitEnabled || visitContext) {
-        launchWorkspace(workspaceName, additionalProps);
-      } else {
+  const startVisitIfNeeded = useCallback(async (): Promise<boolean> => {
+    if (!systemVisitEnabled || visitContext) {
+      return true;
+    } else {
+      return new Promise<boolean>((resolve) => {
         if (isRdeEnabled) {
           const dispose = showModal('visit-context-switcher', {
             patientUuid,
-            closeModal: () => dispose(),
-            onAfterVisitSelected: () => launchWorkspace(workspaceName, additionalProps),
+            closeModal: () => {
+              dispose();
+              resolve(false);
+            },
+            onAfterVisitSelected: () => {
+              resolve(true);
+            },
             size: 'sm',
           });
         } else {
-          launchStartVisitPrompt();
+          const dispose = showModal('start-visit-dialog', {
+            closeModal: () => dispose(),
+            onVisitStarted: () => resolve(true),
+          });
         }
-      }
-    },
-    [visitContext, systemVisitEnabled, workspaceName, isRdeEnabled, patientUuid],
-  );
-  return launchPatientWorkspaceCb;
+      });
+    }
+  }, [visitContext, systemVisitEnabled, isRdeEnabled, patientUuid]);
+  return startVisitIfNeeded;
 }