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

package/components/routes/cases/detail/utils.d.ts

@@ -0,0 +1,29 @@
+import type { Case } from '@cccsaurora/howler-ui/models/entities/generated/Case';
+import type { Event } from '@cccsaurora/howler-ui/models/entities/generated/Event';
+import type { Hit } from '@cccsaurora/howler-ui/models/entities/generated/Hit';
+import type { Related } from '@cccsaurora/howler-ui/models/entities/generated/Related';
+import type { ObservableEntry, ObservableRole, ObservableSource, ObservableType } from './types';
+/** All Related fields that carry asset values */
+export declare const OBSERVABLE_FIELDS: ObservableType[];
+/** Extract (type, value, seenInId) triples from a record's related field */
+export declare const extractObservables: (related: Related | undefined, recordId: string) => {
+    type: ObservableType;
+    value: string;
+    id: string;
+}[];
+/** Deduplicate and merge seenIn lists into a map keyed by `type:value` */
+export declare const buildObservableEntries: (records: Partial<Hit | Event>[]) => ObservableEntry[];
+/**
+ * Classify an asset's role based on case-level lists and per-record outline fields.
+ *
+ * Resolution order:
+ * 1. Case-level `threats[]`, `targets[]`, `indicators[]` (authoritative).
+ * 2. Per-record `outline.threat` / `outline.target` (exact match).
+ * 3. Per-record `outline.indicators[]`, `threat.indicator.ip/.description`.
+ * 4. Default: "indicator" — all assets come from `related.*` fields which are IOCs by nature.
+ *
+ * Comparison is case-insensitive and trimmed.
+ */
+export declare const classifyRole: (value: string, _case: Case, records: Partial<Hit | Event>[]) => ObservableRole;
+/** Resolve source metadata for an asset's seenIn IDs */
+export declare const resolveSources: (seenIn: string[], caseItems: Case["items"], escalationMap: Map<string, string>) => ObservableSource[];

package/components/routes/cases/detail/utils.js

