@cccsaurora/howler-ui 2.19.0-dev.839 → 2.19.0-dev.842

package/components/app/hooks/useMatchers.test.js

@@ -1,7 +1,7 @@
 import { renderHook } from '@testing-library/react';
 import { useContextSelector } from 'use-context-selector';
 import { beforeEach, describe, expect, it, vi } from 'vitest';
-import { HitContext } from '../providers/HitProvider';
+import { RecordContext } from '../providers/RecordProvider';
 import useMatchers from './useMatchers';
 // Mock the useContextSelector hook
 vi.mock('use-context-selector', () => ({
@@ -40,14 +40,14 @@ const mockHitWithMetadata = {
     __overview: mockOverview,
     __dossiers: mockDossiers
 };
-const mockGetHit = vi.fn();
+const mockGetRecord = vi.fn();
 describe('useMatchers', () => {
     beforeEach(() => {
         vi.clearAllMocks();
         // Mock useContextSelector to return our mock getHit function
         useContextSelector.mockImplementation((context, selector) => {
-            if (context === HitContext) {
-                return selector({ getHit: mockGetHit });
+            if (context === RecordContext) {
+                return selector({ getRecord: mockGetRecord });
             }
             return null;
         });
@@ -69,25 +69,25 @@ describe('useMatchers', () => {
             const { result } = renderHook(() => useMatchers());
             const template = await result.current.getMatchingTemplate(mockHitWithMetadata);
             expect(template).toBe(mockTemplate);
-            expect(mockGetHit).not.toHaveBeenCalled();
+            expect(mockGetRecord).not.toHaveBeenCalled();
         });
         it('should fetch hit with metadata when template is not present', async () => {
             const { has } = await import('lodash-es');
             has.mockReturnValue(false);
             const hitWithFetchedMetadata = { ...mockHit, __template: mockTemplate };
-            mockGetHit.mockResolvedValue(hitWithFetchedMetadata);
+            mockGetRecord.mockResolvedValue(hitWithFetchedMetadata);
             const { result } = renderHook(() => useMatchers());
             const template = await result.current.getMatchingTemplate(mockHit);
             expect(template).toBe(mockTemplate);
-            expect(mockGetHit).toHaveBeenCalledWith('test-hit-id', true);
+            expect(mockGetRecord).toHaveBeenCalledWith('test-hit-id', true);
         });
         it('should handle getHit rejection gracefully', async () => {
             const { has } = await import('lodash-es');
             has.mockReturnValue(false);
-            mockGetHit.mockRejectedValue(new Error('Failed to fetch hit'));
+            mockGetRecord.mockRejectedValue(new Error('Failed to fetch hit'));
             const { result } = renderHook(() => useMatchers());
             await expect(result.current.getMatchingTemplate(mockHit)).resolves.toBeNull();
-            expect(mockGetHit).toHaveBeenCalledWith('test-hit-id', true);
+            expect(mockGetRecord).toHaveBeenCalledWith('test-hit-id', true);
         });
     });
     describe('getMatchingOverview', () => {
@@ -107,25 +107,25 @@ describe('useMatchers', () => {
             const { result } = renderHook(() => useMatchers());
             const overview = await result.current.getMatchingOverview(mockHitWithMetadata);
             expect(overview).toBe(mockOverview);
-            expect(mockGetHit).not.toHaveBeenCalled();
+            expect(mockGetRecord).not.toHaveBeenCalled();
         });
         it('should fetch hit with metadata when overview is not present', async () => {
             const { has } = await import('lodash-es');
             has.mockReturnValue(false);
             const hitWithFetchedMetadata = { ...mockHit, __overview: mockOverview };
-            mockGetHit.mockResolvedValue(hitWithFetchedMetadata);
+            mockGetRecord.mockResolvedValue(hitWithFetchedMetadata);
             const { result } = renderHook(() => useMatchers());
             const overview = await result.current.getMatchingOverview(mockHit);
             expect(overview).toBe(mockOverview);
-            expect(mockGetHit).toHaveBeenCalledWith('test-hit-id', true);
+            expect(mockGetRecord).toHaveBeenCalledWith('test-hit-id', true);
         });
         it('should handle getHit rejection gracefully', async () => {
             const { has } = await import('lodash-es');
             has.mockReturnValue(false);
-            mockGetHit.mockRejectedValue(new Error('Failed to fetch hit'));
+            mockGetRecord.mockRejectedValue(new Error('Failed to fetch hit'));
             const { result } = renderHook(() => useMatchers());
             await expect(result.current.getMatchingOverview(mockHit)).resolves.toBeNull();
-            expect(mockGetHit).toHaveBeenCalledWith('test-hit-id', true);
+            expect(mockGetRecord).toHaveBeenCalledWith('test-hit-id', true);
         });
     });
     describe('getMatchingDossiers', () => {
@@ -145,25 +145,25 @@ describe('useMatchers', () => {
             const { result } = renderHook(() => useMatchers());
             const dossiers = await result.current.getMatchingDossiers(mockHitWithMetadata);
             expect(dossiers).toBe(mockDossiers);
-            expect(mockGetHit).not.toHaveBeenCalled();
+            expect(mockGetRecord).not.toHaveBeenCalled();
         });
         it('should fetch hit with metadata when dossiers are not present', async () => {
             const { has } = await import('lodash-es');
             has.mockReturnValue(false);
             const hitWithFetchedMetadata = { ...mockHit, __dossiers: mockDossiers };
-            mockGetHit.mockResolvedValue(hitWithFetchedMetadata);
+            mockGetRecord.mockResolvedValue(hitWithFetchedMetadata);
             const { result } = renderHook(() => useMatchers());
             const dossiers = await result.current.getMatchingDossiers(mockHit);
             expect(dossiers).toBe(mockDossiers);
-            expect(mockGetHit).toHaveBeenCalledWith('test-hit-id', true);
+            expect(mockGetRecord).toHaveBeenCalledWith('test-hit-id', true);
         });
         it('should handle getHit rejection gracefully', async () => {
             const { has } = await import('lodash-es');
             has.mockReturnValue(false);
-            mockGetHit.mockRejectedValue(new Error('Failed to fetch hit'));
+            mockGetRecord.mockRejectedValue(new Error('Failed to fetch hit'));
             const { result } = renderHook(() => useMatchers());
             await expect(result.current.getMatchingDossiers(mockHit)).resolves.toEqual([]);
-            expect(mockGetHit).toHaveBeenCalledWith('test-hit-id', true);
+            expect(mockGetRecord).toHaveBeenCalledWith('test-hit-id', true);
         });
     });
     describe('integration tests', () => {
@@ -177,7 +177,7 @@ describe('useMatchers', () => {
                 ...mockHit,
                 __template: mockTemplate
             };
-            mockGetHit.mockResolvedValue({
+            mockGetRecord.mockResolvedValue({
                 ...mockHit,
                 __overview: mockOverview,
                 __dossiers: mockDossiers
@@ -200,7 +200,7 @@ describe('useMatchers', () => {
         it('should handle empty or undefined metadata gracefully', async () => {
             const { has } = await import('lodash-es');
             has.mockReturnValue(false);
-            mockGetHit.mockResolvedValue({
+            mockGetRecord.mockResolvedValue({
                 ...mockHit,
                 __template: undefined,
                 __overview: null,
@@ -213,7 +213,7 @@ describe('useMatchers', () => {
             expect(template).toBeUndefined();
             expect(overview).toBeNull();
             expect(dossiers).toEqual([]);
-            expect(mockGetHit).toHaveBeenCalledTimes(3);
+            expect(mockGetRecord).toHaveBeenCalledTimes(3);
         });
         it('should maintain referential equality of returned functions', () => {
             const { result, rerender } = renderHook(() => useMatchers());

package/components/app/hooks/useTitle.js

@@ -5,23 +5,23 @@ import { useTranslation } from 'react-i18next';
 import { useLocation, useParams, useSearchParams } from 'react-router-dom';
 import { useContextSelector } from 'use-context-selector';
 import { AnalyticContext } from '../providers/AnalyticProvider';
-import { HitContext } from '../providers/HitProvider';
+import { RecordContext } from '../providers/RecordProvider';
 const useTitle = () => {
     const { t } = useTranslation();
     const location = useLocation();
     const params = useParams();
     const searchParams = useSearchParams()[0];
     const sitemap = useMySitemap();
-    const { getAnalyticFromId } = useContext(AnalyticContext);
-    const hits = useContextSelector(HitContext, ctx => ctx.hits);
-    const getHit = useContextSelector(HitContext, ctx => ctx.getHit);
+    const { getAnalyticFromId } = useContext(AnalyticContext) ?? {};
+    const hits = useContextSelector(RecordContext, ctx => ctx.records);
+    const getHit = useContextSelector(RecordContext, ctx => ctx.getRecord);
     const setTitle = useCallback((title) => {
         document.querySelector('title').innerHTML = title;
     }, []);
     const runChecks = useCallback(async () => {
         const searchType = location.pathname.replace(/^\/(\w+)(\/.+)?$/, '$1').replace(/s$/, '');
         if (searchType === 'analytic') {
-            if (params.id) {
+            if (params.id && getAnalyticFromId) {
                 const analytic = await getAnalyticFromId(params.id);
                 if (analytic) {
                     setTitle(`${t('route.analytics.view')} - ${analytic.name}`);

package/components/app/providers/FavouritesProvider.js

@@ -120,11 +120,11 @@ const FavouriteProvider = ({ children }) => {
         (async () => {
             const analyticElement = processAnalyticElement();
             if (analyticElement) {
-                newElements.splice(1, 0, analyticElement);
+                newElements.splice(2, 0, analyticElement);
             }
             const viewElement = await processViewElement();
             if (viewElement) {
-                newElements.splice(1, 0, viewElement);
+                newElements.splice(2, 0, viewElement);
             }
             leftNav.setElements(newElements);
         })();

package/components/app/providers/ModalProvider.d.ts

@@ -1,6 +1,7 @@
 import type { FC, PropsWithChildren, ReactNode } from 'react';
 export interface ModalOptions {
     disableClose?: boolean;
+    height?: number | string | null;
     maxWidth?: string;
     maxHeight?: string;
 }

package/components/app/providers/ParameterProvider.d.ts

@@ -1,4 +1,5 @@
 import type { FC, PropsWithChildren } from 'react';
+export type SearchIndex = 'hit' | 'observable' | 'case';
 export interface ParameterContextType {
     selected?: string;
     query?: string;
@@ -6,6 +7,7 @@ export interface ParameterContextType {
     trackTotalHits: boolean;
     sort?: string;
     span?: string;
+    indexes?: SearchIndex[];
     filters?: string[];
     startDate?: string;
     endDate?: string;
@@ -19,11 +21,16 @@ export interface ParameterContextType {
     addFilter: (filter: string) => void;
     removeFilter: (filter: string) => void;
     setFilter: (index: number, filter: string) => void;
-    clearFilters: () => void;
+    resetFilters: () => void;
+    addIndex: (index: SearchIndex) => void;
+    removeIndex: (index: SearchIndex) => void;
+    setIndex: (position: number, index: SearchIndex) => void;
+    setIndexes: (indexes: SearchIndex[]) => void;
+    resetIndexes: () => void;
     addView: (view: string) => void;
     removeView: (view: string) => void;
     setView: (index: number, view: string) => void;
-    clearViews: () => void;
+    resetViews: () => void;
 }
 export declare const ParameterContext: import("use-context-selector").Context<ParameterContextType>;
 /**