@kenyaemr/esm-service-queues-app 7.0.2-pre.65

package/src/helpers/helpers.ts

@@ -0,0 +1,177 @@
+import { useEffect, useState } from 'react';
+import { getGlobalStore } from '@openmrs/esm-framework';
+import type { AppointmentSummary } from '../types';
+import { useTranslation } from 'react-i18next';
+
+export const getServiceCountByAppointmentType = (
+  appointmentSummary: Array<AppointmentSummary>,
+  appointmentType: string,
+) => {
+  return appointmentSummary
+    .map((appointment) =>
+      Object.entries(appointment.appointmentCountMap).flatMap((appointment) => appointment[1][appointmentType]),
+    )
+    .flat(1)
+    .reduce((count, val) => count + val, 0);
+};
+
+const initialServiceNameState = { serviceName: sessionStorage.getItem('queueServiceName') };
+const initialServiceUuidState = { serviceUuid: sessionStorage.getItem('queueServiceUuid') };
+const intialStatusNameState = { status: '' };
+const initialQueueLocationNameState = { queueLocationName: sessionStorage.getItem('queueLocationName') };
+const initialQueueLocationUuidState = { queueLocationUuid: sessionStorage.getItem('queueLocationUuid') };
+const initialSelectedQueueRoomTimestamp = { providerQueueRoomTimestamp: new Date() };
+const initialPermanentProviderQueueRoomState = {
+  isPermanentProviderQueueRoom: sessionStorage.getItem('isPermanentProviderQueueRoom'),
+};
+
+export function getSelectedServiceName() {
+  return getGlobalStore<{ serviceName: string }>('queueSelectedServiceName', initialServiceNameState);
+}
+
+export function getSelectedServiceUuid() {
+  return getGlobalStore<{ serviceUuid: string }>('queueSelectedServiceUuid', initialServiceUuidState);
+}
+
+export function getSelectedAppointmentStatus() {
+  return getGlobalStore<{ status: string }>('appointmentSelectedStatus', intialStatusNameState);
+}
+
+export function getSelectedQueueLocationName() {
+  return getGlobalStore<{ queueLocationName: string }>('queueLocationNameSelected', initialQueueLocationNameState);
+}
+
+export function getSelectedQueueLocationUuid() {
+  return getGlobalStore<{ queueLocationUuid: string }>('queueLocationUuidSelected', initialQueueLocationUuidState);
+}
+
+export function getSelectedQueueRoomTimestamp() {
+  return getGlobalStore<{ providerQueueRoomTimestamp: Date }>(
+    'queueProviderRoomTimestamp',
+    initialSelectedQueueRoomTimestamp,
+  );
+}
+
+export function getIsPermanentProviderQueueRoom() {
+  return getGlobalStore<{ isPermanentProviderQueueRoom: string }>(
+    'isPermanentProviderQueueRoom',
+    initialPermanentProviderQueueRoomState,
+  );
+}
+
+export const updateSelectedServiceName = (currentServiceName: string) => {
+  const store = getSelectedServiceName();
+  sessionStorage.setItem('queueServiceName', currentServiceName);
+  store.setState({ serviceName: currentServiceName });
+};
+
+export const updateSelectedServiceUuid = (currentServiceUuid: string) => {
+  const store = getSelectedServiceUuid();
+  sessionStorage.setItem('queueServiceUuid', currentServiceUuid);
+  store.setState({ serviceUuid: currentServiceUuid });
+};
+
+export const updateSelectedAppointmentStatus = (currentAppointmentStatus: string) => {
+  const store = getSelectedAppointmentStatus();
+  store.setState({ status: currentAppointmentStatus });
+};
+
+export const updateSelectedQueueLocationName = (currentLocationName: string) => {
+  const store = getSelectedQueueLocationName();
+  sessionStorage.setItem('queueLocationName', currentLocationName);
+  store.setState({ queueLocationName: currentLocationName });
+};
+
+export const updateSelectedQueueLocationUuid = (currentLocationUuid: string) => {
+  const store = getSelectedQueueLocationUuid();
+  sessionStorage.setItem('queueLocationUuid', currentLocationUuid);
+  store.setState({ queueLocationUuid: currentLocationUuid });
+};
+
+export const updatedSelectedQueueRoomTimestamp = (currentProviderRoomTimestamp: Date) => {
+  const store = getSelectedQueueRoomTimestamp();
+  store.setState({ providerQueueRoomTimestamp: currentProviderRoomTimestamp });
+};
+
+export const updateIsPermanentProviderQueueRoom = (currentIsPermanentProviderQueueRoom) => {
+  const store = getIsPermanentProviderQueueRoom();
+  sessionStorage.setItem('isPermanentProviderQueueRoom', currentIsPermanentProviderQueueRoom);
+  store.setState({ isPermanentProviderQueueRoom: currentIsPermanentProviderQueueRoom });
+};
+
+export const useSelectedServiceName = () => {
+  const { t } = useTranslation();
+  const [currentServiceName, setCurrentServiceName] = useState(initialServiceNameState.serviceName ?? t('all', 'All'));
+
+  useEffect(() => {
+    getSelectedServiceName().subscribe(({ serviceName }) => setCurrentServiceName(serviceName));
+  }, []);
+
+  return currentServiceName;
+};
+
+export const useSelectedServiceUuid = () => {
+  const [currentServiceUuid, setCurrentServiceUuid] = useState(initialServiceUuidState.serviceUuid);
+
+  useEffect(() => {
+    getSelectedServiceUuid().subscribe(({ serviceUuid }) => setCurrentServiceUuid(serviceUuid));
+  }, []);
+  return currentServiceUuid;
+};
+
+export const useSelectedAppointmentStatus = () => {
+  const [currentAppointmentStatus, setCurrentAppointmentStatus] = useState(intialStatusNameState.status);
+
+  useEffect(() => {
+    getSelectedAppointmentStatus().subscribe(({ status }) => setCurrentAppointmentStatus(status));
+  }, []);
+  return currentAppointmentStatus;
+};
+
+export const useSelectedQueueLocationName = () => {
+  const [currentQueueLocationName, setCurrentQueueLocationName] = useState(
+    initialQueueLocationNameState.queueLocationName,
+  );
+
+  useEffect(() => {
+    getSelectedQueueLocationName().subscribe(({ queueLocationName }) => setCurrentQueueLocationName(queueLocationName));
+  }, []);
+  return currentQueueLocationName;
+};
+
+export const useSelectedQueueLocationUuid = () => {
+  const [currentQueueLocationUuid, setCurrentQueueLocationUuid] = useState(
+    initialQueueLocationUuidState.queueLocationUuid,
+  );
+
+  useEffect(() => {
+    getSelectedQueueLocationUuid().subscribe(({ queueLocationUuid }) => setCurrentQueueLocationUuid(queueLocationUuid));
+  }, []);
+  return currentQueueLocationUuid;
+};
+
+export const useSelectedProviderRoomTimestamp = () => {
+  const [currentProviderRoomTimestamp, setCurrentProviderRoomTimestamp] = useState(
+    initialSelectedQueueRoomTimestamp.providerQueueRoomTimestamp,
+  );
+
+  useEffect(() => {
+    getSelectedQueueRoomTimestamp().subscribe(({ providerQueueRoomTimestamp }) =>
+      setCurrentProviderRoomTimestamp(providerQueueRoomTimestamp),
+    );
+  }, []);
+  return currentProviderRoomTimestamp;
+};
+
+export const useIsPermanentProviderQueueRoom = () => {
+  const [currentIsPermanentProviderQueueRoom, setCurrentIsPermanentProviderQueueRoom] = useState(
+    initialPermanentProviderQueueRoomState.isPermanentProviderQueueRoom,
+  );
+
+  useEffect(() => {
+    getIsPermanentProviderQueueRoom().subscribe(({ isPermanentProviderQueueRoom }) =>
+      setCurrentIsPermanentProviderQueueRoom(isPermanentProviderQueueRoom),
+    );
+  }, []);
+  return currentIsPermanentProviderQueueRoom;
+};