@@ -0,0 +1,114 @@
+/** All Related fields that carry asset values */
+export const OBSERVABLE_FIELDS = ['hash', 'hosts', 'ip', 'user', 'ids', 'id', 'uri', 'signature'];
+/** Extract (type, value, seenInId) triples from a record's related field */
+export const extractObservables = (related, recordId) => {
+    if (!related) {
+        return [];
+    }
+    const results = [];
+    for (const field of OBSERVABLE_FIELDS) {
+        const raw = related[field];
+        if (!raw) {
+            continue;
+        }
+        const values = Array.isArray(raw) ? raw : [raw];
+        for (const value of values) {
+            if (value) {
+                results.push({ type: field, value: String(value), id: recordId });
+            }
+        }
+    }
+    return results;
+};
+/** Deduplicate and merge seenIn lists into a map keyed by `type:value` */
+export const buildObservableEntries = (records) => {
+    const map = new Map();
+    for (const record of records) {
+        const related = record.related ?? record.related;
+        const recordId = record.howler?.id ?? record.howler?.id;
+        if (!recordId) {
+            continue;
+        }
+        for (const { type, value, id } of extractObservables(related, recordId)) {
+            const key = `${type}:${value}`;
+            if (!map.has(key)) {
+                map.set(key, { type, value, seenIn: [] });
+            }
+            const entry = map.get(key);
+            if (!entry.seenIn.includes(id)) {
+                entry.seenIn.push(id);
+            }
+        }
+    }
+    return Array.from(map.values());
+};
+/**
+ * Classify an asset's role based on case-level lists and per-record outline fields.
+ *
+ * Resolution order:
+ * 1. Case-level `threats[]`, `targets[]`, `indicators[]` (authoritative).
+ * 2. Per-record `outline.threat` / `outline.target` (exact match).
+ * 3. Per-record `outline.indicators[]`, `threat.indicator.ip/.description`.
+ * 4. Default: "indicator" — all assets come from `related.*` fields which are IOCs by nature.
+ *
+ * Comparison is case-insensitive and trimmed.
+ */
+export const classifyRole = (value, _case, records) => {
+    const normalized = value.trim().toLowerCase();
+    // Case-level classification (most authoritative)
+    if (_case.threats?.some(t => String(t).trim().toLowerCase() === normalized)) {
+        return 'threat';
+    }
+    if (_case.targets?.some(t => String(t).trim().toLowerCase() === normalized)) {
+        return 'target';
+    }
+    if (_case.indicators?.some(i => String(i).trim().toLowerCase() === normalized)) {
+        return 'indicator';
+    }
+    // Per-record outline checks
+    for (const record of records) {
+        const howlerOutline = record.howler?.outline;
+        if (howlerOutline) {
+            if (howlerOutline.threat && howlerOutline.threat.trim().toLowerCase() === normalized) {
+                return 'threat';
+            }
+            if (howlerOutline.target && howlerOutline.target.trim().toLowerCase() === normalized) {
+                return 'target';
+            }
+            if (howlerOutline.indicators?.some(ind => ind.trim().toLowerCase() === normalized)) {
+                return 'indicator';
+            }
+        }
+        const indicator = record.threat?.indicator;
+        if (indicator) {
+            const indicatorIp = indicator.ip?.trim().toLowerCase();
+            const indicatorDesc = indicator.description?.trim().toLowerCase();
+            if ((indicatorIp && indicatorIp === normalized) || (indicatorDesc && indicatorDesc === normalized)) {
+                return 'indicator';
+            }
+        }
+    }
+    // Default: assets from related.* are IOCs
+    return 'indicator';
+};
+/** Resolve source metadata for an asset's seenIn IDs */
+export const resolveSources = (seenIn, caseItems, escalationMap) => {
+    if (!caseItems?.length) {
+        return [];
+    }
+    return seenIn
+        .map(id => {
+        const item = caseItems.find(i => i.value === id);
+        if (!item) {
+            return null;
+        }
+        return {
+            id,
+            type: item.type,
+            path: item.id,
+            label: item.name ?? item.value,
+            escalation: escalationMap.get(id)
+        };
+    })
+        .filter(Boolean);
+};

package/components/routes/cases/detail/utils.test.d.ts

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

package/components/routes/cases/detail/utils.test.js

