@cccsaurora/howler-ui 2.14.0-dev.268 → 2.14.0-dev.271

package/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/components/app/providers/CustomPluginProvider.js

@@ -0,0 +1,14 @@
+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

@@ -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/components/app/providers/FavouritesProvider.js

@@ -0,0 +1,134 @@
+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

@@ -0,0 +1,9 @@
+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;

package/components/app/providers/FieldProvider.js

@@ -0,0 +1,19 @@
+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, 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/components/app/providers/HitProvider.d.ts

@@ -0,0 +1,22 @@
+import type { Hit } from '@cccsaurora/howler-ui/models/entities/generated/Hit';
+import type { WithMetadata } from '@cccsaurora/howler-ui/models/WithMetadata';
+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<WithMetadata<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 declare const useHitContextSelector: <Selected>(selector: (value: HitProviderType) => Selected) => Selected;
+export default HitProvider;

package/components/app/providers/HitProvider.js

@@ -0,0 +1,113 @@
+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 { uniq } from 'lodash-es';
+import { useCallback, useContext, useEffect, useMemo, useRef, useState } from 'react';
+import { createContext, useContextSelector } from 'use-context-selector';
+import { SocketContext } from './SocketProvider';
+export const HitContext = createContext(null);
+/**
+ * Central repository for storing individual hit data across the application. Allows efficient retrieval of hits across componenents.
+ */
+const HitProvider = ({ children }) => {
+    const { dispatchApi } = useMyApi();
+    const { addListener, removeListener } = useContext(SocketContext);
+    /**
+     * The most immediate of two levels of caching, this ref stores the raw promises for each hit.
+     * Rapidly updates, good for uses in-context where parallel updates my be occurring, i.e.
+     * when two cards request the same hit that's missing from the store. Used in getHit for this reason.
+     */
+    const hitRequests = useRef({});
+    /**
+     * The "Authoritative" store of hits. Changes here will trigger rerenders, and essentially
+     * caches the result of the above promises. Slower to update, so used outside of the hitcontext
+     * where parallel requests aren't an issue.
+     */
+    const [hits, setHits] = useState({});
+    const [selectedHitIds, setSelectedHitIds] = useState([]);
+    // The central location where we propagate any changes from hits made via websockets into the repository. We just save every update,
+    // instead of caching it across many components inconsistently as before.
+    const handler = useMemo(() => (data) => {
+        if (data.hit) {
+            // eslint-disable-next-line no-console
+            console.debug('Received websocket update for hit', data.hit.howler.id);
+            hitRequests.current[data.hit.howler.id] = Promise.resolve(data.hit);
+            setHits(_hits => ({
+                ..._hits,
+                [data.hit.howler.id]: {
+                    ..._hits[data.hit.howler.id],
+                    ...data.hit
+                }
+            }));
+        }
+    }, []);
+    useEffect(() => {
+        addListener('hit_provider', handler);
+        return () => removeListener('hit_provider');
+    }, [addListener, handler, removeListener]);
+    /**
+     * A method to retrieve a hit from the context. It first checks the hit state,
+     * then checks for ongoing requests, then finally executes a new request if necessary.
+     */
+    const getHit = useCallback(async (id, force = false) => {
+        if (!hitRequests.current[id] || force) {
+            hitRequests.current[id] = dispatchApi(api.hit.get(id, ['template', 'dossiers', 'analytic', 'overview']));
+            const newHit = await hitRequests.current[id];
+            setHits(_hits => ({ ..._hits, [id]: newHit }));
+        }
+        return hitRequests.current[id];
+    }, [dispatchApi]);
+    /**
+     * Update a hit in the context locally
+     */
+    const updateHit = useCallback((newHit) => {
+        hitRequests.current[newHit.howler.id] = Promise.resolve(newHit);
+        setHits(_hits => ({ ..._hits, [newHit.howler.id]: newHit }));
+    }, []);
+    /**
+     * Add a large number of hits to the cache. Used for results of searches.
+     */
+    const loadHits = useCallback((newHits) => {
+        const mappedHits = newHits.map(hit => [hit.howler.id, hit]);
+        mappedHits.forEach(([id, hit]) => {
+            hitRequests.current[id] = Promise.resolve(hit);
+        });
+        setHits(_hits => ({ ..._hits, ...Object.fromEntries(mappedHits) }));
+    }, []);
+    const addHitToSelection = useCallback((id) => {
+        setSelectedHitIds(_selected => uniq([..._selected, id]));
+    }, []);
+    const removeHitFromSelection = useCallback((id) => {
+        setSelectedHitIds(_selected => _selected.filter(_id => _id !== id));
+    }, []);
+    const clearSelectedHits = useCallback((except) => {
+        setSelectedHitIds(!!except ? [except] : []);
+    }, []);
+    const selectedHits = useMemo(() => selectedHitIds.map(id => hits[id]).filter(hit => !!hit), [hits, selectedHitIds]);
+    useEffect(() => {
+        selectedHitIds.forEach(id => {
+            if (!hitRequests.current[id]) {
+                getHit(id);
+            }
+        });
+    }, [getHit, selectedHitIds]);
+    useEffect(() => {
+        Object.entries(hits).forEach(([id, hit]) => {
+            hitRequests.current[id] = Promise.resolve(hit);
+        });
+    }, [hits]);
+    return (_jsx(HitContext.Provider, { value: {
+            hits,
+            getHit,
+            updateHit,
+            selectedHits,
+            addHitToSelection,
+            removeHitFromSelection,
+            clearSelectedHits,
+            loadHits
+        }, children: children }));
+};
+export const useHitContextSelector = (selector) => {
+    return useContextSelector(HitContext, selector);
+};
+export default HitProvider;

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

