@cccsaurora/howler-ui 2.19.0-dev.1181 → 2.19.0-dev.1264

package/components/routes/cases/modals/CreateCaseModal.test.js

@@ -0,0 +1,319 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+/// <reference types="vitest" />
+import { act, render, screen, waitFor } from '@testing-library/react';
+import userEvent, {} from '@testing-library/user-event';
+import { ApiConfigContext } from '@cccsaurora/howler-ui/components/app/providers/ApiConfigProvider';
+import { ModalContext } from '@cccsaurora/howler-ui/components/app/providers/ModalProvider';
+import i18n from '@cccsaurora/howler-ui/i18n';
+import { I18nextProvider } from 'react-i18next';
+import { createMockEvent, createMockHit } from '@cccsaurora/howler-ui/tests/utils';
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import CreateCaseModal from './CreateCaseModal';
+// ---------------------------------------------------------------------------
+// Hoisted mocks
+// ---------------------------------------------------------------------------
+const mockDispatchApi = vi.hoisted(() => vi.fn());
+const mockClose = vi.hoisted(() => vi.fn());
+vi.mock('components/hooks/useMyApi', () => ({
+    default: () => ({ dispatchApi: mockDispatchApi })
+}));
+vi.mock('components/elements/hit/elements/EscalationChip', () => ({
+    default: () => null
+}));
+let mockSetContent = null;
+vi.mock('components/elements/MarkdownEditor', () => ({
+    default: ({ content, setContent }) => {
+        mockSetContent = setContent;
+        return _jsx("textarea", { id: "markdown-editor", value: content, onChange: ev => setContent(ev.target.value) });
+    }
+}));
+vi.mock('api', () => ({
+    default: {
+        v2: {
+            case: {
+                post: vi.fn().mockReturnValue('case-post-request'),
+                items: {
+                    post: vi.fn().mockReturnValue('items-post-request')
+                }
+            }
+        }
+    }
+}));
+// ---------------------------------------------------------------------------
+// Fixtures
+// ---------------------------------------------------------------------------
+const MOCK_HIT_1 = createMockHit({
+    howler: { id: 'hit-001', analytic: 'AnalyticOne', status: 'open' }
+});
+const MOCK_HIT_2 = createMockHit({
+    howler: { id: 'hit-002', analytic: 'AnalyticTwo', status: 'open' }
+});
+const MOCK_EVENT = createMockEvent({
+    howler: { id: 'obs-001' }
+});
+const MOCK_CONFIG = {
+    lookups: {
+        'howler.escalation': ['normal', 'focus', 'crisis']
+    }
+};
+// ---------------------------------------------------------------------------
+// Wrapper
+// ---------------------------------------------------------------------------
+const Wrapper = ({ children }) => (_jsx(I18nextProvider, { i18n: i18n, children: _jsx(ApiConfigContext.Provider, { value: { config: MOCK_CONFIG, setConfig: vi.fn() }, children: _jsx(ModalContext.Provider, { value: { close: mockClose, open: vi.fn(), setContent: vi.fn() }, children: children }) }) }));
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+const renderModal = (records) => render(_jsx(CreateCaseModal, { records: records }), { wrapper: Wrapper });
+const fillCaseMetadata = async (user, { title = 'My Case', summary = 'A summary' } = {}) => {
+    await user.type(screen.getByPlaceholderText(i18n.t('modal.cases.create_case.title')), title);
+    await user.type(screen.getByPlaceholderText(i18n.t('modal.cases.create_case.summary')), summary);
+};
+// ---------------------------------------------------------------------------
+// Tests
+// ---------------------------------------------------------------------------
+describe('CreateCaseModal', () => {
+    let user;
+    beforeEach(() => {
+        user = userEvent.setup();
+        vi.clearAllMocks();
+        // Default: case creation returns a case, item post resolves
+        mockDispatchApi.mockResolvedValue({ case_id: 'new-case-id' });
+    });
+    // -------------------------------------------------------------------------
+    // Initial render
+    // -------------------------------------------------------------------------
+    describe('initial render', () => {
+        it('shows the modal title', () => {
+            renderModal([MOCK_HIT_1]);
+            expect(screen.getByText(i18n.t('modal.cases.create_case'))).toBeInTheDocument();
+        });
+        it('renders a cancel button', () => {
+            renderModal([MOCK_HIT_1]);
+            expect(screen.getByRole('button', { name: i18n.t('cancel') })).toBeInTheDocument();
+        });
+        it('renders a confirm button', () => {
+            renderModal([MOCK_HIT_1]);
+            expect(screen.getByRole('button', { name: i18n.t('confirm') })).toBeInTheDocument();
+        });
+        it('confirm button is disabled before required fields are filled', () => {
+            renderModal([MOCK_HIT_1]);
+            expect(screen.getByRole('button', { name: i18n.t('confirm') })).toBeDisabled();
+        });
+        it('renders case title, summary, and escalation inputs', () => {
+            renderModal([MOCK_HIT_1]);
+            expect(screen.getByPlaceholderText(i18n.t('modal.cases.create_case.title'))).toBeInTheDocument();
+            expect(screen.getByPlaceholderText(i18n.t('modal.cases.create_case.summary'))).toBeInTheDocument();
+            expect(screen.getByText(i18n.t('modal.cases.create_case.overview'))).toBeInTheDocument();
+        });
+    });
+    // -------------------------------------------------------------------------
+    // Per-record rows
+    // -------------------------------------------------------------------------
+    describe('per-record rows', () => {
+        it('renders a row for each record', () => {
+            renderModal([MOCK_HIT_1, MOCK_HIT_2]);
+            expect(screen.getByText(MOCK_HIT_1.howler.analytic)).toBeInTheDocument();
+            expect(screen.getByText(MOCK_HIT_2.howler.analytic)).toBeInTheDocument();
+        });
+        it('renders a row for an event record', () => {
+            renderModal([MOCK_EVENT]);
+            expect(screen.getByText('Event')).toBeInTheDocument();
+        });
+        it('pre-populates the title for a hit with analytic and id', () => {
+            renderModal([MOCK_HIT_1]);
+            const titleInputs = screen.getAllByPlaceholderText(i18n.t('modal.cases.add_to_case.name'));
+            expect(titleInputs[0]).toHaveValue(`${MOCK_HIT_1.howler.analytic} (${MOCK_HIT_1.howler.id})`);
+        });
+        it('pre-populates the title for an event with Event and id', () => {
+            renderModal([MOCK_EVENT]);
+            const titleInput = screen.getByPlaceholderText(i18n.t('modal.cases.add_to_case.name'));
+            expect(titleInput).toHaveValue(`Event (${MOCK_EVENT.howler.id})`);
+        });
+        it('shows the alert placement section label when there are records', () => {
+            renderModal([MOCK_HIT_1]);
+            expect(screen.getByText(i18n.t('modal.cases.create_case.items_section'))).toBeInTheDocument();
+        });
+        it('does not show the alert placement section when records is empty', () => {
+            renderModal([]);
+            expect(screen.queryByText(i18n.t('modal.cases.create_case.items_section'))).not.toBeInTheDocument();
+        });
+    });
+    // -------------------------------------------------------------------------
+    // Validation
+    // -------------------------------------------------------------------------
+    describe('validation', () => {
+        it('enables confirm after title and summary are filled', async () => {
+            renderModal([MOCK_HIT_1]);
+            await fillCaseMetadata(user);
+            expect(screen.getByRole('button', { name: i18n.t('confirm') })).toBeEnabled();
+        });
+        it('disables confirm when case title is empty', async () => {
+            renderModal([MOCK_HIT_1]);
+            await user.type(screen.getByPlaceholderText(i18n.t('modal.cases.create_case.summary')), 'A summary');
+            expect(screen.getByRole('button', { name: i18n.t('confirm') })).toBeDisabled();
+        });
+        it('disables confirm when summary is empty', async () => {
+            renderModal([MOCK_HIT_1]);
+            await user.type(screen.getByPlaceholderText(i18n.t('modal.cases.create_case.title')), 'My Case');
+            expect(screen.getByRole('button', { name: i18n.t('confirm') })).toBeDisabled();
+        });
+        it('disables confirm when any item title is cleared', async () => {
+            renderModal([MOCK_HIT_1]);
+            await fillCaseMetadata(user);
+            const titleInput = screen.getByPlaceholderText(i18n.t('modal.cases.add_to_case.name'));
+            await user.clear(titleInput);
+            expect(screen.getByRole('button', { name: i18n.t('confirm') })).toBeDisabled();
+        });
+        it('enables confirm without records (case-only creation)', async () => {
+            renderModal([]);
+            await fillCaseMetadata(user);
+            expect(screen.getByRole('button', { name: i18n.t('confirm') })).toBeEnabled();
+        });
+    });
+    // -------------------------------------------------------------------------
+    // Cancel
+    // -------------------------------------------------------------------------
+    describe('cancel button', () => {
+        it('calls close when cancel is clicked', async () => {
+            renderModal([MOCK_HIT_1]);
+            await user.click(screen.getByRole('button', { name: i18n.t('cancel') }));
+            expect(mockClose).toHaveBeenCalledTimes(1);
+        });
+    });
+    // -------------------------------------------------------------------------
+    // Submission
+    // -------------------------------------------------------------------------
+    describe('form submission', () => {
+        it('calls case.post with title, summary, and closes', async () => {
+            const api = (await import('api')).default;
+            mockDispatchApi.mockResolvedValue({ case_id: 'new-case-id' });
+            renderModal([MOCK_HIT_1]);
+            await fillCaseMetadata(user, { title: 'Test Case', summary: 'Test summary' });
+            await user.click(screen.getByRole('button', { name: i18n.t('confirm') }));
+            await waitFor(() => expect(mockClose).toHaveBeenCalled());
+            expect(api.v2.case.post).toHaveBeenCalledWith(expect.objectContaining({ title: 'Test Case', summary: 'Test summary' }));
+        });
+        it('includes overview in case.post when filled', async () => {
+            const api = (await import('api')).default;
+            mockDispatchApi.mockResolvedValue({ case_id: 'new-case-id' });
+            renderModal([]);
+            await fillCaseMetadata(user);
+            act(() => mockSetContent?.('## Overview\nSome detail'));
+            await user.click(screen.getByRole('button', { name: i18n.t('confirm') }));
+            await waitFor(() => expect(mockClose).toHaveBeenCalled());
+            expect(api.v2.case.post).toHaveBeenCalledWith(expect.objectContaining({ overview: '## Overview\nSome detail' }));
+        });
+        it('does not include overview when left blank', async () => {
+            const api = (await import('api')).default;
+            mockDispatchApi.mockResolvedValue({ case_id: 'new-case-id' });
+            renderModal([]);
+            await fillCaseMetadata(user);
+            await user.click(screen.getByRole('button', { name: i18n.t('confirm') }));
+            await waitFor(() => expect(mockClose).toHaveBeenCalled());
+            const callArg = vi.mocked(api.v2.case.post).mock.calls[0][0];
+            expect(callArg).not.toHaveProperty('overview');
+        });
+        it('includes escalation when selected', async () => {
+            const api = (await import('api')).default;
+            mockDispatchApi.mockResolvedValue({ case_id: 'new-case-id' });
+            renderModal([]);
+            await fillCaseMetadata(user);
+            const combobox = screen.getByRole('combobox');
+            await user.click(combobox);
+            const option = await screen.findByRole('option', { name: 'crisis' });
+            await user.click(option);
+            await user.click(screen.getByRole('button', { name: i18n.t('confirm') }));
+            await waitFor(() => expect(mockClose).toHaveBeenCalled());
+            expect(api.v2.case.post).toHaveBeenCalledWith(expect.objectContaining({ escalation: 'crisis' }));
+        });
+        it('calls items.post for each record after case creation', async () => {
+            const api = (await import('api')).default;
+            mockDispatchApi.mockResolvedValue({ case_id: 'new-case-id' });
+            renderModal([MOCK_HIT_1, MOCK_HIT_2]);
+            await fillCaseMetadata(user);
+            await user.click(screen.getByRole('button', { name: i18n.t('confirm') }));
+            await waitFor(() => expect(mockClose).toHaveBeenCalled());
+            // 1 case.post + 2 items.post
+            expect(mockDispatchApi).toHaveBeenCalledTimes(3);
+            expect(api.v2.case.items.post).toHaveBeenCalledTimes(2);
+        });
+        it('uses the default title as path for items', async () => {
+            const api = (await import('api')).default;
+            mockDispatchApi.mockResolvedValue({ case_id: 'new-case-id' });
+            renderModal([MOCK_HIT_1]);
+            await fillCaseMetadata(user);
+            await user.click(screen.getByRole('button', { name: i18n.t('confirm') }));
+            await waitFor(() => expect(mockClose).toHaveBeenCalled());
+            expect(api.v2.case.items.post).toHaveBeenCalledWith('new-case-id', expect.objectContaining({
+                name: `${MOCK_HIT_1.howler.analytic} (${MOCK_HIT_1.howler.id})`,
+                value: MOCK_HIT_1.howler.id,
+                type: 'hit',
+                parent: null
+            }));
+        });
+        it('uses a custom edited item title in the name', async () => {
+            const api = (await import('api')).default;
+            mockDispatchApi.mockResolvedValue({ case_id: 'new-case-id' });
+            renderModal([MOCK_HIT_1]);
+            await fillCaseMetadata(user);
+            const titleInput = screen.getByPlaceholderText(i18n.t('modal.cases.add_to_case.name'));
+            await user.clear(titleInput);
+            await user.type(titleInput, 'Custom Item Name');
+            await user.click(screen.getByRole('button', { name: i18n.t('confirm') }));
+            await waitFor(() => expect(mockClose).toHaveBeenCalled());
+            expect(api.v2.case.items.post).toHaveBeenCalledWith('new-case-id', expect.objectContaining({ name: 'Custom Item Name' }));
+        });
+        it('uses event __index for event records', async () => {
+            const api = (await import('api')).default;
+            mockDispatchApi.mockResolvedValue({ case_id: 'new-case-id' });
+            renderModal([MOCK_EVENT]);
+            await fillCaseMetadata(user);
+            await user.click(screen.getByRole('button', { name: i18n.t('confirm') }));
+            await waitFor(() => expect(mockClose).toHaveBeenCalled());
+            expect(api.v2.case.items.post).toHaveBeenCalledWith('new-case-id', expect.objectContaining({ type: 'event' }));
+        });
+        it('does not call items.post when there are no records', async () => {
+            const api = (await import('api')).default;
+            mockDispatchApi.mockResolvedValue({ case_id: 'new-case-id' });
+            renderModal([]);
+            await fillCaseMetadata(user);
+            await user.click(screen.getByRole('button', { name: i18n.t('confirm') }));
+            await waitFor(() => expect(mockClose).toHaveBeenCalled());
+            expect(api.v2.case.items.post).not.toHaveBeenCalled();
+        });
+        it('does not close if case creation returns no case_id', async () => {
+            mockDispatchApi.mockResolvedValue(null);
+            renderModal([]);
+            await fillCaseMetadata(user);
+            await user.click(screen.getByRole('button', { name: i18n.t('confirm') }));
+            await waitFor(() => expect(mockDispatchApi).toHaveBeenCalled());
+            expect(mockClose).not.toHaveBeenCalled();
+        });
+    });
+    // -------------------------------------------------------------------------
+    // Multiple records
+    // -------------------------------------------------------------------------
+    describe('multiple records', () => {
+        it('renders independent title inputs for each record', () => {
+            renderModal([MOCK_HIT_1, MOCK_HIT_2]);
+            const titleInputs = screen.getAllByPlaceholderText(i18n.t('modal.cases.add_to_case.name'));
+            expect(titleInputs).toHaveLength(2);
+            expect(titleInputs[0]).toHaveValue(`${MOCK_HIT_1.howler.analytic} (${MOCK_HIT_1.howler.id})`);
+            expect(titleInputs[1]).toHaveValue(`${MOCK_HIT_2.howler.analytic} (${MOCK_HIT_2.howler.id})`);
+        });
+        it('editing one record title does not affect the other', async () => {
+            renderModal([MOCK_HIT_1, MOCK_HIT_2]);
+            const titleInputs = screen.getAllByPlaceholderText(i18n.t('modal.cases.add_to_case.name'));
+            await user.clear(titleInputs[0]);
+            await user.type(titleInputs[0], 'Edited Title');
+            expect(titleInputs[0]).toHaveValue('Edited Title');
+            expect(titleInputs[1]).toHaveValue(`${MOCK_HIT_2.howler.analytic} (${MOCK_HIT_2.howler.id})`);
+        });
+        it('mixed hit and event records each get correct default titles', () => {
+            renderModal([MOCK_HIT_1, MOCK_EVENT]);
+            const titleInputs = screen.getAllByPlaceholderText(i18n.t('modal.cases.add_to_case.name'));
+            expect(titleInputs[0]).toHaveValue(`${MOCK_HIT_1.howler.analytic} (${MOCK_HIT_1.howler.id})`);
+            expect(titleInputs[1]).toHaveValue(`Event (${MOCK_EVENT.howler.id})`);
+        });
+    });
+});