package/src/helpers/time-helpers.ts

@@ -0,0 +1,15 @@
+export type amPm = 'AM' | 'PM';
+
+export const convertTime12to24 = (time12h, timeFormat: amPm) => {
+  let [hours, minutes] = time12h.split(':');
+
+  if (hours === '12' && timeFormat === 'AM') {
+    hours = '00';
+  }
+
+  if (timeFormat === 'PM') {
+    hours = hours === '12' ? hours : parseInt(hours, 10) + 12;
+  }
+
+  return [hours, minutes];
+};

package/src/home.component.tsx

@@ -0,0 +1,16 @@
+import React from 'react';
+import PatientQueueHeader from './patient-queue-header/patient-queue-header.component';
+import ClinicMetrics from './patient-queue-metrics/clinic-metrics.component';
+import DefaultQueueTable from './queue-table/default-queue-table.component';
+
+const Home: React.FC = () => {
+  return (
+    <>
+      <PatientQueueHeader />
+      <ClinicMetrics />
+      <DefaultQueueTable />
+    </>
+  );
+};
+
+export default Home;

package/src/home.test.tsx

@@ -0,0 +1,48 @@
+import React from 'react';
+import { render, screen } from '@testing-library/react';
+import Home from './home.component';
+import { getDefaultsFromConfigSchema, useConfig } from '@openmrs/esm-framework';
+import { configSchema } from './config-schema';
+
+const mockedUseConfig = useConfig as jest.Mock;
+
+mockedUseConfig.mockReturnValue({
+  ...getDefaultsFromConfigSchema(configSchema),
+  concepts: {
+    visitQueueNumberAttributeUuid: 'c61ce16f-272a-41e7-9924-4c555d0932c5',
+  },
+});
+
+jest.mock('./helpers/helpers', () => ({
+  ...jest.requireActual('./helpers/helpers'),
+  useSelectedQueueLocationName: jest.fn(() => 'Test Location'),
+}));
+
+describe('Home Component', () => {
+  it('renders PatientQueueHeader, ClinicMetrics when activeTicketScreen is not "screen"', () => {
+    // Mock window.location.pathname
+    const originalLocation = window.location;
+    delete window.location;
+    window.location = { pathname: '/some-path' };
+
+    render(<Home />);
+
+    // Assert that the expected components are rendered
+    expect(screen.getByTestId('patient-queue-header')).toBeInTheDocument();
+    expect(screen.getByTestId('clinic-metrics')).toBeInTheDocument();
+
+    // Clean up the mock
+    window.location = originalLocation;
+  });
+
+  it('renders QueueScreen when activeTicketScreen is "screen"', () => {
+    const originalLocation = window.location;
+    delete window.location;
+    window.location = { pathname: '/some-path/screen' };
+
+    render(<Home />);
+    expect(screen.getByText(/patients currently in queue/i)).toBeInTheDocument();
+
+    window.location = originalLocation;
+  });
+});

