@openmrs/esm-patient-common-lib 11.3.1-pre.9447 → 11.3.1-pre.9455

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openmrs/esm-patient-common-lib",
-  "version": "11.3.1-pre.9447",
+  "version": "11.3.1-pre.9455",
   "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/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,28 @@
+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}`);
+        },
+        undefined,
+        { revalidate: true },
+      ),
+    [patientUuid, mutate],
+  );
+
+  return {
+    mutate: mutateOrders,
+  };
+}

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)';
@@ -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/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,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';
 
-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,
@@ -29,37 +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>(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 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;
 }

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);
-}