package/components/routes/cases/modals/RenameItemModal.d.ts

@@ -0,0 +1,9 @@
+import type { Case } from '@cccsaurora/howler-ui/models/entities/generated/Case';
+import type { Item } from '@cccsaurora/howler-ui/models/entities/generated/Item';
+import { type FC } from 'react';
+declare const RenameItemModal: FC<{
+    _case: Case;
+    item: Item;
+    onRenamed?: (updatedCase: Case) => void;
+}>;
+export default RenameItemModal;

package/components/routes/cases/modals/RenameItemModal.js

@@ -0,0 +1,44 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Button, CircularProgress, Stack, TextField, Typography } from '@mui/material';
+import api from '@cccsaurora/howler-ui/api';
+import { ModalContext } from '@cccsaurora/howler-ui/components/app/providers/ModalProvider';
+import useMyApi from '@cccsaurora/howler-ui/components/hooks/useMyApi';
+import { useContext, useMemo, useState } from 'react';
+import { useTranslation } from 'react-i18next';
+const RenameItemModal = ({ _case, item, onRenamed }) => {
+    const { t } = useTranslation();
+    const { dispatchApi } = useMyApi();
+    const { close } = useContext(ModalContext);
+    const currentName = item.name ?? item.value ?? '';
+    const [name, setName] = useState(currentName);
+    const [submitting, setSubmitting] = useState(false);
+    const nameError = useMemo(() => {
+        if (!name.trim()) {
+            return t('modal.cases.rename_item.error.empty');
+        }
+        return null;
+    }, [name, t]);
+    const isValid = !nameError;
+    const onSubmit = async () => {
+        if (!isValid || !_case.case_id || !item.id) {
+            return;
+        }
+        setSubmitting(true);
+        try {
+            const updatedCase = await dispatchApi(api.v2.case.items.put(_case.case_id, item.id, { name: name.trim() }));
+            if (updatedCase) {
+                onRenamed?.(updatedCase);
+                close();
+            }
+        }
+        finally {
+            setSubmitting(false);
+        }
+    };
+    return (_jsxs(Stack, { spacing: 2, p: 2, sx: { minWidth: 'min(600px, 60vw)' }, children: [_jsx(Typography, { variant: "h4", children: t('modal.cases.rename_item') }), _jsx(TextField, { size: "small", label: t('modal.cases.rename_item.new_name'), value: name, onChange: ev => setName(ev.target.value), error: !!nameError, helperText: nameError ?? ' ', fullWidth: true, autoFocus: true, onKeyDown: ev => {
+                    if (ev.key === 'Enter' && isValid && !submitting) {
+                        onSubmit();
+                    }
+                } }), _jsxs(Stack, { direction: "row", justifyContent: "flex-end", spacing: 1, children: [_jsx(Button, { onClick: close, color: "error", variant: "outlined", disabled: submitting, children: t('button.cancel') }), _jsx(Button, { onClick: onSubmit, color: "success", variant: "outlined", disabled: !isValid || submitting, startIcon: submitting ? _jsx(CircularProgress, { size: 16, color: "inherit" }) : undefined, children: t('button.confirm') })] })] }));
+};
+export default RenameItemModal;