@@ -0,0 +1,144 @@
+import { createMockCase, createMockEvent, createMockHit } from '@cccsaurora/howler-ui/tests/utils';
+import { describe, expect, it } from 'vitest';
+import { buildObservableEntries, classifyRole } from './utils';
+// ---------------------------------------------------------------------------
+// Pure logic tests — no React needed
+// ---------------------------------------------------------------------------
+describe('buildObservableEntries', () => {
+    it('returns an empty array for records with no related field', () => {
+        expect(buildObservableEntries([createMockHit({ howler: { id: 'h1' } })])).toEqual([]);
+    });
+    it('extracts a single IP from a hit', () => {
+        const result = buildObservableEntries([createMockHit({ howler: { id: 'h1' }, related: { ip: ['1.2.3.4'] } })]);
+        expect(result).toHaveLength(1);
+        expect(result[0]).toEqual({ type: 'ip', value: '1.2.3.4', seenIn: ['h1'] });
+    });
+    it('extracts multiple fields from a single record', () => {
+        const result = buildObservableEntries([
+            createMockHit({ howler: { id: 'h1' }, related: { ip: ['1.2.3.4'], user: ['alice'] } })
+        ]);
+        const types = result.map(a => a.type).sort();
+        expect(types).toEqual(['ip', 'user']);
+    });
+    it('deduplicates the same observable value across multiple records', () => {
+        const result = buildObservableEntries([
+            createMockHit({ howler: { id: 'h1' }, related: { ip: ['1.2.3.4'] } }),
+            createMockEvent({ howler: { id: 'obs1' }, related: { ip: ['1.2.3.4'] } })
+        ]);
+        expect(result).toHaveLength(1);
+        expect(result[0].seenIn).toEqual(['h1', 'obs1']);
+    });
+    it('keeps distinct observable values as separate entries', () => {
+        const result = buildObservableEntries([
+            createMockHit({ howler: { id: 'h1' }, related: { ip: ['1.2.3.4'] } }),
+            createMockHit({ howler: { id: 'h2' }, related: { ip: ['5.6.7.8'] } })
+        ]);
+        expect(result).toHaveLength(2);
+    });
+    it('does not duplicate seenIn ids when the same record appears twice for the same observable', () => {
+        const result = buildObservableEntries([
+            createMockHit({ howler: { id: 'h1' }, related: { ip: ['1.2.3.4'] } }),
+            createMockHit({ howler: { id: 'h1' }, related: { ip: ['1.2.3.4'] } })
+        ]);
+        expect(result[0].seenIn).toEqual(['h1']);
+    });
+    it('skips records with no howler.id', () => {
+        const noId = { related: { ip: ['1.2.3.4'] } };
+        expect(buildObservableEntries([noId])).toEqual([]);
+    });
+    it('handles the scalar `id` field on Related', () => {
+        const result = buildObservableEntries([createMockHit({ howler: { id: 'h1' }, related: { id: 'some-id' } })]);
+        expect(result).toHaveLength(1);
+        expect(result[0]).toEqual({ type: 'id', value: 'some-id', seenIn: ['h1'] });
+    });
+    it('handles array fields like hash, hosts, user, ids, uri, signature', () => {
+        const related = {
+            hash: ['abc123'],
+            hosts: ['host.example.com'],
+            user: ['bob'],
+            ids: ['guid-1'],
+            uri: ['https://example.com'],
+            signature: ['rule-X']
+        };
+        const result = buildObservableEntries([createMockHit({ howler: { id: 'h1' }, related })]);
+        const types = result.map(a => a.type).sort();
+        expect(types).toEqual(['hash', 'hosts', 'ids', 'signature', 'uri', 'user']);
+    });
+});
+// ---------------------------------------------------------------------------
+// classifyRole tests
+// ---------------------------------------------------------------------------
+describe('classifyRole', () => {
+    const emptyCase = createMockCase();
+    it('returns "threat" when value is in case.threats', () => {
+        const _case = createMockCase({ threats: ['malicious.exe'] });
+        const records = [createMockHit({ howler: { id: 'h1' } })];
+        expect(classifyRole('malicious.exe', _case, records)).toBe('threat');
+    });
+    it('returns "target" when value is in case.targets', () => {
+        const _case = createMockCase({ targets: ['server-01'] });
+        const records = [createMockHit({ howler: { id: 'h1' } })];
+        expect(classifyRole('server-01', _case, records)).toBe('target');
+    });
+    it('returns "indicator" when value is in case.indicators', () => {
+        const _case = createMockCase({ indicators: ['1.2.3.4'] });
+        const records = [createMockHit({ howler: { id: 'h1' } })];
+        expect(classifyRole('1.2.3.4', _case, records)).toBe('indicator');
+    });
+    it('returns "threat" when value matches howler.outline.threat', () => {
+        const records = [createMockHit({ howler: { id: 'h1', outline: { threat: 'malicious.exe' } } })];
+        expect(classifyRole('malicious.exe', emptyCase, records)).toBe('threat');
+    });
+    it('returns "threat" with case-insensitive matching', () => {
+        const records = [createMockHit({ howler: { id: 'h1', outline: { threat: 'Malicious.EXE' } } })];
+        expect(classifyRole('malicious.exe', emptyCase, records)).toBe('threat');
+    });
+    it('does not match threat by substring — only exact match', () => {
+        const records = [createMockHit({ howler: { id: 'h1', outline: { threat: 'evil.com dropped payload' } } })];
+        // No substring match, defaults to indicator
+        expect(classifyRole('evil.com', emptyCase, records)).toBe('indicator');
+    });
+    it('classifies as indicator when value is in outline.indicators but not in threat/target', () => {
+        const records = [
+            createMockHit({
+                howler: { id: 'h1', outline: { threat: 'actor-x', target: 'server-01', indicators: ['1.2.3.4'] } }
+            })
+        ];
+        expect(classifyRole('1.2.3.4', emptyCase, records)).toBe('indicator');
+    });
+    it('returns "target" when value matches howler.outline.target', () => {
+        const records = [createMockHit({ howler: { id: 'h1', outline: { target: 'server-01' } } })];
+        expect(classifyRole('server-01', emptyCase, records)).toBe('target');
+    });
+    it('returns "indicator" when value matches threat.indicator.ip', () => {
+        const records = [
+            createMockHit({
+                howler: { id: 'h1' },
+                threat: { indicator: { ip: '10.0.0.1' } }
+            })
+        ];
+        expect(classifyRole('10.0.0.1', emptyCase, records)).toBe('indicator');
+    });
+    it('returns "indicator" when value matches threat.indicator.description', () => {
+        const records = [
+            createMockHit({
+                howler: { id: 'h1' },
+                threat: { indicator: { description: 'suspicious-hash-abc123' } }
+            })
+        ];
+        expect(classifyRole('suspicious-hash-abc123', emptyCase, records)).toBe('indicator');
+    });
+    it('defaults to "indicator" when value has no specific classification', () => {
+        const records = [createMockHit({ howler: { id: 'h1' }, related: { ip: ['5.6.7.8'] } })];
+        expect(classifyRole('5.6.7.8', emptyCase, records)).toBe('indicator');
+    });
+    it('case-level threats take priority over per-record outline.target', () => {
+        const _case = createMockCase({ threats: ['dual-use.exe'] });
+        const records = [createMockHit({ howler: { id: 'h1', outline: { target: 'dual-use.exe' } } })];
+        expect(classifyRole('dual-use.exe', _case, records)).toBe('threat');
+    });
+    it('trims whitespace before comparing', () => {
+        const records = [createMockHit({ howler: { id: 'h1', outline: { threat: '  evil.com  ' } } })];
+        expect(classifyRole('evil.com', emptyCase, records)).toBe('threat');
+    });
+});

