@bathiran212/esm-patient-chart-app 7.0.0

package/src/side-nav/side-menu.component.tsx

@@ -0,0 +1,10 @@
+import React from 'react';
+import { LeftNavMenu, useLayoutType } from '@openmrs/esm-framework';
+
+const SideMenuPanel: React.FC = () => {
+  const layout = useLayoutType();
+
+  return layout === 'large-desktop' && <LeftNavMenu />;
+};
+
+export default SideMenuPanel;

package/src/side-nav/side-menu.scss

@@ -0,0 +1,38 @@
+@use '@carbon/layout';
+@use '@carbon/type';
+@use '@openmrs/esm-styleguide/src/vars' as *;
+
+.link > div a:nth-child(1) {
+  height: layout.$spacing-09;
+  padding: layout.$spacing-06 0 layout.$spacing-06 1.25rem;
+  color: $ui-04;
+  @extend .productiveHeading01;
+  border-left: layout.$spacing-02 solid transparent;
+}
+
+:global(.omrs-breakpoint-gt-tablet) .link > div {
+  padding-top: layout.$spacing-05;
+}
+
+:global(.omrs-breakpoint-gt-tablet) .link > div a:nth-child(1) {
+  height: layout.$spacing-07;
+  color: $ui-04;
+  padding-left: layout.$spacing-05;
+}
+
+.link > div a:nth-child(1):hover {
+  background-color: $ui-03;
+  color: $ui-05;
+  border-left: var(--brand-01);
+}
+
+.link > div a:nth-child(1):focus {
+  background-color: $ui-03;
+  outline: none;
+  color: $ui-05;
+  border-left: var(--brand-01);
+}
+
+.productiveHeading01 {
+  @include type.type-style('heading-compact-01');
+}

package/src/side-nav/side-menu.test.tsx

@@ -0,0 +1,27 @@
+import React from 'react';
+import { vi, describe, it, expect } from 'vitest';
+import { render, screen } from '@testing-library/react';
+import { useLayoutType } from '@openmrs/esm-framework';
+import SideMenu from './side-menu.component';
+
+const mockUseLayoutType = vi.mocked(useLayoutType);
+
+describe('Side menu', () => {
+  it('is rendered when viewport == large-desktop', () => {
+    mockUseLayoutType.mockReturnValue('large-desktop');
+    renderSideMenu();
+
+    expect(screen.getByText(/left nav menu/i)).toBeInTheDocument();
+  });
+
+  it('is not rendered when viewport == tablet or viewport == small-desktop', () => {
+    mockUseLayoutType.mockReturnValue('tablet');
+    renderSideMenu();
+
+    expect(screen.queryByText(/left nav menu/i)).not.toBeInTheDocument();
+  });
+});
+
+function renderSideMenu() {
+  render(<SideMenu />);
+}

package/src/utils.test.ts

@@ -0,0 +1,17 @@
+import { isDesktop } from './utils';
+import { vi, describe, it, expect } from 'vitest';
+
+describe('isDesktop', () => {
+  it('is true when layout = tablet', () => {
+    expect(isDesktop('tablet')).toBeFalsy();
+  });
+
+  it('is true when layout = phone', () => {
+    expect(isDesktop('phone')).toBeFalsy();
+  });
+
+  it('is false is desktop', () => {
+    expect(isDesktop('small-desktop')).toBeTruthy();
+    expect(isDesktop('large-desktop')).toBeTruthy();
+  });
+});

package/src/utils.ts

@@ -0,0 +1,5 @@
+import { isDesktop as checkIfIsDesktop, type LayoutType } from '@openmrs/esm-framework';
+
+export function isDesktop(layout: LayoutType) {
+  return checkIfIsDesktop(layout);
+}

package/src/visit/hooks/useDefaultFacilityLocation.tsx

@@ -0,0 +1,15 @@
+import { type FetchResponse, openmrsFetch, useConfig } from '@openmrs/esm-framework';
+import useSWRImmutable from 'swr/immutable';
+import { type ChartConfig } from '../../config-schema';
+
+export const useDefaultFacilityLocation = () => {
+  const config = useConfig() as ChartConfig;
+  const apiUrl = config.defaultFacilityUrl;
+  const { data, error, isLoading } = useSWRImmutable<FetchResponse>(apiUrl, openmrsFetch);
+
+  return {
+    defaultFacility: data ? data?.data : null,
+    isLoading: isLoading,
+    error: error,
+  };
+};

