@cccsaurora/howler-ui 2.19.0-dev.1099 → 2.19.0-dev.1148

package/components/app/App.js

@@ -74,7 +74,9 @@ import AvatarProvider from './providers/AvatarProvider';
 import CustomPluginProvider from './providers/CustomPluginProvider';
 import FavouriteProvider from './providers/FavouritesProvider';
 import FieldProvider from './providers/FieldProvider';
+import GridColumnsProvider from './providers/GridColumnsProvider';
 import HitProvider from './providers/HitProvider';
+import HitSearchProvider from './providers/HitSearchProvider';
 import LocalStorageProvider from './providers/LocalStorageProvider';
 import ModalProvider from './providers/ModalProvider';
 import OverviewProvider from './providers/OverviewProvider';
@@ -232,7 +234,7 @@ const createRouter = () => createBrowserRouter([
             },
             {
                 path: 'views/create',
-                element: (_jsx(ParameterProvider, { children: _jsx(ViewComposer, {}) }))
+                element: (_jsx(ParameterProvider, { children: _jsx(HitSearchProvider, { children: _jsx(GridColumnsProvider, { viewSource: "path", children: _jsx(ViewComposer, {}) }) }) }))
             },
             {
                 path: 'views/:id',
@@ -240,7 +242,7 @@ const createRouter = () => createBrowserRouter([
             },
             {
                 path: 'views/:id/edit',
-                element: (_jsx(ParameterProvider, { children: _jsx(ViewComposer, {}) }))
+                element: (_jsx(ParameterProvider, { children: _jsx(HitSearchProvider, { children: _jsx(GridColumnsProvider, { viewSource: "path", children: _jsx(ViewComposer, {}) }) }) }))
             },
             {
                 path: 'admin/users',

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

@@ -0,0 +1,52 @@
+import { type PropsWithChildren, type SetStateAction } from 'react';
+/**
+ * Shape of the context value exposed by {@link GridColumnsProvider}.
+ *
+ * Column state is sourced from active views when present, otherwise from local storage.
+ * Mutations follow the same rule: they write back to local storage only when there are no
+ * active views (or when `syncLocal` is explicitly set to `true`).
+ */
+export type GridColumnsContextType = {
+    /** Ordered list of field keys to display as grid columns. */
+    columns: string[];
+    /**
+     * Replace or update the active column list.
+     * @param syncLocal - When `true`, also persists the change to local storage even if views are active.
+     */
+    setColumns: (columns: SetStateAction<string[]>, syncLocal?: boolean) => void;
+    /** Per-column widths (pixels, e.g. `120`), keyed by field name. */
+    columnWidths: Record<string, number>;
+    /**
+     * Set the width of a single column.
+     * @param syncLocal - When `true`, also persists the change to local storage even if views are active.
+     */
+    setColumnWidth: (column: string, width: number, syncLocal?: boolean) => void;
+    /**
+     * Maps each column field to the list of view titles that declared it.
+     * Empty array for columns that came from local storage rather than a view.
+     */
+    columnSources: Record<string, string[]>;
+    /** Persist the current in-memory column configuration (columns + widths) to local storage. */
+    syncToStorage: () => void;
+    /** `false` while an async view fetch is in flight; `true` once the column state is settled. */
+    isReady: boolean;
+};
+export declare const GridColumnsContext: import("react").Context<GridColumnsContextType>;
+/**
+ * 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.
+ */
+declare const GridColumnsProvider: ({ children, viewSource }: PropsWithChildren<{
+    viewSource?: "params" | "path";
+}>) => import("react/jsx-runtime").JSX.Element;
+export default GridColumnsProvider;

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 { HitSearchContext } from './HitSearchProvider';
+import { ParameterContext } from './ParameterProvider';
+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(HitSearchContext, 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);
+        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 { HitSearchContext } from './HitSearchProvider';
+import { ParameterContext } from './ParameterProvider';
+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 mockHitSearchContext = {
+    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(HitSearchContext.Provider, { value: mockHitSearchContext, 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/elements/addons/buttons/CustomIconButton.test.d.ts

@@ -0,0 +1 @@
+export {};

package/components/elements/addons/buttons/CustomIconButton.test.js

@@ -0,0 +1,81 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+/// <reference types="vitest" />
+import { render, screen } from '@testing-library/react';
+import { setupReactRouterMock } from '@cccsaurora/howler-ui/tests/mocks';
+import { vi } from 'vitest';
+setupReactRouterMock();
+import CustomIconButton from './CustomIconButton';
+describe('CustomIconButton', () => {
+    afterAll(() => vi.resetModules());
+    describe('rendering', () => {
+        it('renders a button element', () => {
+            render(_jsx(CustomIconButton, { "aria-label": "test", children: "icon" }));
+            expect(screen.getByRole('button', { name: 'test' })).toBeInTheDocument();
+        });
+        it('renders children inside the button', () => {
+            render(_jsx(CustomIconButton, { children: "\u2605" }));
+            expect(screen.getByText('★')).toBeInTheDocument();
+        });
+        it('renders with MUI IconButton classes', () => {
+            render(_jsx(CustomIconButton, { children: "i" }));
+            expect(screen.getByRole('button')).toHaveClass('MuiIconButton-root');
+        });
+    });
+    describe('disabled state', () => {
+        it('is disabled when disabled prop is true', () => {
+            render(_jsx(CustomIconButton, { disabled: true, children: "icon" }));
+            expect(screen.getByRole('button')).toBeDisabled();
+        });
+        it('is disabled when progress is truthy', () => {
+            render(_jsx(CustomIconButton, { progress: true, children: "icon" }));
+            expect(screen.getByRole('button')).toBeDisabled();
+        });
+        it('is NOT disabled when progress is set but clickableWithProgress=true', () => {
+            render(_jsx(CustomIconButton, { progress: true, clickableWithProgress: true, children: "icon" }));
+            expect(screen.getByRole('button')).not.toBeDisabled();
+        });
+    });
+    describe('progress indicator', () => {
+        it('renders a CircularProgress when progress is truthy', () => {
+            render(_jsx(CustomIconButton, { progress: true, children: "icon" }));
+            // CircularProgress renders an svg with role="progressbar"
+            expect(document.querySelector('circle')).toBeInTheDocument();
+        });
+        it('does not render CircularProgress when progress is falsy', () => {
+            render(_jsx(CustomIconButton, { children: "icon" }));
+            expect(document.querySelector('[role="progressbar"]')).not.toBeInTheDocument();
+        });
+    });
+    describe('tooltip', () => {
+        it('wraps the button in a Tooltip when tooltip prop is provided', () => {
+            render(_jsx(CustomIconButton, { tooltip: "Save", children: "icon" }));
+            // The button is wrapped in a <span> when a Tooltip is used
+            const span = screen.getByRole('button').closest('span');
+            expect(span).toBeInTheDocument();
+        });
+        it('does not add a surrounding span when no tooltip is given', () => {
+            render(_jsx(CustomIconButton, { children: "icon" }));
+            const button = screen.getByRole('button');
+            // Without tooltip the immediate parent should NOT be a span wrapper
+            expect(button.parentElement?.tagName).not.toBe('SPAN');
+        });
+    });
+    describe('route link', () => {
+        it('wraps the button in a Link when route prop is provided', () => {
+            render(_jsx(CustomIconButton, { route: "/hits", children: "icon" }));
+            expect(screen.getByRole('link')).toBeInTheDocument();
+        });
+        it('does not render a link when no route is given', () => {
+            render(_jsx(CustomIconButton, { children: "icon" }));
+            expect(screen.queryByRole('link')).not.toBeInTheDocument();
+        });
+    });
+    describe('href link', () => {
+        it('wraps the button in an anchor tag when href is provided', () => {
+            render(_jsx(CustomIconButton, { href: "https://example.com", children: "icon" }));
+            const anchor = screen.getByRole('link');
+            expect(anchor).toBeInTheDocument();
+            expect(anchor).toHaveAttribute('href', 'https://example.com');
+        });
+    });
+});

package/components/elements/addons/layout/FlexVertical.test.d.ts

@@ -0,0 +1 @@
+export {};

package/components/elements/addons/layout/FlexVertical.test.js

@@ -0,0 +1,32 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+/// <reference types="vitest" />
+import { render, screen } from '@testing-library/react';
+import { describe, expect, it } from 'vitest';
+import FlexVertical from './FlexVertical';
+describe('FlexVertical', () => {
+    it('renders a div with display:flex and flex-direction:column', () => {
+        const { container } = render(_jsx(FlexVertical, { children: _jsx("span", { children: "child" }) }));
+        const div = container.firstChild;
+        expect(div).toBeInTheDocument();
+        expect(div).toHaveStyle({ display: 'flex', flexDirection: 'column' });
+    });
+    it('renders children inside the flex container', () => {
+        render(_jsx(FlexVertical, { children: _jsx("span", { id: "inner", children: "hello" }) }));
+        expect(screen.getByTestId('inner')).toBeInTheDocument();
+    });
+    it('renders multiple children', () => {
+        render(_jsxs(FlexVertical, { children: [_jsx("span", { id: "a", children: "A" }), _jsx("span", { id: "b", children: "B" })] }));
+        expect(screen.getByTestId('a')).toBeInTheDocument();
+        expect(screen.getByTestId('b')).toBeInTheDocument();
+    });
+    it('applies the default flex value of 1', () => {
+        const { container } = render(_jsx(FlexVertical, { children: _jsx("span", { children: "child" }) }));
+        const div = container.firstChild;
+        expect(div).toHaveStyle({ flex: 1 });
+    });
+    it('applies a custom flex value when provided', () => {
+        const { container } = render(_jsx(FlexVertical, { flex: 2, children: _jsx("span", { children: "child" }) }));
+        const div = container.firstChild;
+        expect(div).toHaveStyle({ flex: 2 });
+    });
+});

package/components/elements/addons/layout/vsbox/VSBoxContent.test.d.ts

@@ -0,0 +1 @@
+export {};