@cccsaurora/howler-ui 2.12.0-dev.30

package/dist/components/app/drawers/ViewGroupsDrawer.js

@@ -0,0 +1,6 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Box, Divider, Stack, Typography } from '@mui/material';
+const ViewGroupsDrawer = ({ groups }) => {
+    return (_jsx(Stack, { direction: "column", spacing: 1, sx: { mt: 2 }, divider: _jsx(Divider, { orientation: "horizontal" }), children: groups.map(g => (_jsxs(Box, { children: [_jsx(Typography, { variant: "body1", children: g.name }), _jsx(Typography, { variant: "caption", color: "text.disabled", children: g.id })] }, g.id))) }));
+};
+export default ViewGroupsDrawer;

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

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

package/dist/components/app/hooks/useTitle.js

@@ -0,0 +1,67 @@
+import api from 'api';
+import useMySitemap from '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 { AnalyticContext } from '../providers/AnalyticProvider';
+const useTitle = () => {
+    const { t } = useTranslation();
+    const location = useLocation();
+    const params = useParams();
+    const searchParams = useSearchParams()[0];
+    const sitemap = useMySitemap();
+    const { getAnalyticFromId } = useContext(AnalyticContext);
+    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 result = await api.search.hit.post({ query: `howler.id:${params.id}`, rows: 1 });
+            const hit = result.items[0];
+            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, setTitle, sitemap.routes, t]);
+    useEffect(() => {
+        runChecks();
+    }, [runChecks]);
+};
+export default useTitle;

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

@@ -0,0 +1,14 @@
+import type { Analytic } from 'models/entities/generated/Analytic';
+import { type FC, type PropsWithChildren } from 'react';
+interface AnalyticContextType {
+    ready: boolean;
+    analytics: Analytic[];
+    addFavourite: (analytic: Analytic) => Promise<void>;
+    removeFavourite: (analytic: Analytic) => Promise<void>;
+    getIdFromName: (name: string) => Promise<string>;
+    getAnalyticFromName: (name: string) => Promise<Analytic>;
+    getAnalyticFromId: (id: string) => Promise<Analytic>;
+}
+export declare const AnalyticContext: import("react").Context<AnalyticContextType>;
+declare const AnalyticProvider: FC<PropsWithChildren>;
+export default AnalyticProvider;

package/dist/components/app/providers/AnalyticProvider.js

@@ -0,0 +1,104 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import api from 'api';
+import { useAppUser } from 'commons/components/app/hooks';
+import { createContext, useCallback, useEffect, useState } from 'react';
+import { sanitizeLuceneQuery } from 'utils/stringUtils';
+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 addFavourite = useCallback(async (analytic) => {
+        await api.analytic.favourite.post(analytic.analytic_id);
+        appUser.setUser({
+            ...appUser.user,
+            favourite_analytics: [...appUser.user.favourite_analytics, analytic.analytic_id]
+        });
+    }, [appUser]);
+    const removeFavourite = useCallback(async (analytic) => {
+        await api.analytic.favourite.del(analytic.analytic_id);
+        appUser.setUser({
+            ...appUser.user,
+            favourite_analytics: appUser.user.favourite_analytics.filter(v => v !== analytic.analytic_id)
+        });
+    }, [appUser]);
+    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]);
+    const getAnalyticFromName = useCallback(async (name) => {
+        const candidate = analytics.find(_analytic => _analytic.name === name);
+        if (candidate) {
+            return candidate;
+        }
+        // We check to see if there's already a request in progress
+        if (!PROMISES[name]) {
+            PROMISES[name] = api.search.analytic.post({
+                query: `name:(${sanitizeLuceneQuery(name)})`
+            });
+        }
+        try {
+            const result = await PROMISES[name];
+            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]);
+    const getIdFromName = useCallback(async (name) => {
+        return (await getAnalyticFromName(name))?.analytic_id;
+    }, [getAnalyticFromName]);
+    return (_jsx(AnalyticContext.Provider, { value: { analytics, ready, addFavourite, removeFavourite, getAnalyticFromName, getAnalyticFromId, getIdFromName }, children: children }));
+};
+export default AnalyticProvider;

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

@@ -0,0 +1,9 @@
+import type { ApiType } from '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/dist/components/app/providers/ApiConfigProvider.js

