@openmrs/esm-patient-common-lib 11.3.1-patch.9064 → 11.3.1-patch.9310

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openmrs/esm-patient-common-lib",
-  "version": "11.3.1-patch.9064",
+  "version": "11.3.1-patch.9310",
   "license": "MPL-2.0",
   "description": "Library for common patient chart components",
   "browser": "dist/openmrs-esm-patient-common-lib.js",

package/src/empty-state/empty-state.test.tsx

@@ -1,10 +1,10 @@
 import React from 'react';
 import userEvent from '@testing-library/user-event';
 import { render, screen } from '@testing-library/react';
-import { launchWorkspace } from '@openmrs/esm-framework';
+import { launchWorkspace2 } from '@openmrs/esm-framework';
 import { EmptyState } from '.';
 
-const mockLaunchWorkspace = jest.mocked(launchWorkspace);
+const mockLaunchWorkspace = jest.mocked(launchWorkspace2);
 
 describe('EmptyState', () => {
   it('renders an empty state widget card', () => {
@@ -12,7 +12,7 @@ describe('EmptyState', () => {
       <EmptyState
         headerTitle="appointments"
         displayText="appointments"
-        launchForm={() => launchWorkspace('sample-form-workspace')}
+        launchForm={() => launchWorkspace2('sample-form-workspace')}
       />,
     );
 
@@ -28,7 +28,7 @@ describe('EmptyState', () => {
       <EmptyState
         headerTitle="appointments"
         displayText="appointments"
-        launchForm={() => launchWorkspace('sample-form-workspace')}
+        launchForm={() => launchWorkspace2('sample-form-workspace')}
       />,
     );
 

package/src/form-entry/form-entry.ts

@@ -1,4 +1,4 @@
-import { type HtmlFormEntryForm } from '../types';
+import { type Encounter, type Visit, type Workspace2DefinitionProps } from '@openmrs/esm-framework';
 
 export interface FormEntryProps {
   encounterUuid?: string;
@@ -7,6 +7,26 @@ export interface FormEntryProps {
   visitTypeUuid?: string;
   visitStartDatetime?: string;
   visitStopDatetime?: string;
-  htmlForm?: HtmlFormEntryForm;
   additionalProps?: Record<string, any>;
 }
+
+/**
+ * Workspace control props are made optional to support usage in non-workspace contexts,
+ * such as the Fast Data Entry app or other standalone form zones.
+ */
+export interface FormRendererProps {
+  additionalProps?: Record<string, any>;
+  encounterUuid?: string;
+  formUuid: string;
+  patientUuid: string;
+  patient: fhir.Patient;
+  visit?: Visit;
+  visitUuid?: string;
+  hideControls?: boolean;
+  hidePatientBanner?: boolean;
+  handlePostResponse?: (encounter: Encounter) => void;
+  preFilledQuestions?: Record<string, string>;
+  launchChildWorkspace?: Workspace2DefinitionProps['launchChildWorkspace'];
+  closeWorkspace?: Workspace2DefinitionProps['closeWorkspace'];
+  setHasUnsavedChanges?(hasUnsavedChanges: boolean);
+}

package/src/index.ts

@@ -3,7 +3,6 @@ export * from './compare';
 export * from './dashboards/createDashboardLink';
 export * from './empty-state';
 export * from './error-state';
-export * from './form-entry-interop';
 export * from './form-entry/form-entry';
 export * from './launchStartVisitPrompt';
 export * from './offline/visit';

package/src/launchStartVisitPrompt.tsx

@@ -1,7 +1,8 @@
 import { showModal } from '@openmrs/esm-framework';
 
-export function launchStartVisitPrompt() {
+export async function launchStartVisitPrompt(onVisitStarted?: () => void) {
   const dispose = showModal('start-visit-dialog', {
     closeModal: () => dispose(),
+    onVisitStarted,
   });
 }

package/src/offline/visit.ts

@@ -5,7 +5,7 @@ import {
   queueSynchronizationItem,
   useConnectivity,
   useSession,
-  useVisit,
+  type useVisit,
   type Visit,
 } from '@openmrs/esm-framework';
 import { useEffect, useState } from 'react';
@@ -23,20 +23,6 @@ export interface OfflineVisit extends NewVisitPayload {
   uuid: string;
 }
 
-/**
- * Similar to {@link useVisit}, returns the given patient's active visit, but also considers
- * offline visits created by the patient chart while offline.
- * @param patientUuid The UUID of the patient.
- */
-export function useVisitOrOfflineVisit(patientUuid: string) {
-  const isOnline = useConnectivity();
-
-  const onlineVisit = useVisit(patientUuid);
-  const offlineVisit = useOfflineVisit(patientUuid);
-
-  return isOnline ? onlineVisit : offlineVisit;
-}
-
 /**
  * Returns the patient's current offline visit.
  * @param patientUuid The UUID of the patient.
@@ -132,7 +118,7 @@ export async function createOfflineVisitForPatient(
   };
 
   await queueSynchronizationItem(visitSyncType, offlineVisit, descriptor);
-  return offlineVisit;
+  return offlineVisitToVisit(offlineVisit);
 }
 
 function offlineVisitToVisit(offlineVisit: OfflineVisit): Visit {

package/src/orders/index.ts

@@ -1,7 +1,9 @@
-export * from './useOrderBasket';
 export * from './postOrders';
-export * from './useOrders';
+export * from './showOrderSuccessToast';
 export * from './types';
+export * from './useMutatePatientOrders';
+export * from './useOrderBasket';
 export * from './useOrderableConceptSets';
+export * from './useOrders';
 export * from './useOrderType';
 export * from './useOrderTypes';

package/src/orders/postOrders.ts

@@ -120,7 +120,7 @@ export async function postOrders(patientUuid: string, encounterUuid: string, abo
   return erroredItems;
 }
 
-function postOrder(body: OrderPost, abortController?: AbortController) {
+export function postOrder(body: OrderPost, abortController?: AbortController) {
   return openmrsFetch(`${restBaseUrl}/order`, {
     method: 'POST',
     signal: abortController?.signal,

package/src/orders/showOrderSuccessToast.ts

@@ -0,0 +1,28 @@
+import { showSnackbar } from '@openmrs/esm-framework';
+import { type TFunction } from 'i18next';
+import { type OrderBasketItem } from './types';
+
+export function showOrderSuccessToast(t: TFunction, patientOrderItems: OrderBasketItem[]) {
+  const orderedString = patientOrderItems
+    .filter((item) => ['NEW', 'RENEW'].includes(item.action))
+    .map((item) => item.display)
+    .join(', ');
+  const updatedString = patientOrderItems
+    .filter((item) => item.action === 'REVISE')
+    .map((item) => item.display)
+    .join(', ');
+  const discontinuedString = patientOrderItems
+    .filter((item) => item.action === 'DISCONTINUE')
+    .map((item) => item.display)
+    .join(', ');
+
+  showSnackbar({
+    isLowContrast: true,
+    kind: 'success',
+    title: t('orderCompleted', 'Placed orders'),
+    subtitle:
+      (orderedString && `${t('ordered', 'Placed order for')} ${orderedString}. `) +
+      (updatedString && `${t('updated', 'Updated')} ${updatedString}. `) +
+      (discontinuedString && `${t('discontinued', 'Discontinued')} ${discontinuedString}.`),
+  });
+}

package/src/orders/types/order.ts

@@ -1,4 +1,4 @@
-import type { OpenmrsResource } from '@openmrs/esm-framework';
+import type { Encounter, OpenmrsResource, Visit, Workspace2DefinitionProps } from '@openmrs/esm-framework';
 
 export interface Concept extends OpenmrsResource {
   name?: {
@@ -71,6 +71,8 @@ export interface OrderBasketItem {
   orderType?: string;
   orderNumber?: string;
   scheduledDate?: Date;
+  encounterUuid?: string;
+  visit: Visit;
 }
 
 export type OrderUrgency = 'ROUTINE' | 'STAT' | 'ON_SCHEDULED_DATE';
@@ -142,7 +144,7 @@ export interface Order {
   drug: Drug;
   duration: number;
   durationUnits: OpenmrsResource;
-  encounter: OpenmrsResource;
+  encounter: Encounter;
   frequency: OpenmrsResource;
   instructions?: string | null;
   numRefills: number;
@@ -207,16 +209,114 @@ export interface OrderType {
   description: string;
 }
 
-export type FulfillerStatus =
-  | 'RECEIVED'
-  | 'IN_PROGRESS'
-  | 'EXCEPTION'
-  | 'ON_HOLD'
-  | 'DECLINED'
-  | 'COMPLETED';
+export type FulfillerStatus = 'RECEIVED' | 'IN_PROGRESS' | 'EXCEPTION' | 'ON_HOLD' | 'DECLINED' | 'COMPLETED';
 
 export type PostDataPrepFunction = (
   order: OrderBasketItem,
   patientUuid: string,
   encounterUuid: string | null,
 ) => OrderPost;
+
+export interface OrderBasketExtensionProps {
+  patient: fhir.Patient;
+  launchDrugOrderForm(order?: DrugOrderBasketItem): void;
+  launchLabOrderForm(orderTypeUuid: string, order?: TestOrderBasketItem): void;
+  launchGeneralOrderForm(orderTypeUuid: string, order?: OrderBasketItem): void;
+}
+
+export interface DrugOrderBasketItem extends OrderBasketItem {
+  drug: Drug;
+  unit: DosingUnit;
+  commonMedicationName: string;
+  dosage: number;
+  frequency: MedicationFrequency;
+  route: MedicationRoute;
+  quantityUnits: QuantityUnit;
+  patientInstructions: string;
+  asNeeded: boolean;
+  asNeededCondition: string;
+  startDate: Date | string;
+  durationUnit: DurationUnit;
+  duration: number | null;
+  pillsDispensed: number | null;
+  numRefills: number | null;
+  indication: string;
+  isFreeTextDosage: boolean;
+  freeTextDosage: string;
+  previousOrder?: string;
+  template?: OrderTemplate;
+}
+
+export interface DrugOrderTemplate {
+  uuid: string;
+  name: string;
+  drug: Drug;
+  template: OrderTemplate;
+}
+
+export interface OrderTemplate {
+  type: string;
+  dosingType: string;
+  dosingInstructions: DosingInstructions;
+}
+
+export interface DosingInstructions {
+  dose: Array<MedicationDosage>;
+  units: Array<DosingUnit>;
+  route: Array<MedicationRoute>;
+  frequency: Array<MedicationFrequency>;
+  instructions?: Array<MedicationInstructions>;
+  durationUnits?: Array<DurationUnit>;
+  quantityUnits?: Array<QuantityUnit>;
+  asNeeded?: boolean;
+  asNeededCondition?: string;
+}
+
+export interface MedicationDosage extends Omit<CommonMedicationProps, 'value'> {
+  value: number;
+}
+
+export type MedicationFrequency = CommonMedicationValueCoded;
+
+export type MedicationRoute = CommonMedicationValueCoded;
+
+export type MedicationInstructions = CommonMedicationProps;
+
+export type DosingUnit = CommonMedicationValueCoded;
+
+export type QuantityUnit = CommonMedicationValueCoded;
+
+export type DurationUnit = CommonMedicationValueCoded;
+
+interface CommonMedicationProps {
+  value: string;
+  default?: boolean;
+}
+
+export interface CommonMedicationValueCoded extends CommonMedicationProps {
+  valueCoded: string;
+  names?: string[];
+}
+export interface TestOrderBasketItem extends OrderBasketItem {
+  testType: {
+    label: string;
+    conceptUuid: string;
+  };
+  orderReason?: string;
+  specimenSource?: string;
+}
+
+export interface OrderBasketWindowProps {
+  encounterUuid: string;
+}
+
+export interface ExportedOrderBasketWindowProps {
+  encounterUuid: string;
+  drugOrderWorkspaceName: string;
+  labOrderWorkspaceName: string;
+  generalOrderWorkspaceName: string;
+  patient: fhir.Patient;
+  patientUuid: string;
+  visitContext: Visit;
+  mutateVisitContext: () => void;
+}

package/src/orders/useMutatePatientOrders.ts

@@ -0,0 +1,24 @@
+import { restBaseUrl } from '@openmrs/esm-framework';
+import { useCallback } from 'react';
+import { useSWRConfig } from 'swr';
+
+/**
+ * Returns a function which refreshes the patient orders cache. Uses SWR's mutate function.
+ * Refreshes patient orders for all kinds of orders.
+ *
+ * @param patientUuid The UUID of the patient to get an order mutate function for.
+ */
+export function useMutatePatientOrders(patientUuid: string) {
+  const { mutate } = useSWRConfig();
+  const mutateOrders = useCallback(
+    () =>
+      mutate((key) => {
+        return typeof key === 'string' && key.startsWith(`${restBaseUrl}/order?patient=${patientUuid}`);
+      }),
+    [patientUuid, mutate],
+  );
+
+  return {
+    mutate: mutateOrders,
+  };
+}

package/src/orders/useOrderBasket.test.tsx

@@ -2,6 +2,7 @@ import { act, renderHook } from '@testing-library/react';
 import { useOrderBasket } from './useOrderBasket';
 import { type OrderBasketItem, type PostDataPrepFunction } from './types';
 import { _resetOrderBasketStore } from './store';
+import { mockFhirPatient } from '__mocks__';
 
 const mockDrugOrderBasketItem = {
   action: 'NEW',
@@ -19,7 +20,9 @@ describe('useOrderBasket', () => {
   });
 
   it('returns the correct list of orders given a grouping', () => {
-    const { result } = renderHook(() => useOrderBasket('medications', ((x) => x) as unknown as PostDataPrepFunction));
+    const { result } = renderHook(() =>
+      useOrderBasket(mockFhirPatient, 'medications', ((x) => x) as unknown as PostDataPrepFunction),
+    );
     expect(result.current.orders).toEqual([]);
     act(() => {
       result.current.setOrders([mockDrugOrderBasketItem]);
@@ -29,10 +32,10 @@ describe('useOrderBasket', () => {
 
   it('can modify items in one grouping without affecting the other', () => {
     const { result: drugResult } = renderHook(() =>
-      useOrderBasket('medications', ((x) => x) as unknown as PostDataPrepFunction),
+      useOrderBasket(mockFhirPatient, 'medications', ((x) => x) as unknown as PostDataPrepFunction),
     );
     const { result: labResult } = renderHook(() =>
-      useOrderBasket('labs', ((x) => x) as unknown as PostDataPrepFunction),
+      useOrderBasket(mockFhirPatient, 'labs', ((x) => x) as unknown as PostDataPrepFunction),
     );
     expect(drugResult.current.orders).toEqual([]);
     expect(labResult.current.orders).toEqual([]);

package/src/orders/useOrderBasket.ts

@@ -1,16 +1,15 @@
 import { type Actions, useStoreWithActions } from '@openmrs/esm-framework';
 import type { OrderBasketItem, PostDataPrepFunction } from './types';
-import { getPatientUuidFromStore } from '../store/patient-chart-store';
 import { useEffect } from 'react';
 import { type OrderBasketStore, orderBasketStore } from './store';
 
 const orderBasketStoreActions = {
   setOrderBasketItems(
     state: OrderBasketStore,
+    patientUuid: string,
     grouping: string,
     value: Array<OrderBasketItem> | (() => Array<OrderBasketItem>),
   ) {
-    const patientUuid = getPatientUuidFromStore();
     if (!Object.keys(state.postDataPrepFunctions).includes(grouping)) {
       console.warn(`Programming error: You must register a postDataPrepFunction for grouping ${grouping} `);
     }
@@ -34,8 +33,11 @@ const orderBasketStoreActions = {
   },
 } satisfies Actions<OrderBasketStore>;
 
-function getOrderItems(items: OrderBasketStore['items'], grouping?: string | null): Array<OrderBasketItem> {
-  const patientUuid = getPatientUuidFromStore();
+function getOrderItems(
+  patientUuid: string,
+  items: OrderBasketStore['items'],
+  grouping?: string | null,
+): Array<OrderBasketItem> {
   const patientItems = items?.[patientUuid] ?? {};
   return grouping ? patientItems[grouping] ?? [] : Object.values(patientItems).flat();
 }
@@ -44,9 +46,8 @@ export interface ClearOrdersOptions {
   exceptThoseMatching: (order: OrderBasketItem) => boolean;
 }
 
-function clearOrders(options?: ClearOrdersOptions) {
+function clearOrders(patientUuid: string, options?: ClearOrdersOptions) {
   const exceptThoseMatchingFcn = options?.exceptThoseMatching ?? (() => false);
-  const patientUuid = getPatientUuidFromStore();
   const items = orderBasketStore.getState().items;
   const patientItems = items[patientUuid] ?? {};
   const newPatientItems = Object.fromEntries(
@@ -77,13 +78,18 @@ type UseOrderBasketReturn<T, U> = {
  *  A PostDataPrepFunction must be provided for each grouping, but does not necessarily have to be provided
  *  in every usage of useOrderBasket with a grouping key.
  */
-export function useOrderBasket<T extends OrderBasketItem>(): UseOrderBasketReturn<T, void>;
-export function useOrderBasket<T extends OrderBasketItem>(grouping: string): UseOrderBasketReturn<T, string>;
+export function useOrderBasket<T extends OrderBasketItem>(patient: fhir.Patient): UseOrderBasketReturn<T, void>;
 export function useOrderBasket<T extends OrderBasketItem>(
+  patient: fhir.Patient,
+  grouping: string,
+): UseOrderBasketReturn<T, string>;
+export function useOrderBasket<T extends OrderBasketItem>(
+  patient: fhir.Patient,
   grouping: string,
   postDataPrepFunction: PostDataPrepFunction,
 ): UseOrderBasketReturn<T, string>;
 export function useOrderBasket<T extends OrderBasketItem>(
+  patient: fhir.Patient,
   grouping?: string | null,
   postDataPrepFunction?: PostDataPrepFunction,
 ): UseOrderBasketReturn<T, string | void> {
@@ -91,7 +97,7 @@ export function useOrderBasket<T extends OrderBasketItem>(
     orderBasketStore,
     orderBasketStoreActions,
   );
-  const orders = getOrderItems(items, grouping);
+  const orders = getOrderItems(patient.id, items, grouping);
 
   useEffect(() => {
     if (postDataPrepFunction && !postDataPrepFunctions[grouping]) {
@@ -99,15 +105,19 @@ export function useOrderBasket<T extends OrderBasketItem>(
     }
   }, [postDataPrepFunction, grouping, postDataPrepFunctions, setPostDataPrepFunctionForGrouping]);
 
+  const clearOrdersForPatient = (options?: ClearOrdersOptions) => {
+    clearOrders(patient.id, options);
+  };
+
   if (typeof grouping === 'string') {
     const setOrders = (value: Array<T> | (() => Array<T>)) => {
-      return setOrderBasketItems(grouping, value);
+      return setOrderBasketItems(patient.id, grouping, value);
     };
-    return { orders, clearOrders, setOrders } as UseOrderBasketReturn<T, string>;
+    return { orders, clearOrders: clearOrdersForPatient, setOrders } as UseOrderBasketReturn<T, string>;
   } else {
     const setOrders = (groupingKey: string, value: Array<T> | (() => Array<T>)) => {
-      setOrderBasketItems(groupingKey, value);
+      setOrderBasketItems(patient.id, groupingKey, value);
     };
-    return { orders, clearOrders, setOrders } as UseOrderBasketReturn<T, void>;
+    return { orders, clearOrders: clearOrdersForPatient, setOrders } as UseOrderBasketReturn<T, void>;
   }
 }

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,7 +10,7 @@ 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)';
@@ -25,8 +25,8 @@ export function usePatientOrders(
   const { mutate } = useSWRConfig();
   const baseOrdersUrl =
     startDate && endDate
-      ? `${restBaseUrl}/order?patient=${patientUuid}&careSetting=${careSettingUuid}&v=full&activatedOnOrAfterDate=${startDate}&activatedOnOrBeforeDate=${endDate}`
-      : `${restBaseUrl}/order?patient=${patientUuid}&careSetting=${careSettingUuid}&v=full&status=${status}`;
+      ? `${restBaseUrl}/order?patient=${patientUuid}&careSetting=${careSettingUuid}&v=default&activatedOnOrAfterDate=${startDate}&activatedOnOrBeforeDate=${endDate}`
+      : `${restBaseUrl}/order?patient=${patientUuid}&careSetting=${careSettingUuid}&v=default&status=${status}`;
   const ordersUrl = orderType ? `${baseOrdersUrl}&orderTypes=${orderType}` : baseOrdersUrl;
 
   const { data, error, isLoading, isValidating } = useSWR<FetchResponse<PatientOrderFetchResponse>, Error>(
@@ -60,7 +60,7 @@ export function usePatientOrders(
 }
 
 export function getDrugOrderByUuid(orderUuid: string) {
-  return openmrsFetch(`${restBaseUrl}/order/${orderUuid}?v=${drugCustomRepresentation}`);
+  return openmrsFetch<Order>(`${restBaseUrl}/order/${orderUuid}?v=${drugCustomRepresentation}`);
 }
 
 // See the Urgency enum in https://github.com/openmrs/openmrs-core/blob/492dcd35b85d48730bd19da48f6db146cc882c22/api/src/main/java/org/openmrs/Order.java

package/src/store/patient-chart-store.ts

@@ -1,40 +1,54 @@
-import { createGlobalStore, useStore } from '@openmrs/esm-framework';
+import { type Actions, createGlobalStore, useStoreWithActions, type Visit } from '@openmrs/esm-framework';
 
 export interface PatientChartStore {
-  patientUuid?: string;
-  patient?: fhir.Patient;
+  patientUuid: string;
+  patient: fhir.Patient;
+  visitContext: Visit;
+  mutateVisitContext: () => void;
 }
 
 const patientChartStoreName = 'patient-chart-global-store';
 
-const patientChartStore = createGlobalStore<PatientChartStore>(patientChartStoreName, {});
+const patientChartStore = createGlobalStore<PatientChartStore>(patientChartStoreName, {
+  patientUuid: null,
+  patient: null,
+  visitContext: null,
+  mutateVisitContext: null,
+});
 
-/**
- * This function returns the patient chart store.
- *
- * The patient chart store is used to store all global variables used in the patient chart.
- * In the recent requirements, patient chart is now not only bound with `/patient/{patientUuid}/` path.
- */
-export function getPatientChartStore() {
-  return patientChartStore;
-}
-
-export function usePatientChartStore() {
-  return useStore(patientChartStore);
-}
+const patientCharStoreActions = {
+  setPatient(_, patient: fhir.Patient) {
+    return { patient, patientUuid: patient?.id ?? null };
+  },
+  setVisitContext(_, visitContext: Visit, mutateVisitContext: () => void) {
+    return { visitContext, mutateVisitContext };
+  },
+} satisfies Actions<PatientChartStore>;
 
 /**
- * This function will get the patient UUID from either URL, or will look into the patient chart store.
- * @returns {string} patientUuid
- */
-export function getPatientUuidFromStore(): string | undefined {
-  return patientChartStore.getState().patientUuid;
-}
-
-/**
- * This function will get the current patient from the store
- * @returns {string} patientUuid
+ * Hook to access the values and sets of the patient chart store.
+ * Note: This hooks SHOULD only be used by components inside the patient chart app.
+ *
+ * Workspaces / extensions that can be mounted by other apps (ex: the start visit form in the queue's app,
+ * the clinical forms workspace in the ward app)
+ * should have the patient / visitContext explicitly passed in as props.
+ *
+ * As a safety feature, this hook requires the the patientUuid as the input, and only
+ * returns the actual store values if input patientUuid matches that in the store.
  */
-export function getPatientFromStore(): fhir.Patient | undefined {
-  return patientChartStore.getState().patient;
+export function usePatientChartStore(patientUuid: string) {
+  const store = useStoreWithActions(patientChartStore, patientCharStoreActions);
+  if (store.patientUuid === patientUuid) {
+    return store;
+  } else {
+    const fakeStore: typeof store = {
+      ...store,
+      mutateVisitContext: null,
+      setVisitContext: () => {},
+      patient: null,
+      patientUuid: null,
+      visitContext: null,
+    };
+    return fakeStore;
+  }
 }

package/src/visit/revalidation-utils.ts

@@ -100,3 +100,12 @@ export function invalidateVisitAndEncounterData(mutate: KeyedMutator<unknown>, p
   invalidateVisitHistory(mutate, patientUuid);
   invalidatePatientEncounters(mutate, patientUuid);
 }
+
+/**
+ * Invalidates a visit fetched by URL /visit/<uuid>
+ * @param mutate - SWR mutate function from useSWRConfig()
+ * @param visitUuid
+ */
+export function invalidateVisitByUuid(mutate: KeyedMutator<unknown>, visitUuid: string) {
+  mutate(new RegExp(`${restBaseUrl}/visit/${visitUuid}`));
+}

package/src/visit/visit-mutations.ts

@@ -1,6 +1,7 @@
 import { useCallback } from 'react';
 import { useSWRConfig } from 'swr';
 import { useVisit, type Visit, restBaseUrl } from '@openmrs/esm-framework';
+import { usePatientChartStore } from '../store/patient-chart-store';
 
 export interface VisitMutationOptions {
   encounters?: boolean;
@@ -19,7 +20,7 @@ export interface VisitMutationOptions {
  */
 export function useOptimisticVisitMutations(patientUuid: string) {
   const { mutate } = useSWRConfig();
-  const { currentVisit } = useVisit(patientUuid);
+  const { visitContext, mutateVisitContext } = usePatientChartStore(patientUuid);
 
   /**
    * Optimistically updates visit data in SWR caches without triggering network requests.
@@ -28,15 +29,8 @@ export function useOptimisticVisitMutations(patientUuid: string) {
   const updateVisitOptimistically = useCallback(
     (visitUuid: string, updates: Partial<Visit>) => {
       // Update current visit SWR cache if it matches
-      if (currentVisit?.uuid === visitUuid) {
-        mutate(
-          `${restBaseUrl}/visit?patient=${patientUuid}&v=custom`,
-          (current: any) => ({
-            ...current,
-            data: { ...current?.data, ...updates },
-          }),
-          false, // Don't revalidate
-        );
+      if (visitContext?.uuid === visitUuid) {
+        mutateVisitContext();
       }
 
       // Update visit lists across all hooks using regex pattern matching
@@ -59,7 +53,7 @@ export function useOptimisticVisitMutations(patientUuid: string) {
         false, // Don't revalidate
       );
     },
-    [currentVisit, mutate, patientUuid],
+    [visitContext, mutateVisitContext, mutate, patientUuid],
   );
 
   /**
@@ -87,11 +81,11 @@ export function useOptimisticVisitMutations(patientUuid: string) {
       );
 
       // If deleted visit was current, revalidate current visit to get new state
-      if (currentVisit?.uuid === visitUuid) {
-        mutate(`${restBaseUrl}/visit?patient=${patientUuid}&v=custom`);
+      if (visitContext?.uuid === visitUuid) {
+        mutateVisitContext();
       }
     },
-    [currentVisit, mutate, patientUuid],
+    [visitContext, mutateVisitContext, mutate, patientUuid],
   );
 
   /**

package/src/workspaces.ts

@@ -1,21 +1,29 @@
 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';
-import { useVisitOrOfflineVisit } from './offline/visit';
 
-export interface DefaultPatientWorkspaceProps extends DefaultWorkspaceProps {
+export interface PatientWorkspaceGroupProps {
   patient: fhir.Patient;
   patientUuid: string;
+  visitContext: Visit;
+  mutateVisitContext: () => void;
 }
 
+export interface PatientChartWorkspaceActionButtonProps {
+  groupProps: PatientWorkspaceGroupProps;
+}
+
+export interface PatientWorkspace2DefinitionProps<WorkspaceProps extends Object, WindowProps extends Object>
+  extends Workspace2DefinitionProps<WorkspaceProps, WindowProps, PatientWorkspaceGroupProps> {}
+
 export function launchPatientChartWithWorkspaceOpen({
   patientUuid,
   workspaceName,
@@ -27,38 +35,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>(workspaceName: string) {
-  const { patientUuid } = usePatientChartStore();
+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);
+        }
+      });
+    },
+    [startVisitIfNeeded, workspaceName],
+  );
+  return launchPatientWorkspaceCb;
+}
+
+export function useStartVisitIfNeeded(patientUuid: string) {
+  const { visitContext } = usePatientChartStore(patientUuid);
   const { systemVisitEnabled } = useSystemVisitSetting();
-  const { currentVisit } = useVisitOrOfflineVisit(patientUuid);
   const isRdeEnabled = useFeatureFlag('rde');
 
-  const launchPatientWorkspaceCb = useCallback(
-    (additionalProps?: T) => {
-      if (!systemVisitEnabled || currentVisit) {
-        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),
+          });
         }
-      }
-    },
-    [currentVisit, systemVisitEnabled, workspaceName, isRdeEnabled, patientUuid],
-  );
-  return launchPatientWorkspaceCb;
+      });
+    }
+  }, [visitContext, systemVisitEnabled, isRdeEnabled, patientUuid]);
+  return startVisitIfNeeded;
 }

package/src/form-entry-interop.ts

@@ -1,152 +0,0 @@
-import { launchWorkspace } from '@openmrs/esm-framework';
-import { type Form, type HtmlFormEntryForm } from './types';
-import { launchStartVisitPrompt } from './launchStartVisitPrompt';
-
-export const clinicalFormsWorkspace = 'clinical-forms-workspace';
-export const formEntryWorkspace = 'patient-form-entry-workspace';
-export const htmlFormEntryWorkspace = 'patient-html-form-entry-workspace';
-
-const formEngineResourceName = 'formEngine';
-const htmlformentryFormEngine = 'htmlformentry';
-const uiStyleResourceName = 'uiStyle';
-const uiStyleSimple = 'simple';
-
-export function launchFormEntryOrHtmlForms(
-  htmlFormEntryForms: Array<HtmlFormEntryForm>,
-  patientUuid: string,
-  form: Form,
-  visitUuid?: string,
-  encounterUuid?: string,
-  visitTypeUuid?: string,
-  visitStartDatetime?: string,
-  visitStopDatetime?: string,
-  mutateForms?: () => void,
-  clinicalFormsWorkspaceName = clinicalFormsWorkspace,
-  formEntryWorkspaceName = formEntryWorkspace,
-  htmlFormEntryWorkspaceName = htmlFormEntryWorkspace,
-) {
-  if (visitUuid) {
-    const { uuid: formUuid, display, name } = form ?? {};
-    const formName = display ?? name ?? '--';
-
-    const htmlForm = toHtmlForm(form, htmlFormEntryForms);
-    if (htmlForm) {
-      launchHtmlFormEntry(patientUuid, formName, encounterUuid, visitUuid, htmlForm, htmlFormEntryWorkspaceName);
-    } else {
-      launchFormEntry(
-        formUuid,
-        patientUuid,
-        encounterUuid,
-        formName,
-        visitUuid,
-        visitTypeUuid,
-        visitStartDatetime,
-        visitStopDatetime,
-        htmlForm,
-        mutateForms,
-        clinicalFormsWorkspaceName,
-        formEntryWorkspaceName,
-      );
-    }
-  } else {
-    launchStartVisitPrompt();
-  }
-}
-
-export function launchFormEntry(
-  formUuid: string,
-  patientUuid: string,
-  encounterUuid?: string,
-  formName?: string,
-  visitUuid?: string,
-  visitTypeUuid?: string,
-  visitStartDatetime?: string,
-  visitStopDatetime?: string,
-  htmlForm?: HtmlFormEntryForm,
-  mutateForm?: () => void,
-  clinicalFormsWorkspaceName = clinicalFormsWorkspace,
-  formEntryWorkspaceName = formEntryWorkspace,
-) {
-  launchWorkspace(formEntryWorkspaceName, {
-    workspaceTitle: formName,
-    clinicalFormsWorkspaceName,
-    formEntryWorkspaceName,
-    patientUuid,
-    mutateForm,
-    formInfo: {
-      encounterUuid,
-      formUuid,
-      patientUuid,
-      visitTypeUuid: visitTypeUuid,
-      visitUuid: visitUuid,
-      visitStartDatetime,
-      visitStopDatetime,
-      htmlForm,
-    },
-  });
-}
-
-export function launchHtmlFormEntry(
-  patientUuid: string,
-  formName: string,
-  encounterUuid: string,
-  visitUuid: string,
-  htmlForm: HtmlFormEntryForm,
-  workspaceName = htmlFormEntryWorkspace,
-) {
-  launchWorkspace(workspaceName, {
-    workspaceTitle: formName,
-    patientUuid,
-    formInfo: {
-      encounterUuid,
-      visitUuid,
-      htmlForm,
-    },
-  });
-}
-
-/**
- * For a given form , check if it is an HTML form. If it is, return the HtmlFormEntryForm object,
- * otherwise return null
- * @param form
- * @param htmlFormEntryForms A list of HTML forms configured in @esm-patient-forms-app's config
- *
- * @returns
- */
-function toHtmlForm(form: Form, htmlFormEntryForms: Array<HtmlFormEntryForm>): HtmlFormEntryForm {
-  const isHtmlForm =
-    htmlFormEntryForms?.some((hfeForm) => hfeForm.formUuid === form.uuid) ||
-    form.resources?.some((resource) => {
-      return resource.name === formEngineResourceName && resource.valueReference === htmlformentryFormEngine;
-    });
-  if (isHtmlForm) {
-    const hfeForm = htmlFormEntryForms?.find((f) => f.formUuid === form.uuid);
-    const simple = form.resources?.some((r) => r.name === uiStyleResourceName && r.valueReference === uiStyleSimple);
-
-    return {
-      formUuid: form.uuid,
-      formName: hfeForm?.formName ?? form.display ?? form.name,
-      formUiResource: hfeForm?.formUiResource,
-      formUiPage: hfeForm?.formUiPage ?? (simple ? 'enterHtmlFormWithSimpleUi' : 'enterHtmlFormWithStandardUi'),
-      formEditUiPage: hfeForm?.formEditUiPage ?? (simple ? 'editHtmlFormWithSimpleUi' : 'editHtmlFormWithStandardUi'),
-    };
-  } else {
-    return null;
-  }
-}
-
-/**
- * Given a list of forms and a list of HtmlFormEntryForm objects from configuration, return a List of HtmlFormEntryForm
- * returned forms either
- *  a) have a form resource with a name of `formEngine` and a value of `htmlformentry, or
- *  b) have an entry in the HtmlFormEntryForm array for a given form uuid
- * The HtmlFormEntryForm configuration provides a means to override the name and rendering mode of a given form
- * @param allForms
- * @param htmlFormEntryForms
- */
-export function mapFormsToHtmlFormEntryForms(
-  allForms: Array<Form>,
-  htmlFormEntryForms: Array<HtmlFormEntryForm>,
-): Array<HtmlFormEntryForm> {
-  return allForms?.map((form) => toHtmlForm(form, htmlFormEntryForms))?.filter((form) => form !== null);
-}