package/src/hooks/useConcept.ts

@@ -0,0 +1,13 @@
+import { openmrsFetch, restBaseUrl } from '@openmrs/esm-framework';
+import useSWRImmutable from 'swr/immutable';
+import { type Concept } from '../types';
+
+export function useConcept(uuid: string) {
+  const apiUrl = uuid ? `${restBaseUrl}/concept/${uuid}` : undefined;
+  const { data, error, isLoading } = useSWRImmutable<{ data: Concept }, Error>(apiUrl, openmrsFetch);
+  return {
+    concept: data?.data,
+    error: error,
+    isLoading: isLoading,
+  };
+}

package/src/hooks/useQueue.ts

@@ -0,0 +1,10 @@
+import { useQueues } from './useQueues';
+
+export function useQueue(queueUuid?: string) {
+  const { queues, ...rest } = useQueues();
+
+  return {
+    queue: queues.find((q) => q.uuid == queueUuid),
+    ...rest,
+  };
+}

package/src/hooks/useQueueEntries.ts

@@ -0,0 +1,187 @@
+import { type FetchResponse, openmrsFetch, restBaseUrl } from '@openmrs/esm-framework';
+import { type QueueEntry, type QueueEntrySearchCriteria } from '../types';
+import useSWR from 'swr';
+import { useCallback, useEffect, useMemo, useState } from 'react';
+import { useSWRConfig } from 'swr/_internal';
+
+type QueueEntryResponse = FetchResponse<{
+  results: Array<QueueEntry>;
+  links: Array<{
+    rel: 'prev' | 'next';
+    uri: string;
+  }>;
+  totalCount: number;
+}>;
+
+const queueEntryBaseUrl = `${restBaseUrl}/queue-entry`;
+
+const repString =
+  'custom:(uuid,display,queue,status,patient:(uuid,display,person,identifiers:(uuid,display,identifier,identifierType)),visit:(uuid,display,startDatetime,encounters:(uuid,display,diagnoses,encounterDatetime,encounterType,obs,encounterProviders,voided),attributes:(uuid,display,value,attributeType)),priority,priorityComment,sortWeight,startedAt,endedAt,locationWaitingFor,queueComingFrom,providerWaitingFor,previousQueueEntry)';
+
+function getInitialUrl(rep: string, searchCriteria?: QueueEntrySearchCriteria) {
+  const searchParam = new URLSearchParams();
+  searchParam.append('v', rep);
+  searchParam.append('totalCount', 'true');
+
+  if (searchCriteria) {
+    for (let [key, value] of Object.entries(searchCriteria)) {
+      if (value != null) {
+        searchParam.append(key, value?.toString());
+      }
+    }
+  }
+
+  return `${queueEntryBaseUrl}?${searchParam.toString()}`;
+}
+
+function getNextUrlFromResponse(data: QueueEntryResponse) {
+  const next = data?.data?.links?.find((link) => link.rel === 'next');
+  if (next) {
+    const nextUrl = new URL(next.uri);
+    // default for production
+    if (nextUrl.origin === window.location.origin) {
+      return nextUrl.toString();
+    }
+
+    // in development, the request should be routed through the local proxy
+    return new URL(`${nextUrl.pathname}${nextUrl.search ? nextUrl.search : ''}`, window.location.origin).toString();
+  }
+  // There's no next URL
+  return null;
+}
+
+export function useMutateQueueEntries() {
+  const { mutate } = useSWRConfig();
+
+  return {
+    mutateQueueEntries: () => {
+      return mutate((key) => {
+        return (
+          typeof key === 'string' &&
+          (key.includes(`${restBaseUrl}/queue-entry`) || key.includes(`${restBaseUrl}/visit-queue-entry`))
+        );
+      }).then(() => {
+        window.dispatchEvent(new CustomEvent('queue-entry-updated'));
+      });
+    },
+  };
+}
+
+export function useQueueEntries(searchCriteria?: QueueEntrySearchCriteria, rep: string = repString) {
+  // This manually implements a kind of pagination using the useSWR hook. It does not use useSWRInfinite
+  // because useSWRInfinite does not support with `mutate`. The hook starts by fetching the first page,
+  // page zero, waits until data is fetched, then fetches the next page, and so on.
+  //
+  // Fine so far. Where things get complicated is in supporting mutation. When a mutation is made, the
+  // SWR hook first returns stale data with `isValidating` set to false. At this point we say we are
+  // "waiting for mutate," because we have called mutate, but the useSWR hook hasn't updated properly
+  // for it yet. Next it returns stale data again, this time with `isValidating` set to true. At this
+  // point we say we are no longer waiting for mutate. Finally, it returns fresh data with `isValidating`
+  // again set to false. We may then update the data array and move on to the next page.
+  const [data, setData] = useState<Array<Array<QueueEntry>>>([]);
+  const [totalCount, setTotalCount] = useState<number>();
+  const [currentPage, setCurrentPage] = useState<number>(0);
+  const [pageUrl, setPageUrl] = useState<string>(getInitialUrl(rep, searchCriteria));
+  const [error, setError] = useState<Error>();
+  const { mutateQueueEntries } = useMutateQueueEntries();
+  const [waitingForMutate, setWaitingForMutate] = useState(false);
+
+  const { data: pageData, isValidating, error: pageError } = useSWR<QueueEntryResponse, Error>(pageUrl, openmrsFetch);
+
+  useEffect(() => {
+    const nextUrl = getNextUrlFromResponse(pageData);
+    const stillWaitingForMutate = waitingForMutate && !isValidating;
+    if (waitingForMutate && isValidating) {
+      setWaitingForMutate(false);
+    }
+    if (pageData && !isValidating && !stillWaitingForMutate) {
+      // We've got results! Time to update the data array and move on to the next page.
+      if (pageData?.data?.totalCount && pageData?.data?.totalCount !== totalCount) {
+        setTotalCount(pageData?.data?.totalCount);
+      }
+      if (pageData?.data?.results?.length) {
+        const newData = [...data];
+        newData[currentPage] = pageData?.data?.results;
+        setData(newData);
+      }
+      setCurrentPage(currentPage + 1);
+      setPageUrl(nextUrl);
+      // If we're mutating existing data, then we again need to wait for the mutate to work,
+      // since useSWR will (again) first return stale data with isValidating set to false.
+      const inMutateMode = data.length > currentPage;
+      if (inMutateMode && nextUrl) {
+        setWaitingForMutate(true);
+      }
+    }
+    // It may happen that there are fewer pages in the new data than in the old data. In this
+    // case, we need to remove the extra pages, which are stored on the `data` array.
+    // Note that since we mutated the `data` state earlier in this function, it is important to
+    // use the functional form of `setData` so as not to use the stale `data` state.
+    if (!nextUrl) {
+      // I will not be very suprised if there is an off-by-one error here.
+      if (data.length > currentPage + 1) {
+        setData((prevData) => {
+          const newData = [...prevData];
+          newData.splice(currentPage + 1);
+          return newData;
+        });
+      }
+    }
+  }, [pageData, data, currentPage, totalCount, waitingForMutate, isValidating]);
+
+  useEffect(() => {
+    // An error to one is an error to all
+    if (pageError) {
+      setError(pageError);
+    }
+  }, [pageError]);
+
+  const queueUpdateListener = useCallback(() => {
+    setWaitingForMutate(true);
+    setCurrentPage(0);
+    setPageUrl(getInitialUrl(rep, searchCriteria));
+  }, [rep, searchCriteria]);
+
+  useEffect(() => {
+    window.addEventListener('queue-entry-updated', queueUpdateListener);
+    return () => {
+      window.removeEventListener('queue-entry-updated', queueUpdateListener);
+    };
+  }, [queueUpdateListener]);
+
+  const queueEntries = useMemo(() => data.flat(), [data]);
+
+  return {
+    queueEntries,
+    totalCount,
+    isLoading: totalCount && queueEntries.length < totalCount,
+    isValidating: isValidating || currentPage < data.length,
+    error,
+    mutate: mutateQueueEntries,
+  };
+}
+
+export function useQueueEntriesMetrics(searchCriteria?: QueueEntrySearchCriteria) {
+  const searchParam = new URLSearchParams();
+  for (let [key, value] of Object.entries(searchCriteria)) {
+    if (value != null) {
+      searchParam.append(key, value?.toString());
+    }
+  }
+  const apiUrl = `${restBaseUrl}/queue-entry-metrics?` + searchParam.toString();
+
+  const { data } = useSWR<
+    {
+      data: {
+        count: number;
+        averageWaitTime: number;
+      };
+    },
+    Error
+  >(apiUrl, openmrsFetch);
+
+  return {
+    count: data ? data?.data?.count : 0,
+    averageWaitTime: data?.data?.averageWaitTime,
+  };
+}