@@ -0,0 +1,27 @@
+import type { HowlerSearchResponse } from '@cccsaurora/howler-ui/api/search';
+import { HitLayout } from '@cccsaurora/howler-ui/components/elements/hit/HitLayout';
+import type { Hit } from '@cccsaurora/howler-ui/models/entities/generated/Hit';
+import type { WithMetadata } from '@cccsaurora/howler-ui/models/WithMetadata';
+import { type Dispatch, type FC, type PropsWithChildren, type SetStateAction } from 'react';
+export interface QueryEntry {
+    [query: string]: string;
+}
+interface HitSearchProviderType {
+    layout: HitLayout;
+    displayType: 'list' | 'grid';
+    searching: boolean;
+    error: string | null;
+    response: HowlerSearchResponse<WithMetadata<Hit>> | null;
+    viewId: string | null;
+    bundleId: string | null;
+    queryHistory: QueryEntry;
+    fzfSearch: boolean;
+    setDisplayType: (type: 'list' | 'grid') => void;
+    setQueryHistory: Dispatch<SetStateAction<QueryEntry>>;
+    setFzfSearch: Dispatch<SetStateAction<boolean>>;
+    search: (query: string, appendResults?: boolean) => void;
+}
+export declare const HitSearchContext: import("use-context-selector").Context<HitSearchProviderType>;
+declare const HitSearchProvider: FC<PropsWithChildren>;
+export declare const useHitSearchContextSelector: <Selected>(selector: (value: HitSearchProviderType) => Selected) => Selected;
+export default HitSearchProvider;

package/components/app/providers/HitSearchProvider.js