package/components/routes/cases/hooks/useCase.d.ts

@@ -0,0 +1,13 @@
+import type { Case } from '@cccsaurora/howler-ui/models/entities/generated/Case';
+interface CaseArguments {
+    case?: Case;
+    caseId?: string;
+}
+interface CaseResult {
+    case: Case;
+    update: (update: Partial<Case>, publish?: boolean) => Promise<void>;
+    loading: boolean;
+    missing: boolean;
+}
+declare const useCase: (args: CaseArguments) => CaseResult;
+export default useCase;

package/components/routes/cases/hooks/useCase.js

@@ -0,0 +1,69 @@
+import api from '@cccsaurora/howler-ui/api';
+import { SocketContext } from '@cccsaurora/howler-ui/components/app/providers/SocketProvider';
+import useMyApi from '@cccsaurora/howler-ui/components/hooks/useMyApi';
+import { useCallback, useContext, useEffect, useState } from 'react';
+import { isCaseUpdate } from '@cccsaurora/howler-ui/utils/socketUtils';
+const useCase = ({ caseId, case: providedCase }) => {
+    const { dispatchApi } = useMyApi();
+    const { addListener, removeListener } = useContext(SocketContext);
+    const [loading, setLoading] = useState(false);
+    const [missing, setMissing] = useState(false);
+    const [_case, setCase] = useState(providedCase);
+    const activeCaseId = _case?.case_id ?? caseId;
+    useEffect(() => {
+        if (providedCase) {
+            setCase(providedCase);
+        }
+    }, [providedCase]);
+    useEffect(() => {
+        if (caseId) {
+            setLoading(true);
+            dispatchApi(api.v2.case.get(caseId), { throwError: false })
+                .then(setCase)
+                .finally(() => setLoading(false));
+        }
+    }, [caseId, dispatchApi]);
+    useEffect(() => {
+        if (!activeCaseId) {
+            return;
+        }
+        const listenerKey = `case-update-${activeCaseId}`;
+        addListener(listenerKey, data => {
+            if (isCaseUpdate(data) && data.case.case_id === activeCaseId) {
+                setCase(data.case);
+            }
+        });
+        return () => {
+            removeListener(listenerKey);
+        };
+    }, [activeCaseId, addListener, removeListener]);
+    const update = useCallback(async (_updatedCase, publish = true) => {
+        if (!activeCaseId) {
+            return;
+        }
+        try {
+            if (publish) {
+                setCase(await dispatchApi(api.v2.case.put(activeCaseId, _updatedCase)));
+            }
+            else {
+                setCase(prevCase => {
+                    if (!prevCase) {
+                        return prevCase;
+                    }
+                    return {
+                        ...prevCase,
+                        ..._updatedCase
+                    };
+                });
+            }
+        }
+        catch (e) {
+            setMissing(true);
+        }
+        finally {
+            return;
+        }
+    }, [activeCaseId, dispatchApi]);
+    return { case: _case, update, loading, missing };
+};
+export default useCase;