package/components/routes/cases/modals/ResolveModal.d.ts

@@ -0,0 +1,7 @@
+import type { Case } from '@cccsaurora/howler-ui/models/entities/generated/Case';
+import { type FC } from 'react';
+declare const ResolveModal: FC<{
+    case: Case;
+    onConfirm: () => void;
+}>;
+export default ResolveModal;

package/components/routes/cases/modals/ResolveModal.js

@@ -0,0 +1,120 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { KeyboardArrowDown, OpenInNew } from '@mui/icons-material';
+import { Accordion, AccordionDetails, AccordionSummary, Autocomplete, Box, Button, Checkbox, Chip, CircularProgress, Divider, IconButton, LinearProgress, Skeleton, Stack, TextField, Typography } from '@mui/material';
+import api from '@cccsaurora/howler-ui/api';
+import { ApiConfigContext } from '@cccsaurora/howler-ui/components/app/providers/ApiConfigProvider';
+import { ModalContext } from '@cccsaurora/howler-ui/components/app/providers/ModalProvider';
+import { RecordContext } from '@cccsaurora/howler-ui/components/app/providers/RecordProvider';
+import AnalyticLink from '@cccsaurora/howler-ui/components/elements/hit/elements/AnalyticLink';
+import EscalationChip from '@cccsaurora/howler-ui/components/elements/hit/elements/EscalationChip';
+import HitCard from '@cccsaurora/howler-ui/components/elements/hit/HitCard';
+import { HitLayout } from '@cccsaurora/howler-ui/components/elements/hit/HitLayout';
+import useHitActions from '@cccsaurora/howler-ui/components/hooks/useHitActions';
+import useMyApi from '@cccsaurora/howler-ui/components/hooks/useMyApi';
+import { isNil, uniq } from 'lodash-es';
+import { useCallback, useContext, useEffect, useMemo, useState } from 'react';
+import { useTranslation } from 'react-i18next';
+import { Link } from 'react-router-dom';
+import { useContextSelector } from 'use-context-selector';
+import useCase from '../hooks/useCase';
+const HitEntry = ({ hit, checked, onChange }) => {
+    if (!hit) {
+        return _jsx(Skeleton, { variant: "rounded", height: "40px", width: "100%" });
+    }
+    return (_jsxs(Accordion, { sx: { flexShrink: 0, px: 0, py: 0 }, children: [_jsx(AccordionSummary, { expandIcon: _jsx(KeyboardArrowDown, {}), sx: {
+                    px: 1,
+                    py: 0,
+                    minHeight: '48px !important',
+                    '& > *': {
+                        margin: '0 !important'
+                    }
+                }, children: _jsxs(Stack, { direction: "row", alignItems: "center", spacing: 1, pr: 1, width: "100%", children: [!isNil(checked) && (_jsx(Checkbox, { size: "small", checked: checked, onClick: e => {
+                                onChange?.();
+                                e.preventDefault();
+                                e.stopPropagation();
+                            } })), _jsx(AnalyticLink, { hit: hit, compressed: true, alignSelf: "center" }), _jsx(EscalationChip, { hit: hit, layout: HitLayout.DENSE }), _jsx(Chip, { sx: { width: 'fit-content', display: 'inline-flex' }, label: hit.howler.status, size: "small", color: "primary" }), _jsx("div", { style: { flex: 1 } }), _jsx(IconButton, { size: "small", component: Link, to: `/hits/${hit.howler.id}`, children: _jsx(OpenInNew, { fontSize: "small" }) })] }) }), _jsx(AccordionDetails, { children: _jsx(HitCard, { id: hit.howler.id, layout: HitLayout.NORMAL, elevation: 0 }) })] }, hit.howler.id));
+};
+const ResolveModal = ({ case: _case, onConfirm }) => {
+    const { t } = useTranslation();
+    const { dispatchApi } = useMyApi();
+    const { close } = useContext(ModalContext);
+    const { config } = useContext(ApiConfigContext);
+    const { update: updateCase } = useCase({ case: _case });
+    const [loading, setLoading] = useState(true);
+    const [rationale, setRationale] = useState('');
+    const [assessment, setAssessment] = useState(null);
+    const [allowUnresolvedHits, setAllowUnresolvedHits] = useState(false);
+    const [selectedHitIds, setSelectedHitIds] = useState(new Set());
+    const hitIds = useMemo(() => uniq((_case?.items ?? [])
+        .filter(item => item.type === 'hit')
+        .map(item => item.value)
+        .filter(Boolean)), [_case?.items]);
+    const loadRecords = useContextSelector(RecordContext, ctx => ctx.loadRecords);
+    const records = useContextSelector(RecordContext, ctx => ctx.records);
+    const hits = useMemo(() => hitIds.map(id => records[id]).filter(Boolean), [hitIds, records]);
+    const selectedHits = useMemo(() => hits.filter(hit => selectedHitIds.has(hit.howler.id)), [hits, selectedHitIds]);
+    const { assess } = useHitActions(selectedHits);
+    const unresolvedHits = useMemo(() => hitIds.filter(id => {
+        const record = records[id];
+        if (!record) {
+            // Treat missing records as unresolved until they are loaded
+            return true;
+        }
+        return record.howler.status !== 'resolved';
+    }), [hitIds, records]);
+    const handleConfirm = async () => {
+        if (unresolvedHits.length === 0 || allowUnresolvedHits) {
+            setLoading(true);
+            try {
+                await updateCase({ status: 'resolved' });
+                onConfirm();
+                close();
+            }
+            finally {
+                setLoading(false);
+            }
+        }
+    };
+    const onAssess = async () => {
+        setLoading(true);
+        setSelectedHitIds(new Set());
+        try {
+            await assess(assessment, true, rationale);
+        }
+        finally {
+            setLoading(false);
+        }
+    };
+    const handleToggleHit = useCallback((hitId) => {
+        setSelectedHitIds(prev => {
+            const next = new Set(prev);
+            if (next.has(hitId)) {
+                next.delete(hitId);
+            }
+            else {
+                next.add(hitId);
+            }
+            return next;
+        });
+    }, []);
+    useEffect(() => {
+        (async () => {
+            try {
+                const result = await dispatchApi(api.search.hit.post({
+                    query: `howler.id:(${hitIds.join(' OR ')})`,
+                    metadata: ['analytic']
+                }));
+                loadRecords(result.items);
+            }
+            finally {
+                setLoading(false);
+            }
+        })();
+    }, [dispatchApi, hitIds, loadRecords]);
+    return (_jsxs(Stack, { spacing: 1, alignItems: "start", sx: { minWidth: 'min(1000px, 60vw)', maxHeight: '100%', height: '100%' }, children: [_jsx(Typography, { variant: "h4", children: t('modal.cases.resolve') }), _jsx(Typography, { children: t('modal.cases.resolve.description') }), _jsxs(Stack, { spacing: 1, overflow: "auto", width: "100%", flex: 1, children: [_jsxs(Stack, { direction: "row", spacing: 1, children: [_jsx(Box, { flex: 1, children: _jsx(TextField, { size: "small", fullWidth: true, placeholder: t('modal.rationale.label'), "aria-label": t('modal.rationale.label'), value: rationale, onChange: ev => setRationale(ev.target.value) }) }), _jsx(Box, { flex: 1, children: _jsx(Autocomplete, { size: "small", value: assessment, onChange: (_ev, _assessment) => setAssessment(_assessment), options: config.lookups['howler.assessment'], disablePortal: true, renderInput: params => (_jsx(TextField, { ...params, placeholder: t('hit.details.actions.assessment'), "aria-label": t('hit.details.actions.assessment'), fullWidth: true })) }) }), _jsx(Button, { variant: "outlined", color: "primary", onClick: onAssess, disabled: selectedHitIds.size < 1 || !assessment, children: t('modal.cases.alerts.assess') })] }), _jsxs(Stack, { position: "relative", children: [_jsx(Divider, {}), _jsx(LinearProgress, { sx: { opacity: +loading } })] }), hits
+                        .filter(hit => unresolvedHits.includes(hit.howler.id))
+                        .map(hit => (_jsx(HitEntry, { hit: hit, checked: selectedHitIds.has(hit.howler.id), onChange: () => handleToggleHit(hit.howler.id) }, hit.howler.id))), _jsxs(Accordion, { variant: "outlined", children: [_jsx(AccordionSummary, { expandIcon: _jsx(KeyboardArrowDown, {}), children: t('modal.cases.alerts.resolved') }), _jsx(AccordionDetails, { children: _jsx(Stack, { spacing: 1, children: hits
+                                        .filter(hit => !unresolvedHits.includes(hit.howler.id))
+                                        .map(hit => (_jsx(HitEntry, { hit: hit }, hit.howler.id))) }) })] })] }), _jsx(Divider, { flexItem: true, orientation: "horizontal" }), _jsxs(Stack, { direction: "row", spacing: 1, alignSelf: "stretch", alignItems: "center", children: [_jsx(Checkbox, { size: "small", checked: allowUnresolvedHits, onChange: (_ev, checked) => setAllowUnresolvedHits(checked), inputProps: { 'aria-label': t('modal.cases.resolve.allow_unresolved.aria_label') } }), _jsx(Typography, { children: t('modal.cases.resolve.allow_unresolved') }), _jsx("div", { style: { flex: 1 } }), _jsx(Button, { variant: "outlined", color: "error", onClick: close, children: t('cancel') }), _jsx(Button, { variant: "outlined", color: "success", disabled: loading || (unresolvedHits.length > 0 && !allowUnresolvedHits), startIcon: loading ? _jsx(CircularProgress, { size: 16, color: "inherit" }) : undefined, onClick: handleConfirm, children: t('confirm') })] })] }));
+};
+export default ResolveModal;

package/components/routes/cases/modals/ResolveModal.test.d.ts

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