package/src/hooks/useQueues.ts

@@ -0,0 +1,22 @@
+import { getLocale, openmrsFetch, restBaseUrl } from '@openmrs/esm-framework';
+import useSWRImmutable from 'swr/immutable';
+import { type Queue } from '../types';
+import { useMemo } from 'react';
+
+export function useQueues(locationUuid?: string) {
+  const customRepresentation =
+    'custom:(uuid,display,name,description,service:(uuid,display),allowedPriorities:(uuid,display),allowedStatuses:(uuid,display),location:(uuid,display))';
+  const apiUrl = `${restBaseUrl}/queue?v=${customRepresentation}` + (locationUuid ? `&location=${locationUuid}` : '');
+
+  const { data, ...rest } = useSWRImmutable<{ data: { results: Array<Queue> } }, Error>(apiUrl, openmrsFetch);
+
+  const queues = useMemo(
+    () => data?.data?.results.sort((a, b) => a.display.localeCompare(b.display, getLocale())) ?? [],
+    [data?.data?.results],
+  );
+
+  return {
+    queues,
+    ...rest,
+  };
+}

package/src/hooks/useSystemSetting.ts

@@ -0,0 +1,18 @@
+import { openmrsFetch, restBaseUrl } from '@openmrs/esm-framework';
+import useSWRImmutable from 'swr/immutable';
+
+export interface SystemSetting {
+  uuid: string;
+  property: string;
+  value: string;
+}
+
+export function useSystemSetting(setting: string) {
+  const apiUrl = `${restBaseUrl}/systemsetting/${setting}?v=custom:(value)`;
+  const { data, error, isLoading } = useSWRImmutable<{ data: SystemSetting }, Error>(apiUrl, openmrsFetch);
+  return {
+    systemSetting: data?.data,
+    error: error,
+    isLoading: isLoading,
+  };
+}