@@ -0,0 +1,17 @@
+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
+    });
+    const context = useMemo(() => ({
+        config,
+        setConfig
+    }), [config, setConfig]);
+    return _jsx(ApiConfigContext.Provider, { value: context, children: children });
+};
+export default ApiConfigProvider;

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

@@ -0,0 +1,10 @@
+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/dist/components/app/providers/AppDrawerProvider.js

@@ -0,0 +1,29 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Drawer, Typography } from '@mui/material';
+import PageContent from '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/dist/components/app/providers/AvatarProvider.d.ts

@@ -0,0 +1,7 @@
+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/dist/components/app/providers/AvatarProvider.js

@@ -0,0 +1,31 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import api from 'api';
+import useMyApi from '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/dist/components/app/providers/CustomPluginProvider.d.ts

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

package/dist/components/app/providers/CustomPluginProvider.js

@@ -0,0 +1,14 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import howlerPluginStore from '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/dist/components/app/providers/DossierProvider.d.ts

@@ -0,0 +1,15 @@
+import type { Dossier } from 'models/entities/generated/Dossier';
+import { type FC, type PropsWithChildren } from 'react';
+export interface DossierContextType {
+    ready: boolean;
+    dossiers: Dossier[];
+    fetchDossiers: (force?: boolean) => Promise<void>;
+    addDossier: (v: Dossier) => Promise<Dossier>;
+    editDossier: (dossier: Dossier) => Promise<Dossier>;
+    removeDossier: (id: string) => Promise<void>;
+    getCurrentDossiers: () => Dossier[];
+    getMatchingDossiers: (id: string) => Promise<Dossier[]>;
+}
+export declare const DossierContext: import("use-context-selector").Context<DossierContextType>;
+declare const DossierProvider: FC<PropsWithChildren>;
+export default DossierProvider;

package/dist/components/app/providers/DossierProvider.js

@@ -0,0 +1,79 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import api from 'api';
+import { useAppUser } from 'commons/components/app/hooks';
+import useMyApi from 'components/hooks/useMyApi';
+import { useCallback, useEffect, useState } from 'react';
+import { createContext } from 'use-context-selector';
+export const DossierContext = createContext(null);
+const DossierProvider = ({ children }) => {
+    const { dispatchApi } = useMyApi();
+    const appUser = useAppUser();
+    const [loading, setLoading] = useState(false);
+    const [ready, setReady] = useState(false);
+    const [dossiers, setDossiers] = useState([]);
+    const [idToDossiers, setIdToDossiers] = useState({});
+    const fetchDossiers = useCallback(async (force = false) => {
+        if (ready && !force) {
+            return;
+        }
+        if (!appUser.isReady()) {
+            return;
+        }
+        setLoading(true);
+        try {
+            setDossiers((await api.dossier.get()));
+            setReady(true);
+        }
+        finally {
+            setLoading(false);
+        }
+    }, [appUser, ready]);
+    useEffect(() => {
+        if (!ready && !loading) {
+            fetchDossiers();
+        }
+    }, [fetchDossiers, ready, loading]);
+    const getCurrentDossiers = useCallback(() => {
+        return [];
+    }, []);
+    const editDossier = useCallback(async (dossier) => {
+        const result = await api.dossier.put(dossier.dossier_id, dossier);
+        setDossiers(_dossiers => _dossiers.map(_dossier => (_dossier.dossier_id === dossier.dossier_id ? { ..._dossier, dossier } : _dossier)));
+        return result;
+    }, []);
+    const addDossier = useCallback(async (dossier) => {
+        const newDossier = await dispatchApi(api.dossier.post(dossier));
+        setDossiers(_dossiers => [..._dossiers, newDossier]);
+        return newDossier;
+    }, [dispatchApi]);
+    const removeDossier = useCallback(async (id) => {
+        const result = await api.dossier.del(id);
+        setDossiers(_dossiers => _dossiers.filter(v => v.dossier_id !== id));
+        return result;
+    }, []);
+    const getMatchingDossiers = useCallback(async (id) => {
+        if (idToDossiers[id]) {
+            return idToDossiers[id];
+        }
+        const result = await dispatchApi(api.dossier.hit.get(id), { throwError: false });
+        if (result) {
+            setIdToDossiers(_dossiers => ({
+                ..._dossiers,
+                [id]: result
+            }));
+            return result;
+        }
+        return [];
+    }, [dispatchApi, idToDossiers]);
+    return (_jsx(DossierContext.Provider, { value: {
+            ready,
+            dossiers,
+            fetchDossiers,
+            addDossier,
+            editDossier,
+            removeDossier,
+            getCurrentDossiers,
+            getMatchingDossiers
+        }, children: children }));
+};
+export default DossierProvider;

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

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