package/src/visit/hooks/useDefaultVisitLocation.tsx

@@ -0,0 +1,24 @@
+import { type FetchResponse, type Location, openmrsFetch, restBaseUrl } from '@openmrs/esm-framework';
+import { useEffect } from 'react';
+import useSWR from 'swr';
+
+/**
+ * Fetches the default visit location based on the location and the restrictByVisitLocationTag
+ * If restrictByVisitLocationTag is true, it fetches the nearest ancestor location that supports visits, otherwise it returns the passed-in location
+ *
+ * @param location
+ * @param restrictByVisitLocationTag
+ */
+export function useDefaultVisitLocation(location: Location, restrictByVisitLocationTag: boolean) {
+  let url = `${restBaseUrl}/emrapi/locationThatSupportsVisits?location=${location?.uuid}`;
+
+  const { data, error } = useSWR<FetchResponse>(restrictByVisitLocationTag ? url : null, openmrsFetch);
+
+  useEffect(() => {
+    if (error) {
+      console.error(error);
+    }
+  }, [error]);
+
+  return !restrictByVisitLocationTag ? location : data?.data;
+}

package/src/visit/hooks/useDeleteVisit.test.tsx

@@ -0,0 +1,267 @@
+import { useSWRConfig } from 'swr';
+import { vi, describe, it, expect, test, beforeEach } from 'vitest';
+import { renderHook, act } from '@testing-library/react';
+import { showSnackbar, type Visit } from '@openmrs/esm-framework';
+import {
+  invalidateCurrentVisit,
+  invalidateVisitAndEncounterData,
+  usePatientChartStore,
+} from '@openmrs/esm-patient-common-lib';
+import { useDeleteVisit } from './useDeleteVisit';
+import { deleteVisit, restoreVisit } from '../visits-widget/visit.resource';
+
+vi.mock('swr', () => ({
+  useSWRConfig: vi.fn(),
+}));
+
+vi.mock('../visits-widget/visit.resource', async () => {
+  const original = (await vi.importActual('../visits-widget/visit.resource')) as object;
+  return {
+    ...original,
+    deleteVisit: vi.fn(),
+    restoreVisit: vi.fn(),
+  };
+});
+
+vi.mock('@openmrs/esm-patient-common-lib', () => ({
+  invalidateCurrentVisit: vi.fn(),
+  invalidateVisitAndEncounterData: vi.fn(),
+  usePatientChartStore: vi.fn(),
+}));
+
+const mockDeleteVisit = vi.mocked(deleteVisit);
+const mockRestoreVisit = vi.mocked(restoreVisit);
+const mockShowSnackbar = vi.mocked(showSnackbar);
+const mockUseSWRConfig = vi.mocked(useSWRConfig);
+const mockUsePatientChartStore = vi.mocked(usePatientChartStore);
+const mockInvalidateVisitAndEncounterData = vi.mocked(invalidateVisitAndEncounterData);
+
+const mockGlobalMutate = vi.fn();
+const mockSetVisitContext = vi.fn();
+
+const mockVisitType = {
+  uuid: 'visit-type-123',
+  display: 'Outpatient Visit',
+  name: 'Outpatient Visit',
+};
+
+const mockVisit = {
+  uuid: 'visit-123',
+  patient: { uuid: 'patient-123' },
+  visitType: mockVisitType,
+  startDatetime: '2023-01-01T10:00:00Z',
+  stopDatetime: null,
+  location: { uuid: 'location-123', display: 'Test Location' },
+  encounters: [],
+  attributes: [],
+  voided: false,
+  links: [],
+  resourceVersion: '1.8',
+} as Visit;
+
+describe('useDeleteVisit', () => {
+  beforeEach(() => {
+    mockUsePatientChartStore.mockReturnValue({
+      patientUuid: 'patient-123',
+      patient: null,
+      visitContext: null,
+      mutateVisitContext: vi.fn(),
+      setPatient: vi.fn(),
+      setVisitContext: mockSetVisitContext,
+    });
+
+    mockUseSWRConfig.mockReturnValue({
+      mutate: mockGlobalMutate,
+      cache: new Map(),
+    } as any);
+  });
+
+  it('should delete visit successfully and trigger revalidation', async () => {
+    mockDeleteVisit.mockResolvedValue({ data: {} } as any);
+    const onVisitDelete = vi.fn();
+
+    const { result } = renderHook(() => useDeleteVisit(mockVisit, onVisitDelete));
+
+    await act(async () => {
+      result.current.initiateDeletingVisit();
+    });
+
+    expect(mockDeleteVisit).toHaveBeenCalledWith('visit-123');
+    expect(mockInvalidateVisitAndEncounterData).toHaveBeenCalledWith(mockGlobalMutate, 'patient-123');
+
+    expect(mockShowSnackbar).toHaveBeenCalledWith(
+      expect.objectContaining({
+        title: 'Outpatient Visit deleted',
+        subtitle: 'Outpatient Visit deleted successfully',
+        kind: 'success',
+        actionButtonLabel: 'Undo',
+        onActionButtonClick: expect.any(Function),
+      }),
+    );
+
+    expect(onVisitDelete).toHaveBeenCalled();
+  });
+
+  it('should handle delete error and trigger revalidation', async () => {
+    mockDeleteVisit.mockRejectedValue(new Error('Delete failed'));
+    const onVisitDelete = vi.fn();
+
+    const { result } = renderHook(() => useDeleteVisit(mockVisit, onVisitDelete));
+
+    await act(async () => {
+      result.current.initiateDeletingVisit();
+    });
+
+    expect(mockInvalidateVisitAndEncounterData).toHaveBeenCalledWith(mockGlobalMutate, 'patient-123');
+
+    expect(mockShowSnackbar).toHaveBeenCalledWith({
+      title: 'Error deleting visit',
+      kind: 'error',
+      subtitle: 'An error occurred when deleting visit',
+    });
+
+    expect(onVisitDelete).not.toHaveBeenCalled();
+  });
+
+  it('should restore visit successfully when undo is clicked', async () => {
+    mockRestoreVisit.mockResolvedValue({ data: {} } as any);
+    const onVisitRestore = vi.fn();
+
+    const { result } = renderHook(() => useDeleteVisit(mockVisit, undefined, onVisitRestore));
+
+    // First delete to get the restore function
+    mockDeleteVisit.mockResolvedValue({ data: {} } as any);
+    await act(async () => {
+      result.current.initiateDeletingVisit();
+    });
+
+    // Get the restore function from the snackbar
+    const restoreFunction = mockShowSnackbar.mock.calls[0][0].onActionButtonClick;
+
+    // Clear mocks to test restore independently
+    vi.clearAllMocks();
+    mockUsePatientChartStore.mockReturnValue({
+      patientUuid: 'patient-123',
+      patient: null,
+      visitContext: null,
+      mutateVisitContext: vi.fn(),
+      setPatient: vi.fn(),
+      setVisitContext: mockSetVisitContext,
+    });
+    mockUseSWRConfig.mockReturnValue({
+      mutate: mockGlobalMutate,
+      cache: new Map(),
+    } as any);
+
+    // Test restore functionality
+    await act(async () => {
+      restoreFunction();
+    });
+
+    expect(mockRestoreVisit).toHaveBeenCalledWith('visit-123');
+    expect(mockInvalidateVisitAndEncounterData).toHaveBeenCalledWith(mockGlobalMutate, 'patient-123');
+
+    expect(mockShowSnackbar).toHaveBeenCalledWith({
+      title: 'Visit restored',
+      subtitle: 'Outpatient Visit restored successfully',
+      kind: 'success',
+    });
+
+    expect(onVisitRestore).toHaveBeenCalled();
+  });
+
+  it('should handle restore error and trigger revalidation', async () => {
+    mockRestoreVisit.mockRejectedValue(new Error('Restore failed'));
+    const onVisitRestore = vi.fn();
+
+    const { result } = renderHook(() => useDeleteVisit(mockVisit, undefined, onVisitRestore));
+
+    // First delete to get the restore function
+    mockDeleteVisit.mockResolvedValue({ data: {} } as any);
+    await act(async () => {
+      result.current.initiateDeletingVisit();
+    });
+
+    const restoreFunction = mockShowSnackbar.mock.calls[0][0].onActionButtonClick;
+
+    // Clear mocks to test restore independently
+    vi.clearAllMocks();
+    mockUsePatientChartStore.mockReturnValue({
+      patientUuid: 'patient-123',
+      patient: null,
+      visitContext: null,
+      mutateVisitContext: vi.fn(),
+      setPatient: vi.fn(),
+      setVisitContext: mockSetVisitContext,
+    });
+    mockUseSWRConfig.mockReturnValue({
+      mutate: mockGlobalMutate,
+      cache: new Map(),
+    } as any);
+
+    // Test restore error
+    await act(async () => {
+      restoreFunction();
+    });
+
+    expect(mockInvalidateVisitAndEncounterData).toHaveBeenCalledWith(mockGlobalMutate, 'patient-123');
+
+    expect(mockShowSnackbar).toHaveBeenCalledWith({
+      title: "Visit couldn't be restored",
+      subtitle: 'Error occurred when restoring Outpatient Visit',
+      kind: 'error',
+    });
+
+    expect(onVisitRestore).not.toHaveBeenCalled();
+  });
+
+  it('should manage loading state correctly', async () => {
+    mockDeleteVisit.mockResolvedValue({ data: {} } as any);
+
+    const { result } = renderHook(() => useDeleteVisit(mockVisit, () => {}));
+
+    // Initially not deleting
+    expect(result.current.isDeletingVisit).toBe(false);
+
+    // Start deletion and wait for completion
+    await act(async () => {
+      result.current.initiateDeletingVisit();
+    });
+
+    // Should no longer be loading after completion
+    expect(result.current.isDeletingVisit).toBe(false);
+  });
+
+  it('should handle visit with missing patient UUID', () => {
+    const visitWithoutPatient = { ...mockVisit, patient: null };
+
+    expect(() => {
+      renderHook(() => useDeleteVisit(visitWithoutPatient, () => {}));
+    }).not.toThrow();
+  });
+
+  it('should handle visit with empty patient UUID', () => {
+    const visitWithEmptyPatient = { ...mockVisit, patient: { uuid: '' } };
+
+    expect(() => {
+      renderHook(() => useDeleteVisit(visitWithEmptyPatient, () => {}));
+    }).not.toThrow();
+  });
+
+  it('should handle visit with missing visit type display', async () => {
+    const visitWithoutDisplay = {
+      ...mockVisit,
+      visitType: { ...mockVisitType, display: undefined },
+    };
+
+    mockDeleteVisit.mockResolvedValue({ data: {} } as any);
+    const { result } = renderHook(() => useDeleteVisit(visitWithoutDisplay, () => {}));
+
+    await act(async () => {
+      result.current.initiateDeletingVisit();
+    });
+
+    // Should complete without throwing
+    expect(mockDeleteVisit).toHaveBeenCalled();
+  });
+});