package/components/routes/cases/hooks/useCase.test.d.ts

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

package/components/routes/cases/hooks/useCase.test.js

@@ -0,0 +1,141 @@
+import { act, renderHook, waitFor } from '@testing-library/react';
+import { createMockCase } from '@cccsaurora/howler-ui/tests/utils';
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+// ---------------------------------------------------------------------------
+// Hoisted mocks
+// ---------------------------------------------------------------------------
+const mockDispatchApi = vi.hoisted(() => vi.fn());
+const mockAddListener = vi.hoisted(() => vi.fn());
+const mockRemoveListener = vi.hoisted(() => vi.fn());
+const mockCaseGet = vi.hoisted(() => vi.fn());
+vi.mock('components/hooks/useMyApi', () => ({
+    default: () => ({ dispatchApi: mockDispatchApi })
+}));
+vi.mock('api', () => ({
+    default: {
+        v2: {
+            case: {
+                get: (...args) => mockCaseGet(...args),
+                put: vi.fn()
+            }
+        }
+    }
+}));
+vi.mock('components/app/providers/SocketProvider', async () => {
+    const { createContext } = await import('react');
+    return {
+        SocketContext: createContext({
+            addListener: mockAddListener,
+            removeListener: mockRemoveListener,
+            emit: vi.fn(),
+            status: 1,
+            reconnect: vi.fn(),
+            isOpen: () => true,
+            viewers: {},
+            fetchViewers: vi.fn()
+        })
+    };
+});
+// ---------------------------------------------------------------------------
+// Import after mocks
+// ---------------------------------------------------------------------------
+// eslint-disable-next-line
+import useCase from './useCase';
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+const renderUseCaseHook = (args) => {
+    return renderHook(() => useCase(args));
+};
+// ---------------------------------------------------------------------------
+// Setup
+// ---------------------------------------------------------------------------
+beforeEach(() => {
+    mockDispatchApi.mockReset();
+    mockAddListener.mockReset();
+    mockRemoveListener.mockReset();
+    mockCaseGet.mockReset();
+});
+// ---------------------------------------------------------------------------
+// Tests
+// ---------------------------------------------------------------------------
+describe('useCase', () => {
+    describe('initialization', () => {
+        it('uses the provided case directly when given', () => {
+            const mockCase = createMockCase({ case_id: 'c1', title: 'Provided' });
+            const { result } = renderUseCaseHook({ case: mockCase });
+            expect(result.current.case).toBe(mockCase);
+            expect(result.current.loading).toBe(false);
+        });
+        it('fetches the case by ID when caseId is provided', async () => {
+            const mockCase = createMockCase({ case_id: 'c2', title: 'Fetched' });
+            mockDispatchApi.mockResolvedValue(mockCase);
+            const { result } = renderUseCaseHook({ caseId: 'c2' });
+            await waitFor(() => {
+                expect(result.current.case).toEqual(mockCase);
+            });
+            expect(mockDispatchApi).toHaveBeenCalled();
+        });
+    });
+    describe('socket listener', () => {
+        it('registers a listener keyed by case ID', () => {
+            const mockCase = createMockCase({ case_id: 'c3' });
+            renderUseCaseHook({ case: mockCase });
+            expect(mockAddListener).toHaveBeenCalledWith('case-update-c3', expect.any(Function));
+        });
+        it('updates state when a matching case update is received', () => {
+            const mockCase = createMockCase({ case_id: 'c4', title: 'Original' });
+            const { result } = renderUseCaseHook({ case: mockCase });
+            const listenerCallback = mockAddListener.mock.calls[0][1];
+            const updatedCase = createMockCase({ case_id: 'c4', title: 'Updated via socket' });
+            act(() => {
+                listenerCallback({
+                    type: 'cases',
+                    case: updatedCase,
+                    error: false,
+                    message: '',
+                    status: 200
+                });
+            });
+            expect(result.current.case.title).toBe('Updated via socket');
+        });
+        it('ignores case updates for a different case ID', () => {
+            const mockCase = createMockCase({ case_id: 'c5', title: 'Original' });
+            const { result } = renderUseCaseHook({ case: mockCase });
+            const listenerCallback = mockAddListener.mock.calls[0][1];
+            const differentCase = createMockCase({ case_id: 'other-case', title: 'Different' });
+            act(() => {
+                listenerCallback({
+                    type: 'cases',
+                    case: differentCase,
+                    error: false,
+                    message: '',
+                    status: 200
+                });
+            });
+            expect(result.current.case.title).toBe('Original');
+        });
+        it('ignores non-case-update messages', () => {
+            const mockCase = createMockCase({ case_id: 'c6', title: 'Original' });
+            const { result } = renderUseCaseHook({ case: mockCase });
+            const listenerCallback = mockAddListener.mock.calls[0][1];
+            act(() => {
+                listenerCallback({
+                    type: 'hits',
+                    hit: {},
+                    version: '1',
+                    error: false,
+                    message: '',
+                    status: 200
+                });
+            });
+            expect(result.current.case.title).toBe('Original');
+        });
+        it('removes listener on unmount', () => {
+            const mockCase = createMockCase({ case_id: 'c7' });
+            const { unmount } = renderUseCaseHook({ case: mockCase });
+            unmount();
+            expect(mockRemoveListener).toHaveBeenCalledWith('case-update-c7');
+        });
+    });
+});

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

