@cccsaurora/howler-ui 2.14.0-dev.248 → 2.14.0-dev.254

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

@@ -1,237 +0,0 @@
-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 useMatchers from './useMatchers';
-// Mock the useContextSelector hook
-vi.mock('use-context-selector', () => ({
-    useContextSelector: vi.fn(),
-    createContext: vi.fn()
-}));
-// Mock lodash-es has function
-vi.mock('lodash-es', () => ({
-    has: vi.fn()
-}));
-// Create mock data
-const mockTemplate = {
-    name: 'test-template',
-    template: 'Test template content'
-};
-const mockOverview = {
-    name: 'test-overview',
-    overview: 'Test overview content'
-};
-const mockDossiers = [
-    {
-        name: 'test-dossier',
-        description: 'Test dossier content'
-    }
-];
-const mockHit = {
-    howler: {
-        id: 'test-hit-id',
-        analytic: 'test-analytic',
-        data: {}
-    }
-};
-const mockHitWithMetadata = {
-    ...mockHit,
-    __template: mockTemplate,
-    __overview: mockOverview,
-    __dossiers: mockDossiers
-};
-const mockGetHit = 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 });
-            }
-            return null;
-        });
-    });
-    describe('getMatchingTemplate', () => {
-        it('should return null when hit is null', async () => {
-            const { result } = renderHook(() => useMatchers());
-            const template = await result.current.getMatchingTemplate(null);
-            expect(template).toBeNull();
-        });
-        it('should return null when hit is undefined', async () => {
-            const { result } = renderHook(() => useMatchers());
-            const template = await result.current.getMatchingTemplate(undefined);
-            expect(template).toBeNull();
-        });
-        it('should return template from metadata when it exists', async () => {
-            const { has } = await import('lodash-es');
-            has.mockReturnValue(true);
-            const { result } = renderHook(() => useMatchers());
-            const template = await result.current.getMatchingTemplate(mockHitWithMetadata);
-            expect(template).toBe(mockTemplate);
-            expect(mockGetHit).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);
-            const { result } = renderHook(() => useMatchers());
-            const template = await result.current.getMatchingTemplate(mockHit);
-            expect(template).toBe(mockTemplate);
-            expect(mockGetHit).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'));
-            const { result } = renderHook(() => useMatchers());
-            await expect(result.current.getMatchingTemplate(mockHit)).resolves.toBeNull();
-            expect(mockGetHit).toHaveBeenCalledWith('test-hit-id', true);
-        });
-    });
-    describe('getMatchingOverview', () => {
-        it('should return null when hit is null', async () => {
-            const { result } = renderHook(() => useMatchers());
-            const overview = await result.current.getMatchingOverview(null);
-            expect(overview).toBeNull();
-        });
-        it('should return null when hit is undefined', async () => {
-            const { result } = renderHook(() => useMatchers());
-            const overview = await result.current.getMatchingOverview(undefined);
-            expect(overview).toBeNull();
-        });
-        it('should return overview from metadata when it exists', async () => {
-            const { has } = await import('lodash-es');
-            has.mockReturnValue(true);
-            const { result } = renderHook(() => useMatchers());
-            const overview = await result.current.getMatchingOverview(mockHitWithMetadata);
-            expect(overview).toBe(mockOverview);
-            expect(mockGetHit).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);
-            const { result } = renderHook(() => useMatchers());
-            const overview = await result.current.getMatchingOverview(mockHit);
-            expect(overview).toBe(mockOverview);
-            expect(mockGetHit).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'));
-            const { result } = renderHook(() => useMatchers());
-            await expect(result.current.getMatchingOverview(mockHit)).resolves.toBeNull();
-            expect(mockGetHit).toHaveBeenCalledWith('test-hit-id', true);
-        });
-    });
-    describe('getMatchingDossiers', () => {
-        it('should return null when hit is null', async () => {
-            const { result } = renderHook(() => useMatchers());
-            const dossiers = await result.current.getMatchingDossiers(null);
-            expect(dossiers).toBeNull();
-        });
-        it('should return null when hit is undefined', async () => {
-            const { result } = renderHook(() => useMatchers());
-            const dossiers = await result.current.getMatchingDossiers(undefined);
-            expect(dossiers).toBeNull();
-        });
-        it('should return dossiers from metadata when they exist', async () => {
-            const { has } = await import('lodash-es');
-            has.mockReturnValue(true);
-            const { result } = renderHook(() => useMatchers());
-            const dossiers = await result.current.getMatchingDossiers(mockHitWithMetadata);
-            expect(dossiers).toBe(mockDossiers);
-            expect(mockGetHit).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);
-            const { result } = renderHook(() => useMatchers());
-            const dossiers = await result.current.getMatchingDossiers(mockHit);
-            expect(dossiers).toBe(mockDossiers);
-            expect(mockGetHit).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'));
-            const { result } = renderHook(() => useMatchers());
-            await expect(result.current.getMatchingDossiers(mockHit)).resolves.toEqual([]);
-            expect(mockGetHit).toHaveBeenCalledWith('test-hit-id', true);
-        });
-    });
-    describe('integration tests', () => {
-        it('should correctly handle has function calls for different metadata properties', async () => {
-            const { has } = await import('lodash-es');
-            // Mock has to return true for __template, false for others
-            has.mockImplementation((_obj, prop) => {
-                return prop === '__template';
-            });
-            const hitWithPartialMetadata = {
-                ...mockHit,
-                __template: mockTemplate
-            };
-            mockGetHit.mockResolvedValue({
-                ...mockHit,
-                __overview: mockOverview,
-                __dossiers: mockDossiers
-            });
-            const { result } = renderHook(() => useMatchers());
-            // Should return template from metadata
-            const template = await result.current.getMatchingTemplate(hitWithPartialMetadata);
-            expect(template).toBe(mockTemplate);
-            // Should fetch overview
-            const overview = await result.current.getMatchingOverview(hitWithPartialMetadata);
-            expect(overview).toBe(mockOverview);
-            // Should fetch dossiers
-            const dossiers = await result.current.getMatchingDossiers(hitWithPartialMetadata);
-            expect(dossiers).toBe(mockDossiers);
-            // Verify has was called with correct parameters
-            expect(has).toHaveBeenCalledWith(hitWithPartialMetadata, '__template');
-            expect(has).toHaveBeenCalledWith(hitWithPartialMetadata, '__overview');
-            expect(has).toHaveBeenCalledWith(hitWithPartialMetadata, '__dossiers');
-        });
-        it('should handle empty or undefined metadata gracefully', async () => {
-            const { has } = await import('lodash-es');
-            has.mockReturnValue(false);
-            mockGetHit.mockResolvedValue({
-                ...mockHit,
-                __template: undefined,
-                __overview: null,
-                __dossiers: []
-            });
-            const { result } = renderHook(() => useMatchers());
-            const template = await result.current.getMatchingTemplate(mockHit);
-            const overview = await result.current.getMatchingOverview(mockHit);
-            const dossiers = await result.current.getMatchingDossiers(mockHit);
-            expect(template).toBeUndefined();
-            expect(overview).toBeNull();
-            expect(dossiers).toEqual([]);
-            expect(mockGetHit).toHaveBeenCalledTimes(3);
-        });
-        it('should maintain referential equality of returned functions', () => {
-            const { result, rerender } = renderHook(() => useMatchers());
-            const firstRender = {
-                getMatchingTemplate: result.current.getMatchingTemplate,
-                getMatchingOverview: result.current.getMatchingOverview,
-                getMatchingDossiers: result.current.getMatchingDossiers
-            };
-            rerender();
-            const secondRender = {
-                getMatchingTemplate: result.current.getMatchingTemplate,
-                getMatchingOverview: result.current.getMatchingOverview,
-                getMatchingDossiers: result.current.getMatchingDossiers
-            };
-            // Functions should be the same reference due to useCallback
-            expect(firstRender.getMatchingTemplate).toBe(secondRender.getMatchingTemplate);
-            expect(firstRender.getMatchingOverview).toBe(secondRender.getMatchingOverview);
-            expect(firstRender.getMatchingDossiers).toBe(secondRender.getMatchingDossiers);
-        });
-    });
-});