@@ -0,0 +1,169 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import api from '@cccsaurora/howler-ui/api';
+import { HitLayout } from '@cccsaurora/howler-ui/components/elements/hit/HitLayout';
+import useMyApi from '@cccsaurora/howler-ui/components/hooks/useMyApi';
+import useMyLocalStorage, { useMyLocalStorageItem } from '@cccsaurora/howler-ui/components/hooks/useMyLocalStorage';
+import i18n from '@cccsaurora/howler-ui/i18n';
+import isNull from 'lodash-es/isNull';
+import isUndefined from 'lodash-es/isUndefined';
+import { useCallback, useEffect, useMemo, useState } from 'react';
+import { isMobile } from 'react-device-detect';
+import { useLocation, useParams } from 'react-router-dom';
+import { createContext, useContextSelector } from 'use-context-selector';
+import { StorageKey } from '@cccsaurora/howler-ui/utils/constants';
+import { getStored } from '@cccsaurora/howler-ui/utils/localStorage';
+import Throttler from '@cccsaurora/howler-ui/utils/Throttler';
+import { convertCustomDateRangeToLucene, convertDateToLucene } from '@cccsaurora/howler-ui/utils/utils';
+import { HitContext } from './HitProvider';
+import { ParameterContext } from './ParameterProvider';
+import { ViewContext } from './ViewProvider';
+export const HitSearchContext = createContext(null);
+const THROTTLER = new Throttler(500);
+const HitSearchProvider = ({ children }) => {
+    const { get } = useMyLocalStorage();
+    const routeParams = useParams();
+    const location = useLocation();
+    const { dispatchApi } = useMyApi();
+    const pageCount = useMyLocalStorageItem(StorageKey.PAGE_COUNT, 25)[0];
+    const getCurrentView = useContextSelector(ViewContext, ctx => ctx.getCurrentView);
+    const defaultView = useContextSelector(ViewContext, ctx => ctx.defaultView);
+    const query = useContextSelector(ParameterContext, ctx => ctx.query);
+    const setQuery = useContextSelector(ParameterContext, ctx => ctx.setQuery);
+    const offset = useContextSelector(ParameterContext, ctx => ctx.offset);
+    const setOffset = useContextSelector(ParameterContext, ctx => ctx.setOffset);
+    const trackTotalHits = useContextSelector(ParameterContext, ctx => ctx.trackTotalHits);
+    const sort = useContextSelector(ParameterContext, ctx => ctx.sort);
+    const span = useContextSelector(ParameterContext, ctx => ctx.span);
+    const filter = useContextSelector(ParameterContext, ctx => ctx.filter);
+    const startDate = useContextSelector(ParameterContext, ctx => ctx.startDate);
+    const endDate = useContextSelector(ParameterContext, ctx => ctx.endDate);
+    const loadHits = useContextSelector(HitContext, ctx => ctx.loadHits);
+    const [displayType, setDisplayType] = useState(getStored(StorageKey.DISPLAY_TYPE) ?? 'list');
+    const [searching, setSearching] = useState(false);
+    const [error, setError] = useState(null);
+    const [response, setResponse] = useState();
+    const [queryHistory, setQueryHistory] = useState(JSON.parse(get(StorageKey.QUERY_HISTORY)) || { 'howler.id: *': new Date().toISOString() });
+    const [fzfSearch, setFzfSearch] = useState(false);
+    const viewId = useMemo(() => (location.pathname.startsWith('/views') ? routeParams.id : defaultView) ?? null, [defaultView, location.pathname, routeParams.id]);
+    const bundleId = useMemo(() => (location.pathname.startsWith('/bundles') ? routeParams.id : null), [location.pathname, routeParams.id]);
+    const layout = useMemo(() => (isMobile ? HitLayout.COMFY : (get(StorageKey.HIT_LAYOUT) ?? HitLayout.NORMAL)), [get]);
+    const search = useCallback(async (_query, appendResults) => {
+        THROTTLER.debounce(async () => {
+            if (_query === 'woof!') {
+                i18n.changeLanguage('woof');
+                return;
+            }
+            if (isNull(sort) || isNull(span)) {
+                return;
+            }
+            if (!isNull(_query) && !isUndefined(_query) && _query !== query) {
+                setQuery(_query);
+            }
+            setSearching(true);
+            setError(null);
+            const filters = [];
+            if (span && !span.endsWith('custom')) {
+                filters.push(`event.created:${convertDateToLucene(span)}`);
+            }
+            else if (startDate && endDate) {
+                filters.push(`event.created:${convertCustomDateRangeToLucene(startDate, endDate)}`);
+            }
+            if (filter) {
+                filters.push(filter);
+            }
+            try {
+                const bundle = location.pathname.startsWith('/bundles') && routeParams.id;
+                let fullQuery = _query || 'howler.id:*';
+                if (bundle) {
+                    fullQuery = `(howler.bundles:${bundle}) AND (${fullQuery})`;
+                }
+                else if (viewId) {
+                    fullQuery = `(${(await getCurrentView({ viewId }))?.query || 'howler.id:*'}) AND (${fullQuery})`;
+                }
+                const _response = await dispatchApi(api.search.hit.post({
+                    offset: appendResults ? response.rows : offset,
+                    rows: pageCount,
+                    query: fullQuery,
+                    sort,
+                    filters,
+                    track_total_hits: trackTotalHits,
+                    metadata: ['template', 'overview', 'analytic']
+                }), { showError: false, throwError: true });
+                if (_response.total < offset) {
+                    setOffset(0);
+                }
+                loadHits(_response.items);
+                if (!appendResults) {
+                    setResponse(_response);
+                }
+                else {
+                    setResponse(_existingResponse => ({
+                        ..._response,
+                        offset: _existingResponse.offset,
+                        rows: Math.min(_existingResponse.rows + _response.rows, _response.total),
+                        items: [..._existingResponse.items, ..._response.items]
+                    }));
+                }
+            }
+            catch (e) {
+                setError(e.message);
+            }
+            finally {
+                setSearching(false);
+            }
+        });
+    }, 
+    // We skip reloading when the response changes
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [
+        sort,
+        span,
+        query,
+        startDate,
+        endDate,
+        filter,
+        setQuery,
+        location.pathname,
+        routeParams.id,
+        viewId,
+        dispatchApi,
+        offset,
+        pageCount,
+        trackTotalHits,
+        loadHits,
+        getCurrentView,
+        setOffset
+    ]);
+    // We only run this when ancillary properties (i.e. filters, sorting) change
+    useEffect(() => {
+        if (span.endsWith('custom') && (!startDate || !endDate)) {
+            return;
+        }
+        if (viewId || bundleId || (query && query !== 'howler.id:*') || offset > 0) {
+            search(query);
+        }
+        else {
+            setResponse(null);
+        }
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, [filter, offset, pageCount, sort, span, bundleId, location.pathname, startDate, endDate, viewId]);
+    return (_jsx(HitSearchContext.Provider, { value: {
+            layout,
+            displayType,
+            setDisplayType,
+            search,
+            searching,
+            error,
+            response,
+            viewId,
+            bundleId,
+            setQueryHistory,
+            queryHistory,
+            fzfSearch,
+            setFzfSearch
+        }, children: children }));
+};
+export const useHitSearchContextSelector = (selector) => {
+    return useContextSelector(HitSearchContext, selector);
+};
+export default HitSearchProvider;

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

@@ -0,0 +1,13 @@
+import type { FC, PropsWithChildren } from 'react';
+import { StorageKey } from '@cccsaurora/howler-ui/utils/constants';
+type ValuesType = {
+    [K in StorageKey]?: any;
+};
+export interface LocalStorageContextType {
+    set: <T>(key: string, value: T) => void;
+    values: ValuesType;
+    remove: (key: string) => void;
+}
+export declare const LocalStorageContext: import("react").Context<LocalStorageContextType>;
+declare const LocalStorageProvider: FC<PropsWithChildren>;
+export default LocalStorageProvider;

package/components/app/providers/LocalStorageProvider.js

@@ -0,0 +1,41 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import useLocalStorage from '@cccsaurora/howler-ui/commons/components/utils/hooks/useLocalStorage';
+import { createContext, useCallback, useEffect, useState } from 'react';
+import { MY_LOCAL_STORAGE_PREFIX, StorageKey } from '@cccsaurora/howler-ui/utils/constants';
+export const LocalStorageContext = createContext(null);
+const LocalStorageProvider = ({ children }) => {
+    const { get: getStored, set: setStored, remove: removeStored } = useLocalStorage(MY_LOCAL_STORAGE_PREFIX);
+    const [values, setValues] = useState({});
+    useEffect(() => {
+        const newData = {};
+        for (const key in StorageKey) {
+            if (!values[StorageKey[key]]) {
+                newData[StorageKey[key]] = getStored(StorageKey[key]);
+            }
+        }
+        setValues(current => {
+            return {
+                ...current,
+                ...newData
+            };
+        });
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, [getStored]);
+    const set = useCallback((key, value) => {
+        setStored(key, value);
+        setValues(current => ({
+            ...current,
+            [key]: value
+        }));
+    }, [setStored]);
+    const remove = useCallback((key) => {
+        removeStored(key);
+        setValues(current => {
+            const copy = { ...current };
+            delete copy[key];
+            return copy;
+        });
+    }, [removeStored]);
+    return _jsx(LocalStorageContext.Provider, { value: { values, set, remove }, children: children });
+};
+export default LocalStorageProvider;

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

@@ -0,0 +1,16 @@
+import type { FC, PropsWithChildren, ReactNode } from 'react';
+export interface ModalOptions {
+    disableClose?: boolean;
+    maxWidth?: string;
+    maxHeight?: string;
+}
+interface ModalContextType {
+    showModal: (children: ReactNode, options?: ModalOptions) => () => void;
+    content?: ReactNode;
+    setContent: (children: ReactNode) => void;
+    options?: ModalOptions;
+    close: () => void;
+}
+export declare const ModalContext: import("react").Context<ModalContextType>;
+declare const ModalProvider: FC<PropsWithChildren>;
+export default ModalProvider;

package/components/app/providers/ModalProvider.js

@@ -0,0 +1,28 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { createContext, useCallback, useEffect, useState } from 'react';
+const defaultOptions = {
+    disableClose: false
+};
+export const ModalContext = createContext(null);
+const ModalProvider = ({ children }) => {
+    const [content, setContent] = useState(null);
+    const [options, setOptions] = useState(defaultOptions);
+    useEffect(() => {
+        if (!content) {
+            setOptions(defaultOptions);
+        }
+    }, [content]);
+    const showModal = useCallback((_children, newOptions) => {
+        setContent(_children);
+        if (options) {
+            setOptions({
+                ...options,
+                ...newOptions
+            });
+        }
+        return () => setContent(null);
+    }, [options]);
+    const close = useCallback(() => setContent(null), []);
+    return (_jsx(ModalContext.Provider, { value: { showModal, content, setContent, options, close }, children: children }));
+};
+export default ModalProvider;

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

@@ -0,0 +1,13 @@
+import type { Hit } from '@cccsaurora/howler-ui/models/entities/generated/Hit';
+import type { Overview } from '@cccsaurora/howler-ui/models/entities/generated/Overview';
+import type { FC, PropsWithChildren } from 'react';
+interface OverviewContextType {
+    overviews: Overview[];
+    getOverviews: (force?: boolean) => Promise<Overview[]>;
+    getMatchingOverview: (h: Hit) => Overview;
+    refresh: () => void;
+    loaded: boolean;
+}
+export declare const OverviewContext: import("react").Context<OverviewContextType>;
+declare const OverviewProvider: FC<PropsWithChildren>;
+export default OverviewProvider;