@kenyaemr/esm-express-workflow-app 5.4.3 → 5.4.4-pre.100

package/src/components/triage/triage.component.tsx

@@ -1,4 +1,4 @@
-import React, { useMemo, useState } from 'react';
+import React, { useMemo } from 'react';
 import capitalize from 'lodash-es/capitalize';
 import { useTranslation } from 'react-i18next';
 import {
@@ -9,13 +9,14 @@ import {
   ExtensionSlot,
   useConfig,
 } from '@openmrs/esm-framework';
-import { InlineLoading } from '@carbon/react';
+import { TabsSkeleton } from '@carbon/react';
 
 import { useQueues } from '../../hooks/useServiceQueues';
 import QueueTab from '../../shared/queue/queue-tab.component';
+import QueueSummaryCards, { QueueSummaryCard } from '../../shared/queue/queue-summary-cards.component';
+import { QueueWorkflowProvider, useQueueWorkflowContext } from '../../shared/queue/queue-workflow-context';
 import styles from './triage.scss';
-import { Queue, QueueFilter } from '../../types';
-import { useTriageQueuesMetrics } from './triage.resource';
+import { Queue } from '../../types';
 import { ExpressWorkflowConfig } from '../../config-schema';
 
 type TriageProps = {
@@ -38,55 +39,102 @@ export default Triage;
 
 const TriageQueueTab: React.FC = () => {
   const { t } = useTranslation();
-  const [currQueue, setCurrQueue] = useState<Queue>();
-  const { queues, isLoading, error } = useQueues();
-  const [filters, setFilters] = useState<Array<QueueFilter>>([]);
   const {
     queueStatusConceptUuids: { finishedStatus, waitingStatus, inServiceStatus },
     queueServiceConceptUuids,
   } = useConfig<ExpressWorkflowConfig>();
 
-  const triageQueues = queues
-    .filter(
-      (queue) =>
-        queue.service.uuid === queueServiceConceptUuids.triageService &&
-        !queue.location.display.toLowerCase().includes('mch') &&
-        queue?.queueRooms?.length > 0,
-    )
-    .sort((a, b) => a.name.localeCompare(b.name));
-  const activeQueue = useMemo(() => currQueue ?? triageQueues[0], [currQueue, triageQueues]);
+  const { queues, isLoading: isLoadingQueues, error: errorLoadingQueues } = useQueues();
 
-  const {
-    error: metricsError,
-    isLoading: isLoadingMetrics,
-    waitingEntries,
-    attendedtoEntries,
-  } = useTriageQueuesMetrics(activeQueue);
-
-  if (isLoadingMetrics) {
-    return <InlineLoading description={t('loadingQueues', 'Loading queues...')} />;
+  const triageQueues = useMemo(
+    () =>
+      queues
+        .filter(
+          (queue) =>
+            queue.service.uuid === queueServiceConceptUuids.triageService &&
+            !queue.location.display.toLowerCase().includes('mch') &&
+            queue?.queueRooms?.length > 0,
+        )
+        .sort((a, b) => a.name.localeCompare(b.name)),
+    [queues, queueServiceConceptUuids.triageService],
+  );
+
+  if (isLoadingQueues) {
+    return (
+      <div className={styles.contentArea}>
+        <TabsSkeleton />
+      </div>
+    );
+  }
+
+  if (errorLoadingQueues) {
+    return (
+      <div className={styles.contentArea}>
+        <ErrorState error={errorLoadingQueues} headerTitle={t('errorLoadingQueues', 'Error loading queues')} />
+      </div>
+    );
   }
 
-  if (metricsError) {
-    return <ErrorState error={metricsError} headerTitle={t('errorLoadingQueues', 'Error loading queues')} />;
+  if (!triageQueues.length) {
+    return <div className={styles.contentArea} />;
   }
-  const cards = [
+
+  return (
+    <QueueWorkflowProvider queues={triageQueues}>
+      <TriageContent
+        triageQueues={triageQueues}
+        waitingStatus={waitingStatus}
+        finishedStatus={finishedStatus}
+        inServiceStatus={inServiceStatus}
+      />
+    </QueueWorkflowProvider>
+  );
+};
+
+type TriageContentProps = {
+  triageQueues: Queue[];
+  waitingStatus: string;
+  finishedStatus: string;
+  inServiceStatus: string;
+};
+
+const TriageContent: React.FC<TriageContentProps> = ({
+  triageQueues,
+  waitingStatus,
+  finishedStatus,
+  inServiceStatus,
+}) => {
+  const { t } = useTranslation();
+  const { queueEntries, setFilters, queueEntriesError } = useQueueWorkflowContext();
+
+  const waitingEntries = useMemo(
+    () => queueEntries.filter((entry) => entry?.status?.uuid === waitingStatus),
+    [queueEntries, waitingStatus],
+  );
+
+  const attendedToEntries = useMemo(
+    () =>
+      queueEntries.filter((entry) => entry?.status?.uuid === inServiceStatus || entry?.status?.uuid === finishedStatus),
+    [queueEntries, inServiceStatus, finishedStatus],
+  );
+
+  const cards: Array<QueueSummaryCard> = [
     {
       title: t('clientsPatientsWaiting', 'Clients/Patients waiting'),
       value: waitingEntries.length.toString(),
       onClick: () => {
-        setFilters((prevFilters) => [
-          ...prevFilters.filter((f) => f.key !== 'status'),
+        setFilters((prev) => [
+          ...prev.filter((f) => f.key !== 'status'),
           { key: 'status', value: waitingStatus, label: t('waiting', 'Waiting') },
         ]);
       },
     },
     {
       title: t('clientsPatientsAttendedTo', 'Clients/Patients attended to'),
-      value: attendedtoEntries.length.toString(),
+      value: attendedToEntries.length.toString(),
       onClick: () => {
-        setFilters((prevFilters) => [
-          ...prevFilters.filter((f) => f.key !== 'status'),
+        setFilters((prev) => [
+          ...prev.filter((f) => f.key !== 'status'),
           { key: 'status', value: `${finishedStatus},${inServiceStatus}`, label: t('attendedTo', 'Attended to') },
         ]);
       },
@@ -94,14 +142,16 @@ const TriageQueueTab: React.FC = () => {
   ];
 
   return (
-    <QueueTab
-      queues={triageQueues}
-      navigatePath="triage"
-      usePatientChart
-      cards={cards}
-      onTabChanged={setCurrQueue}
-      filters={filters}
-      onFiltersChanged={setFilters}
-    />
+    <div className={styles.contentArea}>
+      <QueueSummaryCards cards={cards} />
+      {queueEntriesError ? (
+        <ErrorState
+          error={queueEntriesError}
+          headerTitle={t('errorLoadingQueueEntries', 'Error loading queue entries')}
+        />
+      ) : (
+        <QueueTab queues={triageQueues} navigatePath="triage" usePatientChart />
+      )}
+    </div>
   );
 };

package/src/components/triage/triage.resource.ts

@@ -1,62 +1,68 @@
-import { useConfig } from '@openmrs/esm-framework';
 import { useMemo } from 'react';
-import { ExpressWorkflowConfig } from '../../config-schema';
+import dayjs from 'dayjs';
+import { useConfig } from '@openmrs/esm-framework';
+
+import { type ExpressWorkflowConfig } from '../../config-schema';
 import { useQueueEntries } from '../../hooks/useServiceQueues';
-import { Queue } from '../../types';
+import { type Queue } from '../../types';
 
 export const useTriageQueuesMetrics = (queue?: Queue) => {
-  const { queueServiceConceptUuids, queueStatusConceptUuids } = useConfig<ExpressWorkflowConfig>();
-  const {
-    queueEntries: waitingEntries,
-    isLoading: isLoadingWaiting,
-    error: waitingError,
-  } = useQueueEntries({
-    service: [queueServiceConceptUuids.triageService],
-    statuses: [queueStatusConceptUuids.waitingStatus],
-    location: queue?.location?.uuid ? [queue.location.uuid] : undefined,
-  });
-  const {
-    queueEntries: inServiceEntries,
-    isLoading: isLoadingInService,
-    error: inServiceError,
-  } = useQueueEntries({
-    service: [queueServiceConceptUuids.triageService],
-    statuses: [queueStatusConceptUuids.inServiceStatus],
-    location: queue?.location?.uuid ? [queue.location.uuid] : undefined,
-  });
+  const { queueStatusConceptUuids } = useConfig<ExpressWorkflowConfig>();
+
   const {
-    queueEntries: finishedEntries,
-    isLoading: isLoadingFinished,
-    error: finishedError,
+    queueEntries: allTriageEntries,
+    isLoading,
+    error,
+    isValidating: isValidatingQueueEntries,
   } = useQueueEntries({
-    service: [queueServiceConceptUuids.triageService],
-    statuses: [queueStatusConceptUuids.finishedStatus],
-    location: queue?.location?.uuid ? [queue.location.uuid] : undefined,
-  });
-  const { queueEntries: attendedtoEntries } = useQueueEntries({
-    service: [queueServiceConceptUuids.triageService],
-    statuses: [queueStatusConceptUuids.inServiceStatus, queueStatusConceptUuids.finishedStatus],
     location: queue?.location?.uuid ? [queue.location.uuid] : undefined,
+    startedOnOrAfter: dayjs().subtract(24, 'hour').format('YYYY-MM-DD HH:mm:ss'),
   });
 
+  const queueUuid = queue?.uuid;
+
+  const waitingEntries = useMemo(
+    () =>
+      allTriageEntries.filter(
+        (entry) => entry?.queue?.uuid === queueUuid && entry?.status?.uuid === queueStatusConceptUuids.waitingStatus,
+      ),
+    [allTriageEntries, queueUuid, queueStatusConceptUuids.waitingStatus],
+  );
+
+  const inServiceEntries = useMemo(
+    () =>
+      allTriageEntries.filter(
+        (entry) => entry?.queue?.uuid === queueUuid && entry?.status?.uuid === queueStatusConceptUuids.inServiceStatus,
+      ),
+    [allTriageEntries, queueUuid, queueStatusConceptUuids.inServiceStatus],
+  );
+
+  const finishedEntries = useMemo(
+    () =>
+      allTriageEntries.filter(
+        (entry) => entry?.queue?.uuid === queueUuid && entry?.status?.uuid === queueStatusConceptUuids.finishedStatus,
+      ),
+    [allTriageEntries, queueUuid, queueStatusConceptUuids.finishedStatus],
+  );
+
+  const attendedToEntries = useMemo(
+    () =>
+      allTriageEntries.filter(
+        (entry) =>
+          entry?.queue?.uuid === queueUuid &&
+          (entry?.status?.uuid === queueStatusConceptUuids.inServiceStatus ||
+            entry?.status?.uuid === queueStatusConceptUuids.finishedStatus),
+      ),
+    [allTriageEntries, queueUuid, queueStatusConceptUuids.inServiceStatus, queueStatusConceptUuids.finishedStatus],
+  );
+
   return {
-    isLoading: isLoadingFinished || isLoadingInService || isLoadingWaiting,
-    waitingEntries: useMemo(
-      () => waitingEntries.filter((entry) => entry?.queue?.uuid === queue?.uuid),
-      [waitingEntries, queue],
-    ),
-    inServiceEntries: useMemo(
-      () => inServiceEntries.filter((entry) => entry?.queue?.uuid === queue?.uuid),
-      [inServiceEntries, queue],
-    ),
-    finishedEntries: useMemo(
-      () => finishedEntries.filter((entry) => entry?.queue?.uuid === queue?.uuid),
-      [finishedEntries, queue],
-    ),
-    attendedtoEntries: useMemo(
-      () => attendedtoEntries.filter((entry) => entry?.queue?.uuid === queue?.uuid),
-      [attendedtoEntries, queue],
-    ),
-    error: finishedError ?? inServiceError ?? waitingError,
+    isLoading,
+    waitingEntries,
+    inServiceEntries,
+    finishedEntries,
+    attendedToEntries,
+    error,
+    isValidating: isValidatingQueueEntries,
   };
 };

package/src/components/triage/triage.scss

@@ -1,6 +1,7 @@
 @use '@carbon/layout';
 @use '@carbon/type';
 @use '@carbon/colors';
+
 .pageHeader {
   @include type.type-style('body-compact-02');
   height: layout.$spacing-12;
@@ -10,3 +11,8 @@
   background: colors.$white-0;
   border-bottom: 1px solid colors.$gray-20;
 }
+
+.contentArea {
+  padding: layout.$spacing-05;
+  min-height: 400px;
+}

package/src/config-schema.ts

@@ -176,6 +176,82 @@ export const configSchema = {
     _description: 'The UUID of the outpatient visit type.',
     _default: '3371a4d4-f66f-4454-a86d-92c7b3da990c',
   },
+  inPatientVisitTypeUuid: {
+    _type: Type.String,
+    _description: 'The UUID of the in-patient visit type.',
+    _default: 'a73e2ac6-263b-47fc-99fc-e0f2c09fc914',
+  },
+  defaultFacilityUrl: {
+    _type: Type.String,
+    _default: '',
+    _description: 'Custom URL to load default facility if it is not in the session',
+  },
+  offlineVisitTypeUuid: {
+    _type: Type.UUID,
+    _description: 'The UUID of the visit type to be used for the automatically created offline visits.',
+    _default: '',
+  },
+  showRecommendedVisitTypeTab: {
+    _type: Type.Boolean,
+    _description: 'Whether start visit form should display recommended visit type tab. Requires `visitTypeResourceUrl`',
+    _default: false,
+  },
+  visitTypeResourceUrl: {
+    _type: Type.String,
+    _default: '',
+    _description: 'Custom URL to load resources required for showing recommended visit types',
+  },
+  disableChangingVisitLocation: {
+    _type: Type.Boolean,
+    _description: 'Whether the visit location field in the Start Visit form should be view-only.',
+    _default: false,
+  },
+  visitAttributeTypes: {
+    _type: Type.Array,
+    _elements: {
+      _type: Type.Object,
+      uuid: {
+        _type: Type.UUID,
+        _description: 'UUID of the visit attribute type',
+      },
+      required: {
+        _type: Type.Boolean,
+        _description: 'Whether the attribute type field is required or not',
+        _default: false,
+      },
+      displayInThePatientBanner: {
+        _type: Type.Boolean,
+        _description: "Whether we should show this visit attribute's value in the patient banner",
+        _default: true,
+      },
+    },
+    _description: 'List of visit attribute types shown when filling the visit form',
+    _default: [
+      {
+        uuid: '',
+        required: false,
+        displayInThePatientBanner: true,
+      },
+      {
+        uuid: '',
+        required: false,
+        displayInThePatientBanner: true,
+      },
+    ],
+  },
+  showUpcomingAppointments: {
+    _type: Type.Boolean,
+    _description: 'Whether start visit form should display upcoming appointments',
+    _default: false,
+  },
+  excludedVisitTypeUuids: {
+    _type: Type.Array,
+    _elements: {
+      _type: Type.UUID,
+    },
+    _default: ['02b67c47-6071-4091-953d-ad21452e830c'],
+    _description: 'List of visit type UUIDs to exclude from the start visit form',
+  },
 };
 
 export type ExpressWorkflowConfig = {
@@ -231,4 +307,19 @@ export type ExpressWorkflowConfig = {
     labourWard: string;
   };
   outpatientVisitTypeUuid: string;
+  inPatientVisitTypeUuid: string;
+  defaultFacilityUrl: string; //done
+  offlineVisitTypeUuid: string;
+  showRecommendedVisitTypeTab: boolean;
+  visitTypeResourceUrl: string;
+  disableChangingVisitLocation: boolean;
+  restrictByVisitLocationTag: boolean;
+  visitAttributeTypes: Array<{
+    displayInThePatientBanner: boolean;
+    required: boolean;
+    showWhenExpression?: string;
+    uuid: string;
+  }>; // done
+  showUpcomingAppointments: boolean; //done
+  excludedVisitTypeUuids: Array<string>;
 };

package/src/hooks/useServiceQueues.tsx

@@ -1,68 +1,138 @@
-import { openmrsFetch, restBaseUrl, useConfig } from '@openmrs/esm-framework';
-import dayjs from 'dayjs';
 import { useMemo } from 'react';
-import useSWR from 'swr';
-import { ExpressWorkflowConfig } from '../config-schema';
-import { Queue, QueueEntry, QueueEntryFilters } from '../types/index';
+import useSWRImmutable from 'swr/immutable';
+import dayjs from 'dayjs';
+import { openmrsFetch, restBaseUrl, useConfig, useOpenmrsPagination } from '@openmrs/esm-framework';
+
+import { type ExpressWorkflowConfig } from '../config-schema';
+import { QueueEntriesPagination, type Queue, type QueueEntry, type QueueEntryFilters } from '../types/index';
+
+const QUEUE_LIST_REP =
+  'custom:(uuid,display,name,location:(uuid,display),service:(uuid,display),queueRooms:(uuid,display))';
+
+const SWR_QUEUE_OPTIONS = {
+  dedupingInterval: 5000,
+  revalidateOnFocus: false,
+} as const;
 
 export const useQueues = () => {
-  const { data, isLoading, error } = useSWR<{ data: { results: Array<Queue> } }>(
-    '/ws/rest/v1/queue?v=full',
+  const queueListKey = `/ws/rest/v1/queue?v=${encodeURIComponent(QUEUE_LIST_REP)}`;
+  const { data, isLoading, error, isValidating } = useSWRImmutable<{ data: { results: Array<Queue> } }>(
+    queueListKey,
     openmrsFetch,
+    SWR_QUEUE_OPTIONS,
   );
 
   return {
     queues: data?.data?.results || [],
     isLoading,
     error,
+    isValidating,
   };
 };
 
-export const useQueueEntries = (filters?: QueueEntryFilters) => {
+export const useQueueEntries = (filters?: QueueEntryFilters, defaultPageSize: number = 10) => {
   const { outpatientVisitTypeUuid } = useConfig<ExpressWorkflowConfig>();
   const repString =
-    'custom:(uuid,display,queue,status,patient:(uuid,display,person,identifiers:(uuid,display,identifier,identifierType)),visit:(uuid,display,startDatetime,visitType:(uuid,display),encounters:(uuid,display,diagnoses,encounterDatetime,encounterType,obs,encounterProviders,voided),attributes:(uuid,display,value,attributeType)),priority,priorityComment,sortWeight,startedAt,endedAt,locationWaitingFor,queueComingFrom,providerWaitingFor,previousQueueEntry)';
+    'custom:(uuid,queue:(uuid,display,name,location:(uuid,display)),status:(uuid,display),patient:(uuid,person:(uuid,display),identifiers:(uuid,display,identifier,identifierType:(uuid,display))),visit:(uuid,visitType:(uuid),attributes:(uuid,value,attributeType:(uuid))),priority:(uuid,display),priorityComment,startedAt,previousQueueEntry:(uuid,queue:(uuid,display)))';
 
-  const buildQueryParams = (filters?: QueueEntryFilters & { status: string[] }): string => {
+  const queryString = useMemo(() => {
     const params = new URLSearchParams();
     params.append('v', repString);
 
-    if (filters) {
-      Object.entries(filters).forEach(([key, value]) => {
-        if (value !== undefined && value !== null) {
-          if (Array.isArray(value)) {
-            value.forEach((v) => params.append(key, v));
-          } else {
-            params.append(key, String(value));
-          }
+    const merged = {
+      ...filters,
+      status: filters?.statuses ?? [],
+      statuses: undefined,
+      startedOnOrAfter: filters?.startedOnOrAfter ?? undefined,
+      startedOnOrBefore: filters?.startedOnOrBefore ?? undefined,
+      queue: filters?.queues ?? [],
+    };
+    if (merged) {
+      Object.entries(merged).forEach(([key, value]) => {
+        if (key === 'statuses' || value === undefined || value === null) {
+          return;
+        }
+        if (Array.isArray(value)) {
+          [...value].sort((a, b) => String(a).localeCompare(String(b))).forEach((v) => params.append(key, v));
+        } else {
+          params.append(key, String(value));
         }
       });
     }
 
-    if (!filters || filters.isEnded === undefined || filters.isEnded === null) {
+    if (filters?.isEnded == null) {
       params.append('isEnded', 'false');
     }
 
     return params.toString();
-  };
+  }, [
+    filters?.location?.join(','),
+    filters?.service?.join(','),
+    [...(filters?.statuses ?? [])].sort((a, b) => String(a).localeCompare(String(b))).join(','),
+    filters?.priorities?.join(','),
+    filters?.patient,
+    filters?.visit,
+    filters?.hasVisit,
+    filters?.isEnded,
+    filters?.locationsWaitingFor?.join(','),
+    filters?.providersWaitingFor?.join(','),
+    filters?.queuesComingFrom?.join(','),
+    filters?.queues?.join(','),
+  ]);
 
-  const queryString = buildQueryParams({ ...filters, status: filters?.statuses ?? [], statuses: [] });
-  const url = `/ws/rest/v1/queue-entry${queryString ? `?${queryString}` : ''}`;
+  const url = queryString ? `/ws/rest/v1/queue-entry?${queryString}` : '/ws/rest/v1/queue-entry';
+
+  const {
+    data,
+    isLoading,
+    isValidating,
+    error,
+    totalPages,
+    totalCount,
+    currentPage,
+    currentPageSize,
+    paginated,
+    showNextButton,
+    showPreviousButton,
+    goTo,
+    goToNext,
+    goToPrevious,
+  } = useOpenmrsPagination<QueueEntry>(url, defaultPageSize, {
+    swrConfig: {
+      revalidateOnFocus: true,
+      keepPreviousData: true,
+    },
+  });
 
-  const { data, isLoading, error } = useSWR<{ data: { results: Array<QueueEntry> } }>(url, openmrsFetch);
   const queueEntries = useMemo(() => {
-    return (data?.data?.results ?? [])?.filter((entry) => {
+    return (data ?? [])?.filter((entry) => {
       return (
         dayjs(entry.startedAt).isAfter(dayjs().subtract(24, 'hour')) &&
         entry?.visit?.visitType?.uuid === outpatientVisitTypeUuid
       );
     });
-  }, [data?.data?.results, outpatientVisitTypeUuid]);
+  }, [data, outpatientVisitTypeUuid]);
+
+  const pagination: QueueEntriesPagination = {
+    totalPages,
+    totalCount,
+    currentPage,
+    currentPageSize,
+    paginated,
+    showNextButton,
+    showPreviousButton,
+    goTo,
+    goToNext,
+    goToPrevious,
+    defaultPageSize,
+  };
 
   return {
     queueEntries,
     isLoading,
+    isValidating,
     error,
+    pagination,
   };
 };
 export function serveQueueEntry(servicePointName: string, ticketNumber: string, status: string, locationUuid?: string) {

package/src/index.ts

@@ -1,10 +1,5 @@
 import { defineConfigSchema, getAsyncLifecycle, getSyncLifecycle } from '@openmrs/esm-framework';
 import { configSchema } from './config-schema';
-import CheckinFormExtraExtension from './components/registration/checkin-form-extra/checkin-form-extra.extension';
-import { Home } from '@carbon/react/icons';
-
-import PatientSummaryDashboard from './shared/patient-chart/patient-summary-dashboard/patient-summary-dashboard.component';
-import { createLeftPanelLink } from './shared/dashboard-link/dashboard-link.component';
 
 const moduleName = '@kenyaemr/esm-express-workflow-app';
 
@@ -37,15 +32,39 @@ export const otpVerificationModal = getAsyncLifecycle(
   () => import('./shared/otp-verification/otp-verification.modal'),
   options,
 );
-export const checkinFormExtraExtension = getSyncLifecycle(CheckinFormExtraExtension, options);
-export const patientSummaryDashboard = getSyncLifecycle(PatientSummaryDashboard, options);
+export const checkinFormExtraExtension = getAsyncLifecycle(
+  () => import('./components/registration/checkin-form-extra/checkin-form-extra.extension'),
+  options,
+);
+export const patientSummaryDashboard = getAsyncLifecycle(
+  () => import('./shared/patient-chart/patient-summary-dashboard/patient-summary-dashboard.component'),
+  options,
+);
+
+export const customStartVisitOverflowMenuItem = getAsyncLifecycle(
+  () => import('./components/registration/start-visit-form/overflow-menu-extension/overflow-menu-item.extension'),
+  {
+    featureName: 'patient-actions-slot-deceased-button',
+    moduleName,
+  },
+);
+
+export const visitFormWorkspace = getAsyncLifecycle(
+  () => import('./components/registration/start-visit-form/visit-form-workspace/visit-form.workspace'),
+  options,
+);
 
 export const queuesAdminHome = getAsyncLifecycle(() => import('./shared/queue/queues-home.component'), options);
-export const homepageDashboardLink = getSyncLifecycle(
-  createLeftPanelLink({
-    name: `consultation`,
-    title: 'Home',
-    icon: Home,
-  }),
+export const homepageDashboardLink = getAsyncLifecycle(
+  () =>
+    Promise.all([import('./shared/dashboard-link/dashboard-link.component'), import('@carbon/react/icons')]).then(
+      ([m, icons]) => ({
+        default: m.createLeftPanelLink({
+          name: 'consultation',
+          title: 'Home',
+          icon: icons.Home,
+        }),
+      }),
+    ),
   options,
 );