package/components/app/hooks/useTitle.d.ts

@@ -1,2 +0,0 @@
-declare const useTitle: () => void;
-export default useTitle;

package/components/app/hooks/useTitle.js

@@ -1,68 +0,0 @@
-import useMySitemap from '@cccsaurora/howler-ui/components/hooks/useMySitemap';
-import { capitalize } from 'lodash-es';
-import { useCallback, useContext, useEffect } from 'react';
-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';
-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 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) {
-                const analytic = await getAnalyticFromId(params.id);
-                if (analytic) {
-                    setTitle(`${t('route.analytics.view')} - ${analytic.name}`);
-                }
-                else {
-                    setTitle(`${t('route.analytics.view')}`);
-                }
-            }
-            else {
-                setTitle(`Howler - ${t('route.analytics')}`);
-            }
-        }
-        else if (searchType === 'hit' && params.id) {
-            const hit = hits[params.id];
-            let newTitle = `${capitalize(hit.howler.escalation)} - ${hit.howler.analytic}`;
-            if (hit.howler.detection) {
-                newTitle += `: ${hit.howler.detection}`;
-            }
-            setTitle(newTitle);
-        }
-        else if (searchType === 'template' && location.pathname.endsWith('view') && searchParams.has('analytic')) {
-            let title = t('route.templates.view');
-            if (searchParams.has('analytic')) {
-                title += ` - ${searchParams.get('analytic')}`;
-            }
-            else if (!searchParams.has('detection')) {
-                title = `Howler - ${title}`;
-            }
-            if (searchParams.has('detection')) {
-                title += `: ${searchParams.get('detection')}`;
-            }
-            setTitle(title);
-        }
-        else {
-            const matchingRoute = sitemap.routes.find(_route => _route.path === location.pathname);
-            if (matchingRoute) {
-                setTitle(`Howler - ${t(matchingRoute.title)}`);
-            }
-        }
-    }, [getAnalyticFromId, location.pathname, params.id, searchParams, hits, setTitle, sitemap.routes, t]);
-    useEffect(() => {
-        runChecks();
-    }, [runChecks]);
-};
-export default useTitle;

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