package/src/visit/hooks/useDeleteVisit.tsx

@@ -0,0 +1,103 @@
+import { useState } from 'react';
+import { useTranslation } from 'react-i18next';
+import { useSWRConfig } from 'swr';
+import { type Visit, showSnackbar } from '@openmrs/esm-framework';
+import {
+  invalidateCurrentVisit,
+  invalidateVisitAndEncounterData,
+  invalidateVisitByUuid,
+  usePatientChartStore,
+} from '@openmrs/esm-patient-common-lib';
+import { deleteVisit, restoreVisit } from '../visits-widget/visit.resource';
+
+export function useDeleteVisit(activeVisit: Visit, onVisitDelete = () => {}, onVisitRestore = () => {}) {
+  const { t } = useTranslation();
+  const { mutate: globalMutate } = useSWRConfig();
+  const [isDeletingVisit, setIsDeletingVisit] = useState(false);
+  const patientUuid = activeVisit?.patient?.uuid || '';
+  const { visitContext, setVisitContext } = usePatientChartStore(patientUuid);
+
+  const restoreDeletedVisit = () => {
+    restoreVisit(activeVisit?.uuid)
+      .then(({ data: updatedVisit }) => {
+        if (!updatedVisit.stopDatetime) {
+          const mutateSavedOrUpdatedVisit = () => invalidateVisitByUuid(globalMutate, updatedVisit.uuid);
+          setVisitContext(updatedVisit, mutateSavedOrUpdatedVisit);
+        }
+
+        // Use targeted SWR invalidation instead of global mutateVisit
+        invalidateCurrentVisit(globalMutate, patientUuid);
+        invalidateVisitAndEncounterData(globalMutate, patientUuid);
+        window.dispatchEvent(new CustomEvent('queue-entry-updated'));
+
+        showSnackbar({
+          title: t('visitRestored', 'Visit restored'),
+          subtitle: t('visitRestoredSuccessfully', '{{visit}} restored successfully', {
+            visit: activeVisit?.visitType?.display ?? t('visit', 'Visit'),
+          }),
+          kind: 'success',
+        });
+        onVisitRestore?.();
+      })
+      .catch(() => {
+        // On error, revalidate to get correct state
+        invalidateCurrentVisit(globalMutate, patientUuid);
+        invalidateVisitAndEncounterData(globalMutate, patientUuid);
+        showSnackbar({
+          title: t('visitNotRestored', "Visit couldn't be restored"),
+          subtitle: t('errorWhenRestoringVisit', 'Error occurred when restoring {{visit}}', {
+            visit: activeVisit?.visitType?.display ?? t('visit', 'Visit'),
+          }),
+          kind: 'error',
+        });
+      });
+  };
+
+  const initiateDeletingVisit = () => {
+    setIsDeletingVisit(true);
+
+    deleteVisit(activeVisit?.uuid)
+      .then(() => {
+        if (activeVisit.uuid == visitContext?.uuid) {
+          setVisitContext(null, null);
+        }
+
+        // Use targeted SWR invalidation instead of global mutateVisit
+        invalidateCurrentVisit(globalMutate, patientUuid);
+        invalidateVisitAndEncounterData(globalMutate, patientUuid);
+        window.dispatchEvent(new CustomEvent('queue-entry-updated'));
+
+        showSnackbar({
+          title: t('visitDeleted', '{{visit}} deleted', {
+            visit: activeVisit?.visitType?.display ?? t('visit', 'Visit'),
+          }),
+          subtitle: t('visitDeletedSuccessfully', '{{visit}} deleted successfully', {
+            visit: activeVisit?.visitType?.display ?? t('visit', 'Visit'),
+          }),
+          kind: 'success',
+          actionButtonLabel: t('undo', 'Undo'),
+          onActionButtonClick: restoreDeletedVisit,
+        });
+        onVisitDelete?.();
+      })
+      .catch(() => {
+        // On error, revalidate to get correct state
+        invalidateCurrentVisit(globalMutate, patientUuid);
+        invalidateVisitAndEncounterData(globalMutate, patientUuid);
+
+        showSnackbar({
+          title: t('errorDeletingVisit', 'Error deleting visit'),
+          kind: 'error',
+          subtitle: t('errorOccurredDeletingVisit', 'An error occurred when deleting visit'),
+        });
+      })
+      .finally(() => {
+        setIsDeletingVisit(false);
+      });
+  };
+
+  return {
+    initiateDeletingVisit,
+    isDeletingVisit,
+  };
+}