@@ -0,0 +1,7 @@
+import type { Event } from '@cccsaurora/howler-ui/models/entities/generated/Event';
+import type { Hit } from '@cccsaurora/howler-ui/models/entities/generated/Hit';
+import { type FC } from 'react';
+declare const AddRecordToCaseModal: FC<{
+    records: (Hit | Event)[];
+}>;
+export default AddRecordToCaseModal;

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

@@ -0,0 +1,57 @@
+import { createElement as _createElement } from "react";
+import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
+import { Autocomplete, Button, CircularProgress, Divider, Stack, TextField, Typography } from '@mui/material';
+import api from '@cccsaurora/howler-ui/api';
+import { ModalContext } from '@cccsaurora/howler-ui/components/app/providers/ModalProvider';
+import CaseCard from '@cccsaurora/howler-ui/components/elements/case/CaseCard';
+import useMyApi from '@cccsaurora/howler-ui/components/hooks/useMyApi';
+import { useContext, useEffect, useMemo, useState } from 'react';
+import { useTranslation } from 'react-i18next';
+import CaseRecordRow from './CaseRecordRow';
+import { useFolderOptions, useRecordEntries } from './hooks';
+// ---------------------------------------------------------------------------
+// Modal
+// ---------------------------------------------------------------------------
+const AddRecordToCaseModal = ({ records }) => {
+    const { t } = useTranslation();
+    const { dispatchApi } = useMyApi();
+    const { close } = useContext(ModalContext);
+    const [cases, setCases] = useState([]);
+    const [selectedCase, setSelectedCase] = useState(null);
+    const [submitting, setSubmitting] = useState(false);
+    const [entries, updateEntry] = useRecordEntries(records);
+    useEffect(() => {
+        dispatchApi(api.search.case.post({ query: 'case_id:*', rows: 100 }), { throwError: false }).then(result => {
+            if (result) {
+                setCases(result.items);
+            }
+        });
+    }, [dispatchApi]);
+    const folderOptions = useFolderOptions(selectedCase);
+    const isValid = useMemo(() => !!selectedCase && entries.length > 0 && entries.every(e => !!e.name.trim()), [selectedCase, entries]);
+    const onSubmit = async () => {
+        if (!isValid || !selectedCase) {
+            return;
+        }
+        setSubmitting(true);
+        try {
+            for (const entry of entries) {
+                await dispatchApi(api.v2.case.items.post(selectedCase.case_id, {
+                    name: entry.name,
+                    value: entry.record.howler.id,
+                    type: entry.record.__index,
+                    parent: entry.parent
+                }));
+            }
+            close();
+        }
+        finally {
+            setSubmitting(false);
+        }
+    };
+    return (_jsxs(Stack, { spacing: 2, p: 2, sx: { minWidth: 'min(800px, 60vw)', maxHeight: '90vh', height: '100%' }, children: [_jsx(Typography, { variant: "h4", children: t('modal.cases.add_to_case') }), _jsx(Autocomplete, { options: cases, getOptionLabel: option => option.title ?? option.case_id ?? '', isOptionEqualToValue: (option, value) => option.case_id === value.case_id, value: selectedCase, disablePortal: true, onChange: (_ev, newVal) => {
+                    setSelectedCase(newVal);
+                }, renderOption: (props, option) => (_createElement("li", { ...props, key: option.case_id, style: { ...props.style, display: 'flex', justifyContent: 'stretch', alignItems: 'stretch' } },
+                    _jsx(CaseCard, { case: option, slotProps: { card: { sx: { width: '100%' } } } }))), renderInput: params => (_jsx(TextField, { ...params, size: "small", placeholder: t('modal.cases.add_to_case.select_case'), fullWidth: true })) }), selectedCase && entries.length > 0 ? (_jsxs(_Fragment, { children: [_jsx(Divider, { children: _jsx(Typography, { variant: "caption", color: "textSecondary", children: t('modal.cases.add_to_case.items_section') }) }), _jsx(Stack, { spacing: 1, overflow: "auto", flex: 1, children: entries.map((entry, i) => (_jsx(CaseRecordRow, { entry: entry, folderOptions: folderOptions, onNameChange: val => updateEntry(i, 'name', val), onParentChange: val => updateEntry(i, 'parent', val) }, entry.record.howler.id))) })] })) : (_jsx("div", { style: { flex: 1, maxHeight: '100px' } })), _jsxs(Stack, { direction: "row", spacing: 1, alignSelf: "end", children: [_jsx(Button, { variant: "outlined", color: "error", onClick: close, disabled: submitting, children: t('cancel') }), _jsx(Button, { variant: "outlined", color: "success", disabled: !isValid || submitting, startIcon: submitting ? _jsx(CircularProgress, { size: 16, color: "inherit" }) : undefined, onClick: onSubmit, children: t('confirm') })] })] }));
+};
+export default AddRecordToCaseModal;

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

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