@@ -1,10 +0,0 @@
-import type { Analytic } from '@cccsaurora/howler-ui/models/entities/generated/Analytic';
-import { type FC, type PropsWithChildren } from 'react';
-interface AnalyticContextType {
-    ready: boolean;
-    analytics: Analytic[];
-    getAnalyticFromId: (id: string) => Promise<Analytic>;
-}
-export declare const AnalyticContext: import("react").Context<AnalyticContextType>;
-declare const AnalyticProvider: FC<PropsWithChildren>;
-export default AnalyticProvider;

package/components/app/providers/AnalyticProvider.js

@@ -1,61 +0,0 @@
-import { jsx as _jsx } from "react/jsx-runtime";
-import api from '@cccsaurora/howler-ui/api';
-import { useAppUser } from '@cccsaurora/howler-ui/commons/components/app/hooks';
-import { createContext, useCallback, useEffect, useState } from 'react';
-export const AnalyticContext = createContext(null);
-/**
- * A set of promises for each analytic search. This is to stop several identical
- * requests from going due to issues with react state updates not happening fast enough
- */
-const PROMISES = {};
-const AnalyticProvider = ({ children }) => {
-    const appUser = useAppUser();
-    const [fetching, setFetching] = useState(false);
-    const [ready, setReady] = useState(false);
-    const [analytics, setAnalytics] = useState([]);
-    const fetchAnalytics = useCallback(async () => {
-        if (ready || fetching) {
-            return;
-        }
-        try {
-            setFetching(true);
-            setAnalytics(((await api.analytic.get()) ?? []));
-            setReady(true);
-        }
-        finally {
-            setFetching(false);
-        }
-    }, [ready, fetching]);
-    useEffect(() => {
-        if (!ready && appUser.isReady()) {
-            fetchAnalytics();
-        }
-    }, [ready, appUser, fetchAnalytics]);
-    const getAnalyticFromId = useCallback(async (id) => {
-        const candidate = analytics?.find(_analytic => _analytic.analytic_id === id);
-        if (candidate) {
-            return candidate;
-        }
-        // We check to see if there's already a request in progress
-        if (!PROMISES[id]) {
-            PROMISES[id] = api.search.analytic.post({
-                query: `analytic_id:${id}`
-            });
-        }
-        try {
-            const result = await PROMISES[id];
-            const analytic = result.items?.[0];
-            if (analytic) {
-                setAnalytics([...(analytics ?? []), analytic]);
-                return analytic;
-            }
-        }
-        catch (e) {
-            // eslint-disable-next-line no-console
-            console.error(e);
-        }
-        return null;
-    }, [analytics]);
-    return (_jsx(AnalyticContext.Provider, { value: { analytics, ready, getAnalyticFromId }, children: children }));
-};
-export default AnalyticProvider;

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