package/src/visit/hooks/useOfflineVisitType.tsx

@@ -0,0 +1,18 @@
+import { type VisitType, useConfig } from '@openmrs/esm-framework';
+import { type ChartConfig } from '../../config-schema';
+import { useEffect, useState } from 'react';
+import { useTranslation } from 'react-i18next';
+
+export const useOfflineVisitType = () => {
+  const config = useConfig() as ChartConfig;
+  const { t } = useTranslation();
+  const [visitTypes, setVisitTypes] = useState<Array<VisitType>>([]);
+
+  useEffect(() => {
+    setVisitTypes([
+      { uuid: config.offlineVisitTypeUuid, name: 'Offline Visit', display: t('offlineVisit', 'Offline Visit') },
+    ]);
+  }, [t, config.offlineVisitTypeUuid]);
+
+  return visitTypes;
+};

package/src/visit/hooks/useRecommendedVisitTypes.tsx

@@ -0,0 +1,34 @@
+import { useMemo } from 'react';
+import useSWR from 'swr';
+import { openmrsFetch, useConfig } from '@openmrs/esm-framework';
+import { type ChartConfig } from '../../config-schema';
+
+interface EnrollmentVisitType {
+  dataDependencies: Array<string>;
+  enrollmentOptions: object;
+  incompatibleWith: Array<string>;
+  name: string;
+  visitTypes: { allowed: Array<EnrollmentVisitType>; disallowed: Array<EnrollmentVisitType> };
+}
+
+export const useRecommendedVisitTypes = (
+  patientUuid: string,
+  enrollmentUuid: string,
+  programUuid: string,
+  locationUuid: string,
+) => {
+  const { visitTypeResourceUrl, showRecommendedVisitTypeTab } = useConfig() as ChartConfig;
+  const url = `${visitTypeResourceUrl}${patientUuid}/program/${programUuid}/enrollment/${enrollmentUuid}?intendedLocationUuid=${locationUuid}`;
+
+  const { data, error, isLoading } = useSWR<{ data: EnrollmentVisitType }>(
+    showRecommendedVisitTypeTab && patientUuid && enrollmentUuid && programUuid ? url : null,
+    openmrsFetch,
+  );
+
+  const recommendedVisitTypes = useMemo(() => data?.data?.visitTypes?.allowed.map(mapToVisitType) ?? [], [data]);
+  return { recommendedVisitTypes, error, isLoading };
+};
+
+const mapToVisitType = (visitType) => {
+  return { ...visitType, display: visitType.name };
+};