package/dist/components/app/providers/FavouritesProvider.js

@@ -0,0 +1,137 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { QueryStats, SavedSearch } from '@mui/icons-material';
+import { useAppLeftNav, useAppUser } from 'commons/components/app/hooks';
+import { uniqBy } 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 views = useContextSelector(ViewContext, ctx => ctx.views);
+    const viewsReady = useContextSelector(ViewContext, ctx => ctx.ready);
+    const processViewElement = useCallback(() => {
+        const viewElement = leftNav.elements.find(el => el.element?.id === 'views');
+        const favourites = 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 items = uniqBy(favourites
+            .map(view_id => {
+            const view = views?.find(v => v.view_id === view_id);
+            return view
+                ? {
+                    id: view.view_id,
+                    text: t(view.title),
+                    route: `/views/${view.view_id}`,
+                    nested: true
+                }
+                : null;
+        })
+            .filter(v => !!v), val => val.id);
+        if (viewElement) {
+            const newViewElement = {
+                ...viewElement,
+                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, leftNav, t, views]);
+    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 {
+                ...analyticElement,
+                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() || !viewsReady || !analytics.ready) {
+            return;
+        }
+        const newElements = leftNav.elements
+            .filter(el => !['views', 'analytics'].includes(el.element?.id))
+            .filter(el => !!el);
+        const analyticElement = processAnalyticElement();
+        if (analyticElement) {
+            newElements.splice(1, 0, analyticElement);
+        }
+        const viewElement = processViewElement();
+        if (viewElement) {
+            newElements.splice(1, 0, viewElement);
+        }
+        leftNav.setElements(newElements);
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, [analytics.ready, appUser, viewsReady]);
+    return _jsx(FavouriteContext.Provider, { value: {}, children: children });
+};
+export default FavouriteProvider;

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

@@ -0,0 +1,9 @@
+import type { SearchField } from '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;

package/dist/components/app/providers/FieldProvider.js

@@ -0,0 +1,19 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import api from 'api';
+import useMyApi from 'components/hooks/useMyApi';
+import { createContext, useCallback, useState } from 'react';
+export const FieldContext = createContext(null);
+const FieldProvider = ({ children }) => {
+    const { dispatchApi } = useMyApi();
+    const [hitFields, setHitFields] = useState([]);
+    const getHitFields = useCallback(async () => {
+        if (hitFields.length) {
+            return hitFields;
+        }
+        const fields = await dispatchApi(api.search.fields.hit.get());
+        setHitFields(fields);
+        return fields;
+    }, [dispatchApi, hitFields]);
+    return _jsx(FieldContext.Provider, { value: { hitFields, getHitFields }, children: children });
+};
+export default FieldProvider;

package/dist/components/app/providers/HitProvider.d.ts

@@ -0,0 +1,20 @@
+import type { Hit } from 'models/entities/generated/Hit';
+import type { FC, PropsWithChildren } from 'react';
+interface HitProviderType {
+    hits: {
+        [index: string]: Hit;
+    };
+    selectedHits: Hit[];
+    addHitToSelection: (id: string) => void;
+    removeHitFromSelection: (id: string) => void;
+    clearSelectedHits: (except?: string) => void;
+    loadHits: (hits: Hit[]) => void;
+    updateHit: (newHit: Hit) => void;
+    getHit: (id: string, force?: boolean) => Promise<Hit>;
+}
+export declare const HitContext: import("use-context-selector").Context<HitProviderType>;
+/**
+ * Central repository for storing individual hit data across the application. Allows efficient retrieval of hits across componenents.
+ */
+declare const HitProvider: FC<PropsWithChildren>;
+export default HitProvider;