@@ -1,9 +0,0 @@
-import type { ApiType } from '@cccsaurora/howler-ui/models/entities/generated/ApiType';
-import type { FC, PropsWithChildren } from 'react';
-export type ApiConfigContextType = {
-    config: ApiType;
-    setConfig: (config: ApiType) => void;
-};
-export declare const ApiConfigContext: import("react").Context<ApiConfigContextType>;
-declare const ApiConfigProvider: FC<PropsWithChildren>;
-export default ApiConfigProvider;

package/components/app/providers/ApiConfigProvider.js

@@ -1,18 +0,0 @@
-import { jsx as _jsx } from "react/jsx-runtime";
-import { createContext, useMemo, useState } from 'react';
-export const ApiConfigContext = createContext(null);
-const ApiConfigProvider = ({ children }) => {
-    const [config, setConfig] = useState({
-        indexes: null,
-        lookups: null,
-        configuration: null,
-        c12nDef: null,
-        mapping: null
-    });
-    const context = useMemo(() => ({
-        config,
-        setConfig
-    }), [config, setConfig]);
-    return _jsx(ApiConfigContext.Provider, { value: context, children: children });
-};
-export default ApiConfigProvider;

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

@@ -1,10 +0,0 @@
-import type { FC, PropsWithChildren } from 'react';
-import type { AppDrawerProps } from '../drawers/AppDrawerType';
-export type AppDrawerContextState = {
-    close: () => void;
-    open: (props: AppDrawerProps) => void;
-    props: AppDrawerProps;
-};
-export declare const AppDrawerContext: import("react").Context<AppDrawerContextState>;
-declare const AppDrawerProvider: FC<PropsWithChildren>;
-export default AppDrawerProvider;

package/components/app/providers/AppDrawerProvider.js

@@ -1,29 +0,0 @@
-import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-import { Drawer, Typography } from '@mui/material';
-import PageContent from '@cccsaurora/howler-ui/commons/components/pages/PageContent';
-import { createContext, useCallback, useMemo, useState } from 'react';
-import { useTranslation } from 'react-i18next';
-const APPDRAWER_INIT_STATE = {
-    props: { titleKey: null, children: null, onClosed: () => null },
-    close: () => null,
-    open: () => null
-};
-export const AppDrawerContext = createContext(APPDRAWER_INIT_STATE);
-const AppDrawerProvider = ({ children }) => {
-    const { t } = useTranslation();
-    const [isOpen, setOpen] = useState(false);
-    const [props, setProps] = useState(APPDRAWER_INIT_STATE.props);
-    const close = useCallback(() => {
-        setOpen(false);
-        if (props.onClosed) {
-            props.onClosed();
-        }
-    }, [props]);
-    const open = useCallback((_props) => {
-        setOpen(true);
-        setProps(_props);
-    }, []);
-    const context = useMemo(() => ({ props, open, close }), [props, open, close]);
-    return (_jsxs(AppDrawerContext.Provider, { value: context, children: [children, _jsx(Drawer, { anchor: "right", open: isOpen, PaperProps: { sx: { minWidth: 500 } }, onClose: close, children: _jsxs(PageContent, { children: [_jsx(Typography, { variant: "h4", children: t(props.titleKey) }), props.children] }) })] }));
-};
-export default AppDrawerProvider;

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