package/src/visit/hooks/useVisitAttributeType.tsx

@@ -0,0 +1,102 @@
+import { useMemo } from 'react';
+import { type FetchResponse, openmrsFetch, restBaseUrl } from '@openmrs/esm-framework';
+import useSWRImmutable from 'swr/immutable';
+
+interface VisitAttributeType {
+  uuid: string;
+  display: string;
+  name: string;
+  description: string | null;
+  datatypeClassname:
+    | 'org.openmrs.customdatatype.datatype.ConceptDatatype'
+    | 'org.openmrs.customdatatype.datatype.FloatDatatype'
+    | 'org.openmrs.customdatatype.datatype.BooleanDatatype'
+    | 'org.openmrs.customdatatype.datatype.LongFreeTextDatatype'
+    | 'org.openmrs.customdatatype.datatype.FreeTextDatatype'
+    | 'org.openmrs.customdatatype.datatype.DateDatatype';
+  datatypeConfig: string;
+  preferredHandlerClassname: any;
+  retired: boolean;
+}
+
+interface Concept {
+  uuid: string;
+  name: {
+    display: string;
+  };
+  display: string;
+  answers: Array<{
+    display: string;
+    uuid: string;
+  }>;
+}
+
+const visitAttributeTypeCustomRepresentation =
+  'custom:(uuid,display,name,description,datatypeClassname,datatypeConfig)';
+
+export function useVisitAttributeTypes() {
+  const { data, error, isLoading } = useSWRImmutable<FetchResponse<{ results: VisitAttributeType[] }>, Error>(
+    `${restBaseUrl}/visitattributetype?v=${visitAttributeTypeCustomRepresentation}`,
+    openmrsFetch,
+  );
+
+  if (error) {
+    console.error('Failed to fetch visit attribute types: ', error);
+  }
+
+  const results = useMemo(
+    () => ({
+      isLoading,
+      error,
+      visitAttributeTypes: data?.data?.results ?? [],
+    }),
+    [data, error, isLoading],
+  );
+
+  return results;
+}
+
+export function useVisitAttributeType(uuid) {
+  const { data, error, isLoading } = useSWRImmutable<FetchResponse<VisitAttributeType>, Error>(
+    `${restBaseUrl}/visitattributetype/${uuid}?v=${visitAttributeTypeCustomRepresentation}`,
+    openmrsFetch,
+  );
+
+  if (error) {
+    console.error(`Failed to fetch visit attribute type ${uuid}: `, error);
+  }
+
+  const results = useMemo(
+    () => ({
+      isLoading,
+      error: error,
+      data: data?.data,
+    }),
+    [data, error, isLoading],
+  );
+
+  return results;
+}
+
+export function useConceptAnswersForVisitAttributeType(conceptUuid) {
+  const { data, error, isLoading } = useSWRImmutable<FetchResponse<Concept>, Error>(
+    conceptUuid ? `${restBaseUrl}/concept/${conceptUuid}` : null,
+    openmrsFetch,
+  );
+
+  if (error) {
+    console.error(`Failed to fetch concept answers for visit attribute type ${conceptUuid}: `, error);
+  }
+
+  const results = useMemo(
+    () => ({
+      isLoading,
+      error: error,
+      data: data?.data,
+      answers: data?.data?.answers,
+    }),
+    [data, error, isLoading],
+  );
+
+  return results;
+}