@cccsaurora/howler-ui 2.19.0-dev.989 → 2.19.0

package/components/app/providers/GridColumnsProvider.js

@@ -0,0 +1,177 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useMyLocalStorageItem } from '@cccsaurora/howler-ui/components/hooks/useMyLocalStorage';
+import { createContext, useCallback, useEffect, useMemo, useRef, useState } from 'react';
+import { useParams } from 'react-router-dom';
+import { useContextSelector } from 'use-context-selector';
+import { StorageKey } from '@cccsaurora/howler-ui/utils/constants';
+import { parsePixelSizeStringToInt } from '@cccsaurora/howler-ui/utils/stringUtils';
+import { ParameterContext } from './ParameterProvider';
+import { RecordSearchContext } from './RecordSearchProvider';
+import { ViewContext } from './ViewProvider';
+export const GridColumnsContext = createContext(null);
+/**
+ * Manages which grid columns are active and how wide they are.
+ *
+ * **Priority order:**
+ * 1. Active views (fetched asynchronously) — columns and widths are derived from view settings.
+ * 2. Local storage — used as fallback when no views are active.
+ *
+ * Local storage is only written when there are no active views, keeping view-driven state
+ * isolated from the user's personal preferences.
+ *
+ * @param viewSource - Determines where view IDs are read from:
+ *   - `"params"` (default) — reads from `ParameterContext` (query-string driven).
+ *   - `"path"` — reads from the current route's `:id` param.
+ */
+const GridColumnsProvider = ({ children, viewSource = 'params' }) => {
+    const routeParams = useParams();
+    // Resolve view IDs from the appropriate source.
+    const parameterViewIds = useContextSelector(ParameterContext, ctx => ctx.views);
+    const pathViewIds = useMemo(() => (routeParams.id ? [routeParams.id] : []), [routeParams.id]);
+    const viewIds = viewSource === 'params' ? parameterViewIds : pathViewIds;
+    const getCurrentViews = useContextSelector(ViewContext, ctx => ctx.getCurrentViews);
+    const setDisplayType = useContextSelector(RecordSearchContext, ctx => ctx.setDisplayType);
+    // --- Local storage state (user's personal preferences) ---
+    const [localStorageColumns, setLocalStorageColumns] = useMyLocalStorageItem(StorageKey.GRID_COLUMNS, [
+        'howler.outline.threat',
+        'howler.outline.target',
+        'howler.outline.indicators',
+        'howler.outline.summary'
+    ]);
+    const [localStorageColumnWidths, setLocalStorageColumnWidths] = useMyLocalStorageItem(StorageKey.GRID_COLUMN_WIDTHS, {});
+    // --- In-memory state (may be overridden by view data) ---
+    const [contextColumns, setContextColumns] = useState(localStorageColumns);
+    /** Non-null only when columns were loaded from views; null means fall back to local storage widths. */
+    const [viewColumnWidths, setViewColumnWidths] = useState(null);
+    /** Non-null only when columns were loaded from views; tracks which view(s) declared each column. */
+    const [viewColumnSources, setViewColumnSources] = useState(null);
+    const [isReady, setIsReady] = useState(false);
+    // Parse local storage widths into numbers for backwards compatibility with css style strings
+    const parsedLocalStorageColumnWidths = useMemo(() => {
+        const parsed = {};
+        for (const [col, width] of Object.entries(localStorageColumnWidths)) {
+            const numWidth = typeof width === 'string' ? parsePixelSizeStringToInt(width) : width;
+            if (numWidth !== null) {
+                parsed[col] = numWidth;
+            }
+        }
+        return parsed;
+    }, [localStorageColumnWidths]);
+    /**
+     * Tracks the current async load "cycle" to guard against stale async results.
+     * - `viewIds` is snapshotted at the start of each effect run; the callback checks
+     *   identity (`===`) before applying results to confirm it is still the current run.
+     * - `hasLocalEdits` is set to `true` the moment the user makes a manual change mid-flight,
+     *   which causes the pending async response to be discarded.
+     */
+    const currentLoadRef = useRef({ viewIds, hasLocalEdits: false });
+    const hasViews = viewIds?.length > 0;
+    // Fetch and apply view column settings whenever the set of active views changes.
+    useEffect(() => {
+        // Start a new load cycle.
+        currentLoadRef.current = { viewIds, hasLocalEdits: false };
+        if (!hasViews) {
+            // No views active — fall back to local storage immediately.
+            setContextColumns(localStorageColumns);
+            setViewColumnWidths(null);
+            setViewColumnSources(null);
+            setIsReady(true);
+            return;
+        }
+        setIsReady(false);
+        void getCurrentViews({ views: viewIds }).then(_views => {
+            // Discard stale results: either the user already made a manual edit, or viewIds changed.
+            if (currentLoadRef.current.hasLocalEdits) {
+                setIsReady(true);
+                return;
+            }
+            if (currentLoadRef.current.viewIds !== viewIds) {
+                return;
+            }
+            const views = _views.filter(Boolean);
+            if (!views.length) {
+                // Views resolved to nothing (e.g. all deleted) — fall back to local storage.
+                setContextColumns(localStorageColumns);
+                setViewColumnWidths(null);
+                setViewColumnSources(null);
+                setIsReady(true);
+                return;
+            }
+            // Honour the display-type declared by the highest-priority view.
+            if (views[0].settings?.display === 'list') {
+                setDisplayType('list');
+            }
+            else if (views[0].settings?.display === 'grid') {
+                setDisplayType('grid');
+                // Sort grid views by their position in the requested viewIds array so that
+                // the first-listed view has the highest precedence for column order and width.
+                const idRankMap = new Map(viewIds.map((id, i) => [id, i]));
+                const gridViews = views
+                    .filter(v => v.settings?.display === 'grid')
+                    .sort((a, b) => (idRankMap.get(a.view_id) ?? Infinity) - (idRankMap.get(b.view_id) ?? Infinity));
+                const columns = [];
+                const widths = {};
+                const sources = {};
+                for (const view of gridViews) {
+                    for (const { field, width } of view.settings?.columns ?? []) {
+                        if (!sources[field]) {
+                            // First occurrence wins for column order and width.
+                            columns.push(field);
+                            widths[field] = width ?? undefined;
+                            sources[field] = [view.title];
+                        }
+                        else {
+                            // Subsequent views that also declare this field are recorded as additional sources.
+                            sources[field].push(view.title);
+                        }
+                    }
+                }
+                setContextColumns(columns);
+                setViewColumnWidths(widths);
+                setViewColumnSources(sources);
+            }
+            setIsReady(true);
+        });
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, [viewIds, hasViews, getCurrentViews, localStorageColumns, setDisplayType]);
+    const setColumns = useCallback((columns, syncLocal) => {
+        // Persist to local storage only when there are no active views (or when explicitly requested).
+        if (!hasViews || syncLocal) {
+            const newColumns = typeof columns === 'function' ? columns(contextColumns) : columns;
+            setLocalStorageColumns(newColumns);
+        }
+        // Flag that a user edit has occurred so any in-flight async fetch won't overwrite this change.
+        currentLoadRef.current.hasLocalEdits = true;
+        setContextColumns(columns);
+    }, [hasViews, contextColumns, setLocalStorageColumns]);
+    // When views are active, use their widths; otherwise fall back to local storage widths.
+    const columnWidths = useMemo(() => viewColumnWidths ?? parsedLocalStorageColumnWidths, [viewColumnWidths, parsedLocalStorageColumnWidths]);
+    const setColumnWidth = useCallback((column, width, syncLocal) => {
+        if (!hasViews || syncLocal) {
+            // No active views — persist directly to local storage.
+            setLocalStorageColumnWidths({ ...parsedLocalStorageColumnWidths, [column]: width });
+        }
+        else {
+            // Active views — update the in-memory view widths only, and flag a local edit.
+            currentLoadRef.current.hasLocalEdits = true;
+            setViewColumnWidths(prev => ({ ...prev, [column]: width }));
+        }
+    }, [hasViews, parsedLocalStorageColumnWidths, setLocalStorageColumnWidths]);
+    // Map each column to the view(s) that declared it, or an empty array for local-storage columns.
+    const columnSources = useMemo(() => Object.fromEntries(contextColumns.map(col => [col, viewColumnSources?.[col] ?? []])), [viewColumnSources, contextColumns]);
+    /** Flush the current in-memory state to local storage (used by the "save to storage" action). */
+    const syncToStorage = useCallback(() => {
+        setLocalStorageColumns(contextColumns);
+        setLocalStorageColumnWidths(columnWidths);
+    }, [contextColumns, columnWidths, setLocalStorageColumns, setLocalStorageColumnWidths]);
+    return (_jsx(GridColumnsContext.Provider, { value: {
+            columns: contextColumns,
+            setColumns,
+            columnWidths,
+            setColumnWidth,
+            columnSources,
+            syncToStorage,
+            isReady
+        }, children: children }));
+};
+export default GridColumnsProvider;

package/components/app/providers/GridColumnsProvider.test.js

@@ -0,0 +1,255 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { act, renderHook, waitFor } from '@testing-library/react';
+import { useContext } from 'react';
+import { setupContextSelectorMock, setupLocalStorageMock, setupReactRouterMock } from '@cccsaurora/howler-ui/tests/mocks';
+import { StorageKey } from '@cccsaurora/howler-ui/utils/constants';
+import GridColumnsProvider, { GridColumnsContext } from './GridColumnsProvider';
+import { ParameterContext } from './ParameterProvider';
+import { RecordSearchContext } from './RecordSearchProvider';
+import { ViewContext } from './ViewProvider';
+setupContextSelectorMock();
+setupReactRouterMock();
+const mockLocalStorage = setupLocalStorageMock();
+import { useParams } from 'react-router-dom';
+const mockParams = vi.mocked(useParams);
+const mockGetCurrentViews = vi.fn();
+const mockSetDisplayType = vi.fn();
+const mockViewsContext = {
+    getCurrentViews: mockGetCurrentViews
+};
+const mockRecordSearchContext = {
+    setDisplayType: mockSetDisplayType
+};
+const makeWrapper = (parameterViewIds = [], routeId) => {
+    mockParams.mockReturnValue({ id: routeId });
+    const parameterContextValue = {
+        views: parameterViewIds
+    };
+    const Wrapper = ({ children }) => (_jsx(ParameterContext.Provider, { value: parameterContextValue, children: _jsx(ViewContext.Provider, { value: mockViewsContext, children: _jsx(RecordSearchContext.Provider, { value: mockRecordSearchContext, children: _jsx(GridColumnsProvider, { viewSource: routeId ? 'path' : 'params', children: children }) }) }) }));
+    return Wrapper;
+};
+const _prefixStorageKey = (key) => `howler.ui.${key}`;
+describe('no views', () => {
+    beforeEach(() => {
+        mockLocalStorage.clear();
+        mockGetCurrentViews.mockClear();
+        mockSetDisplayType.mockClear();
+        mockGetCurrentViews.mockResolvedValue([]);
+        mockLocalStorage.setItem(_prefixStorageKey(StorageKey.GRID_COLUMNS), JSON.stringify(['col1', 'col2']));
+        mockLocalStorage.setItem(_prefixStorageKey(StorageKey.GRID_COLUMN_WIDTHS), JSON.stringify({ col1: '100px' }));
+    });
+    it('should get columns from local storage', () => {
+        const Wrapper = makeWrapper();
+        const hook = renderHook(() => useContext(GridColumnsContext), { wrapper: Wrapper });
+        expect(mockLocalStorage.getItem).toHaveBeenCalledWith(_prefixStorageKey(StorageKey.GRID_COLUMNS));
+        expect(hook.result.current.columns).toEqual(['col1', 'col2']);
+        expect(mockLocalStorage.getItem).toHaveBeenCalledWith(_prefixStorageKey(StorageKey.GRID_COLUMN_WIDTHS));
+        expect(hook.result.current.columnWidths).toEqual({ col1: 100 });
+        expect(mockSetDisplayType).not.toHaveBeenCalled();
+    });
+    it('should update columns in local storage', () => {
+        const Wrapper = makeWrapper();
+        const hook = renderHook(() => useContext(GridColumnsContext), { wrapper: Wrapper });
+        act(() => {
+            hook.result.current.setColumns(['col1', 'col3']);
+        });
+        expect(mockLocalStorage.setItem).toHaveBeenCalledWith(_prefixStorageKey(StorageKey.GRID_COLUMNS), JSON.stringify(['col1', 'col3']));
+        expect(hook.result.current.columns).toEqual(['col1', 'col3']);
+    });
+    it('should update column widths in local storage', () => {
+        const Wrapper = makeWrapper();
+        const hook = renderHook(() => useContext(GridColumnsContext), { wrapper: Wrapper });
+        act(() => {
+            hook.result.current.setColumnWidth('col1', 150);
+        });
+        expect(mockLocalStorage.setItem).toHaveBeenCalledWith(_prefixStorageKey(StorageKey.GRID_COLUMN_WIDTHS), JSON.stringify({ col1: 150 }));
+        expect(hook.result.current.columnWidths).toEqual({ col1: 150 });
+    });
+    it("should add a column width to local storage if it doesn't exist", () => {
+        const Wrapper = makeWrapper();
+        const hook = renderHook(() => useContext(GridColumnsContext), { wrapper: Wrapper });
+        act(() => {
+            hook.result.current.setColumnWidth('col2', 200);
+        });
+        expect(mockLocalStorage.setItem).toHaveBeenCalledWith(_prefixStorageKey(StorageKey.GRID_COLUMN_WIDTHS), JSON.stringify({ col1: 100, col2: 200 }));
+        expect(hook.result.current.columnWidths).toEqual({ col1: 100, col2: 200 });
+    });
+});
+describe('with views', () => {
+    const mockViews = new Map([
+        [
+            'view1',
+            {
+                view_id: 'view1',
+                settings: {
+                    display: 'grid',
+                    columns: [
+                        {
+                            field: 'viewCol1',
+                            width: 101
+                        },
+                        {
+                            field: 'viewCol2',
+                            width: 102
+                        },
+                        {
+                            field: 'viewCol3'
+                        }
+                    ]
+                }
+            }
+        ],
+        [
+            'view2',
+            {
+                view_id: 'view2',
+                settings: {
+                    display: 'grid',
+                    columns: [
+                        {
+                            field: 'viewCol3',
+                            width: 103
+                        },
+                        {
+                            field: 'viewCol4',
+                            width: 204
+                        },
+                        {
+                            field: 'viewCol2',
+                            width: 202
+                        }
+                    ]
+                }
+            }
+        ],
+        [
+            'view3',
+            {
+                view_id: 'view3',
+                settings: {
+                    display: 'grid',
+                    columns: [
+                        {
+                            field: 'viewCol5',
+                            width: 300
+                        },
+                        {
+                            field: 'viewCol6',
+                            width: 301
+                        }
+                    ]
+                }
+            }
+        ],
+        ['listView', { view_id: 'listView', settings: { display: 'list' } }]
+    ]);
+    const getDelayedCurrentViews = (timeout) => {
+        return ({ views }) => new Promise(resolve => setTimeout(() => resolve(views ? views.map((viewId) => mockViews.get(viewId)) : Array.from(mockViews.values())), timeout));
+    };
+    const localStorageColumns = JSON.stringify(['localCol1', 'localCol2']);
+    const localStorageColumnWidths = JSON.stringify({ localCol1: '100px' });
+    beforeEach(() => {
+        mockLocalStorage.clear();
+        mockGetCurrentViews.mockClear();
+        mockSetDisplayType.mockClear();
+        mockGetCurrentViews.mockImplementation(({ views }) => Promise.resolve(views ? views.map((viewId) => mockViews.get(viewId)) : Array.from(mockViews.values())));
+        mockLocalStorage.setItem(_prefixStorageKey(StorageKey.GRID_COLUMNS), localStorageColumns);
+        mockLocalStorage.setItem(_prefixStorageKey(StorageKey.GRID_COLUMN_WIDTHS), localStorageColumnWidths);
+    });
+    it('should get columns from parameters', async () => {
+        const Wrapper = makeWrapper(['view1', 'view2']);
+        const hook = renderHook(() => useContext(GridColumnsContext), { wrapper: Wrapper });
+        expect(mockGetCurrentViews).toHaveBeenCalledWith({ views: ['view1', 'view2'] });
+        await waitFor(() => expect(hook.result.current.isReady).toBe(true));
+        expect(hook.result.current.columns).toEqual(['viewCol1', 'viewCol2', 'viewCol3', 'viewCol4']);
+        expect(hook.result.current.columnWidths).toEqual({
+            viewCol1: 101,
+            viewCol2: 102,
+            viewCol4: 204
+        });
+        expect(mockSetDisplayType).toHaveBeenCalledWith('grid');
+        expect(mockLocalStorage.getItem(_prefixStorageKey(StorageKey.GRID_COLUMNS))).toEqual(localStorageColumns);
+        expect(mockLocalStorage.getItem(_prefixStorageKey(StorageKey.GRID_COLUMN_WIDTHS))).toEqual(localStorageColumnWidths);
+    });
+    it('should get columns from path', async () => {
+        const Wrapper = makeWrapper(['view1', 'view2'], 'view3');
+        const hook = renderHook(() => useContext(GridColumnsContext), { wrapper: Wrapper });
+        expect(mockGetCurrentViews).toHaveBeenCalledWith({ views: ['view3'] });
+        await waitFor(() => expect(hook.result.current.isReady).toBe(true));
+        expect(hook.result.current.columns).toEqual(['viewCol5', 'viewCol6']);
+        expect(hook.result.current.columnWidths).toEqual({ viewCol5: 300, viewCol6: 301 });
+        expect(mockSetDisplayType).toHaveBeenCalledWith('grid');
+        expect(mockLocalStorage.getItem(_prefixStorageKey(StorageKey.GRID_COLUMNS))).toEqual(localStorageColumns);
+        expect(mockLocalStorage.getItem(_prefixStorageKey(StorageKey.GRID_COLUMN_WIDTHS))).toEqual(localStorageColumnWidths);
+    });
+    it('should update columns in context', async () => {
+        const Wrapper = makeWrapper(['view1']);
+        const hook = renderHook(() => useContext(GridColumnsContext), { wrapper: Wrapper });
+        await waitFor(() => expect(hook.result.current.isReady).toBe(true));
+        await act(async () => {
+            hook.result.current.setColumns(['newCol1', 'newCol2']);
+        });
+        expect(hook.result.current.columns).toEqual(['newCol1', 'newCol2']);
+        expect(mockLocalStorage.getItem(_prefixStorageKey(StorageKey.GRID_COLUMNS))).toEqual(localStorageColumns);
+        expect(mockLocalStorage.getItem(_prefixStorageKey(StorageKey.GRID_COLUMN_WIDTHS))).toEqual(localStorageColumnWidths);
+    });
+    it('should update column widths in context', async () => {
+        const Wrapper = makeWrapper(['view1']);
+        const hook = renderHook(() => useContext(GridColumnsContext), { wrapper: Wrapper });
+        await waitFor(() => expect(hook.result.current.isReady).toBe(true));
+        await act(async () => {
+            hook.result.current.setColumnWidth('viewCol1', 150);
+        });
+        expect(hook.result.current.columnWidths).toEqual({
+            viewCol1: 150,
+            viewCol2: 102
+        });
+        expect(mockLocalStorage.getItem(_prefixStorageKey(StorageKey.GRID_COLUMNS))).toEqual(localStorageColumns);
+        expect(mockLocalStorage.getItem(_prefixStorageKey(StorageKey.GRID_COLUMN_WIDTHS))).toEqual(localStorageColumnWidths);
+    });
+    it("should add a column width to context if it doesn't exist", async () => {
+        const Wrapper = makeWrapper(['view1']);
+        const hook = renderHook(() => useContext(GridColumnsContext), { wrapper: Wrapper });
+        await waitFor(() => expect(hook.result.current.isReady).toBe(true));
+        await act(async () => {
+            hook.result.current.setColumnWidth('viewCol3', 150);
+        });
+        expect(hook.result.current.columnWidths).toEqual({
+            viewCol1: 101,
+            viewCol2: 102,
+            viewCol3: 150
+        });
+        expect(mockLocalStorage.getItem(_prefixStorageKey(StorageKey.GRID_COLUMNS))).toEqual(localStorageColumns);
+        expect(mockLocalStorage.getItem(_prefixStorageKey(StorageKey.GRID_COLUMN_WIDTHS))).toEqual(localStorageColumnWidths);
+    });
+    it('should not update context if views change but local edits have been made', async () => {
+        // force race condition
+        mockGetCurrentViews.mockImplementationOnce(getDelayedCurrentViews(100));
+        const Wrapper = makeWrapper(['view1']);
+        const hook = renderHook(() => useContext(GridColumnsContext), { wrapper: Wrapper });
+        await act(async () => {
+            hook.result.current.setColumns(['newCol1', 'newCol2']);
+        });
+        // dirty takes precedence
+        expect(hook.result.current.columns).toEqual(['newCol1', 'newCol2']);
+    });
+    it('should not update context if async view load returns for an outdated view set', async () => {
+        // force race condition
+        mockGetCurrentViews.mockImplementationOnce(getDelayedCurrentViews(100));
+        const hook = renderHook(() => useContext(GridColumnsContext), { wrapper: makeWrapper([], 'view1') });
+        mockParams.mockReturnValue({ id: 'view2' });
+        hook.rerender();
+        await waitFor(() => expect(hook.result.current.isReady).toBe(true));
+        // most recent request takes precedence
+        expect(hook.result.current.columns).toEqual(['viewCol3', 'viewCol4', 'viewCol2']);
+    });
+    it('should keep isReady false until all async view loads are complete', async () => {
+        mockGetCurrentViews.mockImplementation(getDelayedCurrentViews(100));
+        const hook = renderHook(() => useContext(GridColumnsContext), { wrapper: makeWrapper([], 'view1') });
+        mockGetCurrentViews.mockImplementation(getDelayedCurrentViews(200));
+        mockParams.mockReturnValue({ id: 'view2' });
+        hook.rerender();
+        await waitFor(() => expect(hook.result.current.isReady).toBe(true));
+        expect(hook.result.current.columns).toEqual(['viewCol3', 'viewCol4', 'viewCol2']);
+    });
+});

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/OverviewProvider.js

@@ -45,7 +45,7 @@ const OverviewProvider = ({ children }) => {
         })[0], [overviews]);
     const refresh = useCallback(() => {
         setLoaded(false);
-        getOverviews();
+        void getOverviews();
         // eslint-disable-next-line react-hooks/exhaustive-deps
     }, []);
     return (_jsx(OverviewContext.Provider, { value: {

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

@@ -1,3 +1,4 @@
+import type { SearchIndex } from '@cccsaurora/howler-ui/api/v2/search';
 import type { FC, PropsWithChildren } from 'react';
 export interface ParameterContextType {
     selected?: string;
@@ -6,6 +7,7 @@ export interface ParameterContextType {
     trackTotalHits: boolean;
     sort?: string;
     span?: string;
+    indexes?: SearchIndex[];
     filters?: string[];
     startDate?: string;
     endDate?: string;
@@ -19,16 +21,36 @@ 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;
+}
+interface SearchValues {
+    selected: string;
+    query: string;
+    sort: string;
+    span: string;
+    indexes: SearchIndex[];
+    filters: string[];
+    views: string[];
+    startDate: string;
+    endDate: string;
+    offset: number;
+    trackTotalHits: boolean;
 }
 export declare const ParameterContext: import("use-context-selector").Context<ParameterContextType>;
 /**
  * Context responsible for tracking updates to query operations in hit and view search.
  */
-declare const ParameterProvider: FC<PropsWithChildren>;
+declare const ParameterProvider: FC<PropsWithChildren<{
+    defaults?: Partial<SearchValues>;
+}>>;
 export declare const useParameterContextSelector: <Selected>(selector: (value: ParameterContextType) => Selected) => Selected;
 export default ParameterProvider;