@@ -1,7 +0,0 @@
-import type { FC, PropsWithChildren } from 'react';
-interface AvatarContextType {
-    getAvatar: (id: string) => Promise<string>;
-}
-export declare const AvatarContext: import("react").Context<AvatarContextType>;
-declare const AvatarProvider: FC<PropsWithChildren>;
-export default AvatarProvider;

package/components/app/providers/AvatarProvider.js

@@ -1,31 +0,0 @@
-import { jsx as _jsx } from "react/jsx-runtime";
-import api from '@cccsaurora/howler-ui/api';
-import useMyApi from '@cccsaurora/howler-ui/components/hooks/useMyApi';
-import { createContext, useCallback } from 'react';
-export const AvatarContext = createContext(null);
-/**
- * Because of the nature of requesting avatars, there's often LOTS of requests firing off in rapid succession,
- * too quickly for React to react (pardon the pun). To circumvent this, we just use a global object to remove race conditions.
- */
-const promises = {};
-const AvatarProvider = ({ children }) => {
-    const { dispatchApi } = useMyApi();
-    const getAvatar = useCallback((id) => {
-        if (!id) {
-            return Promise.resolve('');
-        }
-        if (promises[id]) {
-            return promises[id];
-        }
-        try {
-            promises[id] = dispatchApi(api.user.avatar.get(id), { logError: false, showError: false, throwError: false });
-            return promises[id];
-        }
-        catch (e) {
-            promises[id] = api.user.get(id).then(user => user.name);
-            return promises[id];
-        }
-    }, [dispatchApi]);
-    return _jsx(AvatarContext.Provider, { value: { getAvatar }, children: children });
-};
-export default AvatarProvider;

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

@@ -1,3 +0,0 @@
-import type { FC, PropsWithChildren } from 'react';
-declare const CustomPluginProvider: FC<PropsWithChildren>;
-export default CustomPluginProvider;

package/components/app/providers/CustomPluginProvider.js

@@ -1,14 +0,0 @@
-import { jsx as _jsx } from "react/jsx-runtime";
-import howlerPluginStore from '@cccsaurora/howler-ui/plugins/store';
-import { usePluginStore } from 'react-pluggable';
-const CustomPluginProvider = ({ children }) => {
-    const pluginStore = usePluginStore();
-    return howlerPluginStore.plugins.reduce((_children, plugin) => {
-        const Provider = pluginStore.executeFunction(`${plugin}.provider`);
-        if (!Provider) {
-            return _children;
-        }
-        return _jsx(Provider, { children: _children });
-    }, children);
-};
-export default CustomPluginProvider;

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

@@ -1,4 +0,0 @@
-import { type FC, type PropsWithChildren } from 'react';
-export declare const FavouriteContext: import("react").Context<object>;
-declare const FavouriteProvider: FC<PropsWithChildren>;
-export default FavouriteProvider;

package/components/app/providers/FavouritesProvider.js