package/src/index.ts

@@ -0,0 +1,172 @@
+import { defineConfigSchema, getAsyncLifecycle, getSyncLifecycle, registerBreadcrumbs } from '@openmrs/esm-framework';
+import { configSchema } from './config-schema';
+import { createDashboardLink } from './createDashboardLink.component';
+import { dashboardMeta } from './dashboard.meta';
+import rootComponent from './root.component';
+import queueTableByStatusMenuComponent from './queue-table/queue-table-by-status-menu.component';
+import appointmentListComponent from './queue-patient-linelists/scheduled-appointments-table.component';
+import queueListComponent from './queue-patient-linelists/queue-services-table.component';
+import outpatientSideNavComponent from './side-menu/side-menu.component';
+import homeDashboardComponent from './home.component';
+import patientInfoBannerSlotComponent from './patient-info/patient-info.component';
+import pastVisitSummaryComponent from './past-visit/past-visit.component';
+import VisitFormQueueFields from './patient-search/visit-form-queue-fields/visit-form-queue-fields.component';
+
+export const importTranslation = require.context('../translations', false, /.json$/, 'lazy');
+
+const moduleName = '@kenyaemr/esm-service-queues-app';
+
+const options = {
+  featureName: 'outpatient',
+  moduleName,
+};
+
+export const root = getSyncLifecycle(rootComponent, options);
+
+export const queueTableByStatusMenu = getSyncLifecycle(queueTableByStatusMenuComponent, options);
+
+export const appointmentsList = getSyncLifecycle(appointmentListComponent, options);
+
+export const queueList = getSyncLifecycle(queueListComponent, options);
+
+export const outpatientSideNav = getSyncLifecycle(outpatientSideNavComponent, options);
+
+export const serviceQueuesDashboardLink = getSyncLifecycle(createDashboardLink(dashboardMeta), options);
+
+export const homeDashboard = getSyncLifecycle(homeDashboardComponent, options);
+
+export const editQueueEntryStatusModal = getAsyncLifecycle(
+  () => import('./active-visits/change-status-dialog.component'),
+  {
+    featureName: 'edit queue status',
+    moduleName,
+  },
+);
+
+export const patientInfoBannerSlot = getSyncLifecycle(patientInfoBannerSlotComponent, {
+  featureName: 'patient info slot',
+  moduleName,
+});
+
+export const removeQueueEntry = getAsyncLifecycle(
+  () => import('./remove-queue-entry-dialog/remove-queue-entry.component'),
+  {
+    featureName: 'remove queue entry and end visit',
+    moduleName,
+  },
+);
+
+export const clearAllQueueEntries = getAsyncLifecycle(
+  () => import('./clear-queue-entries-dialog/clear-queue-entries-dialog.component'),
+  {
+    featureName: 'clear all queue entries and end visits',
+    moduleName,
+  },
+);
+
+export const addVisitToQueueModal = getAsyncLifecycle(
+  () => import('./add-patient-toqueue/add-patient-toqueue-dialog.component'),
+  {
+    featureName: 'add visit to queue',
+    moduleName,
+  },
+);
+
+export const transitionQueueEntryStatusModal = getAsyncLifecycle(
+  () => import('./transition-queue-entry/transition-queue-entry-dialog.component'),
+  {
+    featureName: 'transition queue status',
+    moduleName,
+  },
+);
+
+export const pastVisitSummary = getSyncLifecycle(pastVisitSummaryComponent, options);
+
+export const addProviderToRoomModal = getAsyncLifecycle(
+  () => import('./add-provider-queue-room/add-provider-queue-room.component'),
+  {
+    featureName: 'add provider queue room',
+    moduleName,
+  },
+);
+
+export const transitionQueueEntryModal = getAsyncLifecycle(
+  () => import('./queue-table/queue-entry-actions/transition-queue-entry-modal.component'),
+  {
+    featureName: 'transfer patient to a different queue',
+    moduleName,
+  },
+);
+
+export const editQueueEntryModal = getAsyncLifecycle(
+  () => import('./queue-table/queue-entry-actions/edit-queue-entry-modal.component'),
+  {
+    featureName: 'edit queue entry of a patient',
+    moduleName,
+  },
+);
+
+export const undoTransitionQueueEntryModal = getAsyncLifecycle(
+  () => import('./queue-table/queue-entry-actions/undo-transition-queue-entry-modal.component'),
+  {
+    featureName: 'undo queue entry transiion of a patient',
+    moduleName,
+  },
+);
+
+export const voidQueueEntryModal = getAsyncLifecycle(
+  () => import('./queue-table/queue-entry-actions/void-queue-entry-modal.component'),
+  {
+    featureName: 'void queue entry of a patient',
+    moduleName,
+  },
+);
+
+export const endQueueEntryModal = getAsyncLifecycle(
+  () => import('./queue-table/queue-entry-actions/end-queue-entry-modal.component'),
+  {
+    featureName: 'end queue entry of a patient',
+    moduleName,
+  },
+);
+
+// t('addNewQueueService', 'Add New Queue Service')
+export const addNewQueueServiceWorkspace = getAsyncLifecycle(
+  () => import('./queue-services/queue-service-form.workspace'),
+  {
+    featureName: 'service-queues-service-form',
+    moduleName,
+  },
+);
+
+// t('addNewQueueServiceRoom', 'Add new queue service room')
+export const addNewQueueServiceRoomWorkspace = getAsyncLifecycle(
+  () => import('./queue-rooms/queue-room-form.workspace'),
+  {
+    featureName: 'service-queues-queue-room-form',
+    moduleName,
+  },
+);
+
+export const visitFormQueueFields = getSyncLifecycle(VisitFormQueueFields, options);
+
+// t('searchPatient', 'Search Patient')
+export const patientSearchWorkspace = getAsyncLifecycle(() => import('./patient-search/patient-search.workspace'), {
+  featureName: 'service-queues-patient-search',
+  moduleName,
+});
+
+export const activeVisitsRowActions = getAsyncLifecycle(
+  () => import('./active-visits/active-visits-row-actions.component'),
+  {
+    featureName:
+      'quick actions to queue, requeue and transfer patients. With overflow menu actions to edit patient and end visit',
+    moduleName,
+  },
+);
+
+export function startupApp() {
+  registerBreadcrumbs([]);
+
+  defineConfigSchema(moduleName, configSchema);
+}