@@ -1,134 +0,0 @@
-import { jsx as _jsx } from "react/jsx-runtime";
-import { QueryStats, SavedSearch } from '@mui/icons-material';
-import { useAppLeftNav, useAppUser } from '@cccsaurora/howler-ui/commons/components/app/hooks';
-import { sortBy, uniq } from 'lodash-es';
-import { createContext, useCallback, useContext, useEffect } from 'react';
-import { useTranslation } from 'react-i18next';
-import { useContextSelector } from 'use-context-selector';
-import { AnalyticContext } from './AnalyticProvider';
-import { ViewContext } from './ViewProvider';
-export const FavouriteContext = createContext(null);
-const FavouriteProvider = ({ children }) => {
-    const { t } = useTranslation();
-    const leftNav = useAppLeftNav();
-    const appUser = useAppUser();
-    const analytics = useContext(AnalyticContext);
-    const fetchViews = useContextSelector(ViewContext, ctx => ctx.fetchViews);
-    const processViewElement = useCallback(async () => {
-        const viewElement = leftNav.elements.find(el => el.element?.id === 'views');
-        const favourites = uniq(appUser.user?.favourite_views || []);
-        // There are no favourites and no nav elements - return
-        if (favourites.length < 1 && !viewElement) {
-            return null;
-        }
-        // There are no favourites, but the nav element exists - remove it
-        if (favourites.length < 1) {
-            return null;
-        }
-        // The favourite list is fully represented, skip
-        if (favourites.length === viewElement?.element?.items?.length) {
-            return viewElement;
-        }
-        const savedViews = await fetchViews(favourites);
-        const items = sortBy(savedViews, 'title')
-            .filter(view => !!view)
-            .map(view => ({
-            id: view.view_id,
-            text: t(view.title),
-            route: `/views/${view.view_id}`,
-            nested: true
-        }));
-        if (viewElement) {
-            const newViewElement = {
-                type: 'group',
-                element: {
-                    ...viewElement.element,
-                    items
-                }
-            };
-            return newViewElement;
-        }
-        else {
-            return {
-                type: 'group',
-                element: {
-                    id: 'views',
-                    i18nKey: 'route.views.saved',
-                    icon: _jsx(SavedSearch, {}),
-                    items
-                }
-            };
-        }
-    }, [appUser.user?.favourite_views, fetchViews, leftNav.elements, t]);
-    const processAnalyticElement = useCallback(() => {
-        const analyticElement = leftNav.elements.find(el => el.element?.id === 'analytics');
-        const favourites = appUser.user?.favourite_analytics;
-        // There are no favourites and no nav elements - return
-        if (favourites.length < 1 && !analyticElement) {
-            return null;
-        }
-        // There are no favourites, but the nav element exists - remove it
-        if (favourites.length < 1) {
-            return null;
-        }
-        // The favourite list is fully represented, skip
-        if (favourites.length === analyticElement?.element?.items?.length) {
-            return analyticElement;
-        }
-        const items = favourites
-            .map(aid => {
-            const analytic = analytics.analytics.find(v => v.analytic_id === aid);
-            return analytic
-                ? {
-                    id: analytic.analytic_id,
-                    text: t(analytic.name),
-                    route: `/analytics/${analytic.analytic_id}`,
-                    nested: true
-                }
-                : null;
-        })
-            .filter(v => !!v);
-        if (analyticElement) {
-            return {
-                type: 'group',
-                element: {
-                    ...analyticElement.element,
-                    items
-                }
-            };
-        }
-        else {
-            return {
-                type: 'group',
-                element: {
-                    id: 'analytics',
-                    i18nKey: 'route.analytics.pinned',
-                    icon: _jsx(QueryStats, {}),
-                    items
-                }
-            };
-        }
-    }, [analytics.analytics, appUser.user?.favourite_analytics, leftNav, t]);
-    useEffect(() => {
-        if (!appUser.isReady() || !analytics.ready) {
-            return;
-        }
-        const newElements = leftNav.elements
-            .filter(el => !['views', 'analytics'].includes(el.element?.id))
-            .filter(el => !!el);
-        (async () => {
-            const analyticElement = processAnalyticElement();
-            if (analyticElement) {
-                newElements.splice(1, 0, analyticElement);
-            }
-            const viewElement = await processViewElement();
-            if (viewElement) {
-                newElements.splice(1, 0, viewElement);
-            }
-            leftNav.setElements(newElements);
-        })();
-        // eslint-disable-next-line react-hooks/exhaustive-deps
-    }, [analytics.ready, appUser]);
-    return _jsx(FavouriteContext.Provider, { value: {}, children: children });
-};
-export default FavouriteProvider;

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

@@ -1,9 +0,0 @@
-import type { SearchField } from '@cccsaurora/howler-ui/api/search/fields';
-import type { FC, PropsWithChildren } from 'react';
-interface FieldProviderType {
-    hitFields: SearchField[];
-    getHitFields: () => Promise<SearchField[]>;
-}
-export declare const FieldContext: import("react").Context<FieldProviderType>;
-declare const FieldProvider: FC<PropsWithChildren>;
-export default FieldProvider;