@cccsaurora/howler-ui 2.18.0-dev.723 → 2.18.0-dev.736

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

@@ -0,0 +1,246 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { render, screen, waitFor } from '@testing-library/react';
+import { act } from 'react';
+import { MemoryRouter } from 'react-router-dom';
+import { setupContextSelectorMock } from '@cccsaurora/howler-ui/tests/mocks';
+import { createMockCase } from '@cccsaurora/howler-ui/tests/utils';
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+setupContextSelectorMock();
+// ---------------------------------------------------------------------------
+// Hoisted mocks
+// ---------------------------------------------------------------------------
+const mockDragEndHandler = vi.hoisted(() => ({ current: null }));
+const mockDragStartHandler = vi.hoisted(() => ({ current: null }));
+const mockActiveDrag = vi.hoisted(() => ({ current: null }));
+vi.mock('@dnd-kit/core', () => ({
+    DndContext: ({ children, onDragEnd, onDragStart }) => {
+        mockDragEndHandler.current = onDragEnd;
+        mockDragStartHandler.current = onDragStart;
+        return _jsx("div", { id: "dnd-context", children: children });
+    },
+    DragOverlay: ({ children }) => _jsx("div", { id: "drag-overlay", children: children ?? null }),
+    MouseSensor: class {
+    },
+    TouchSensor: class {
+    },
+    useSensor: vi.fn(),
+    useSensors: vi.fn(() => []),
+    useDndContext: vi.fn(() => ({ active: mockActiveDrag.current })),
+    useDroppable: vi.fn(() => ({ setNodeRef: vi.fn(), isOver: false })),
+    useDraggable: vi.fn(() => ({
+        attributes: {},
+        listeners: {},
+        setNodeRef: vi.fn(),
+        transform: null,
+        isDragging: false,
+        active: null
+    })),
+    pointerWithin: vi.fn()
+}));
+vi.mock('@dnd-kit/utilities', () => ({
+    CSS: { Transform: { toString: () => '' } }
+}));
+const mockDispatchApi = vi.hoisted(() => vi.fn());
+vi.mock('components/hooks/useMyApi', () => ({
+    default: () => ({ dispatchApi: mockDispatchApi })
+}));
+const mockPut = vi.hoisted(() => vi.fn());
+vi.mock('api', () => ({
+    default: {
+        v2: {
+            case: {
+                put: (...args) => mockPut(...args),
+                get: vi.fn(),
+                items: { del: vi.fn(), patch: vi.fn() }
+            }
+        }
+    }
+}));
+vi.mock('react-router-dom', async () => {
+    const actual = await vi.importActual('react-router-dom');
+    return {
+        ...actual,
+        Link: ({ to, children, ...props }) => (_jsx("a", { href: to, ...props, children: children })),
+        useLocation: vi.fn(() => ({ pathname: '/', search: '' }))
+    };
+});
+// Stub heavy child components
+vi.mock('./sidebar/CaseFolder', () => ({
+    default: () => _jsx("div", { id: "case-folder" })
+}));
+vi.mock('./sidebar/FolderEntry', () => ({
+    default: ({ label }) => _jsx("div", { id: "folder-entry-overlay", children: label })
+}));
+vi.mock('./sidebar/RootDropZone', () => ({
+    default: ({ caseId }) => _jsx("div", { id: "root-drop-zone", "data-case-id": caseId })
+}));
+vi.mock('components/app/providers/ModalProvider', async () => {
+    const { createContext } = await import('react');
+    return {
+        ModalContext: createContext({ showModal: vi.fn(), close: vi.fn(), setContent: vi.fn() })
+    };
+});
+vi.mock('components/app/providers/RecordProvider', async () => {
+    const { createContext } = await import('react');
+    return { RecordContext: createContext({ records: {} }) };
+});
+// ---------------------------------------------------------------------------
+// Imports after mocks
+// ---------------------------------------------------------------------------
+import CaseSidebar from './CaseSidebar';
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+const hitItem = (path, value = path) => ({ type: 'hit', value, path });
+const renderSidebar = (overrides, onUpdate = vi.fn()) => {
+    const _case = createMockCase({ case_id: 'case-1', items: [], ...overrides });
+    render(_jsx(MemoryRouter, { children: _jsx(CaseSidebar, { case: _case, update: onUpdate }) }));
+    return { _case, onUpdate };
+};
+const fireDragStart = (data) => {
+    act(() => {
+        mockDragStartHandler.current?.({ active: { data: { current: data } } });
+    });
+};
+const fireDragEnd = (activeData, overData) => {
+    act(() => {
+        mockDragEndHandler.current?.({
+            active: { data: { current: activeData } },
+            over: { data: { current: overData } }
+        });
+    });
+};
+// ---------------------------------------------------------------------------
+// Setup
+// ---------------------------------------------------------------------------
+beforeEach(() => {
+    mockDispatchApi.mockReset();
+    mockPut.mockReset();
+    mockActiveDrag.current = null;
+    mockDragEndHandler.current = null;
+    mockDragStartHandler.current = null;
+});
+// ---------------------------------------------------------------------------
+// Tests
+// ---------------------------------------------------------------------------
+describe('CaseSidebar', () => {
+    describe('structure', () => {
+        it('renders the DndContext', () => {
+            renderSidebar();
+            expect(screen.getByTestId('dnd-context')).toBeInTheDocument();
+        });
+        it('renders the CaseFolder inside DndContext', () => {
+            renderSidebar();
+            expect(screen.getByTestId('case-folder')).toBeInTheDocument();
+        });
+        it('renders the RootDropZone with the correct caseId', () => {
+            renderSidebar();
+            expect(screen.getByTestId('root-drop-zone')).toHaveAttribute('data-case-id', 'case-1');
+        });
+        it('renders the DragOverlay', () => {
+            renderSidebar();
+            expect(screen.getByTestId('drag-overlay')).toBeInTheDocument();
+        });
+    });
+    describe('drag overlay', () => {
+        it('shows nothing in the overlay when no drag is active', () => {
+            renderSidebar();
+            expect(screen.queryByTestId('folder-entry-overlay')).not.toBeInTheDocument();
+        });
+        it('shows a FolderEntry in the overlay after drag starts', () => {
+            renderSidebar();
+            fireDragStart({ type: 'hit', label: 'my-item', entry: hitItem('folder/my-item'), caseId: 'case-1' });
+            expect(screen.getByTestId('folder-entry-overlay')).toBeInTheDocument();
+            expect(screen.getByText('my-item')).toBeInTheDocument();
+        });
+        it('clears the overlay after drag ends', async () => {
+            const items = [hitItem('folder/my-item', 'val')];
+            renderSidebar({ items });
+            mockDispatchApi.mockResolvedValue(createMockCase({ case_id: 'case-1', items }));
+            mockPut.mockReturnValue(Promise.resolve());
+            fireDragStart({ type: 'hit', label: 'my-item', entry: hitItem('folder/my-item'), caseId: 'case-1' });
+            expect(screen.getByTestId('folder-entry-overlay')).toBeInTheDocument();
+            fireDragEnd({ type: 'hit', entry: hitItem('folder/my-item', 'val'), caseId: 'case-1' }, { path: 'other', caseId: 'case-1' });
+            await waitFor(() => {
+                expect(screen.queryByTestId('folder-entry-overlay')).not.toBeInTheDocument();
+            });
+        });
+    });
+    describe('handleDragEnd — item moves', () => {
+        it('calls PUT with the updated path when a hit is moved to a folder', async () => {
+            const items = [hitItem('docs/report', 'rep-val')];
+            const updatedCase = createMockCase({ case_id: 'case-1', items: [hitItem('archive/report', 'rep-val')] });
+            mockPut.mockReturnValue(Promise.resolve(updatedCase));
+            mockDispatchApi.mockImplementation((p) => p);
+            const { onUpdate } = renderSidebar({ items });
+            fireDragEnd({ type: 'hit', entry: hitItem('docs/report', 'rep-val'), caseId: 'case-1' }, { path: 'archive', caseId: 'case-1' });
+            await waitFor(() => {
+                expect(mockPut).toHaveBeenCalledWith('case-1', expect.objectContaining({
+                    items: expect.arrayContaining([expect.objectContaining({ path: 'archive/report' })])
+                }));
+                expect(onUpdate).toHaveBeenCalledWith(updatedCase);
+            });
+        });
+        it('moves an item to root when the over path is empty', async () => {
+            const items = [hitItem('folder/report', 'rep-val')];
+            const updatedCase = createMockCase({ case_id: 'case-1', items: [hitItem('report', 'rep-val')] });
+            mockPut.mockReturnValue(Promise.resolve(updatedCase));
+            mockDispatchApi.mockImplementation((p) => p);
+            const { onUpdate } = renderSidebar({ items });
+            fireDragEnd({ type: 'hit', entry: hitItem('folder/report', 'rep-val'), caseId: 'case-1' }, { path: '', caseId: 'case-1' } // root drop zone
+            );
+            await waitFor(() => {
+                expect(mockPut).toHaveBeenCalledWith('case-1', expect.objectContaining({
+                    items: expect.arrayContaining([expect.objectContaining({ path: 'report' })])
+                }));
+                expect(onUpdate).toHaveBeenCalledWith(updatedCase);
+            });
+        });
+        it('moves all items under a folder when type is folder', async () => {
+            const items = [hitItem('docs/a', 'a-val'), hitItem('docs/b', 'b-val'), hitItem('other/c', 'c-val')];
+            const updatedCase = createMockCase({ case_id: 'case-1', items });
+            mockPut.mockReturnValue(Promise.resolve(updatedCase));
+            mockDispatchApi.mockImplementation((p) => p);
+            renderSidebar({ items });
+            fireDragEnd({ type: 'folder', entry: { path: 'docs' }, caseId: 'case-1' }, { path: 'archive', caseId: 'case-1' });
+            await waitFor(() => {
+                expect(mockPut).toHaveBeenCalledWith('case-1', expect.objectContaining({
+                    items: expect.arrayContaining([
+                        expect.objectContaining({ path: 'archive/docs/a' }),
+                        expect.objectContaining({ path: 'archive/docs/b' }),
+                        // Items not under 'docs' are unchanged
+                        expect.objectContaining({ path: 'other/c' })
+                    ])
+                }));
+            });
+        });
+    });
+    describe('handleDragEnd — guards', () => {
+        it('does nothing when over is null', async () => {
+            renderSidebar({ items: [hitItem('folder/item', 'val')] });
+            act(() => {
+                mockDragEndHandler.current?.({
+                    active: { data: { current: { type: 'hit', entry: hitItem('folder/item', 'val'), caseId: 'case-1' } } },
+                    over: null
+                });
+            });
+            await new Promise(r => setTimeout(r, 0));
+            expect(mockPut).not.toHaveBeenCalled();
+        });
+        it('does nothing when the path would not change (no-op drop)', async () => {
+            const items = [hitItem('folder/item', 'val')];
+            renderSidebar({ items });
+            // Dropping into the same folder → same path
+            fireDragEnd({ type: 'hit', entry: hitItem('folder/item', 'val'), caseId: 'case-1' }, { path: 'folder', caseId: 'case-1' });
+            await new Promise(r => setTimeout(r, 0));
+            expect(mockPut).not.toHaveBeenCalled();
+        });
+        it('does nothing when movingEntry.path is missing', async () => {
+            renderSidebar();
+            fireDragEnd({ type: 'hit', entry: { value: 'val' }, caseId: 'case-1' }, // no path
+            { path: 'archive', caseId: 'case-1' });
+            await new Promise(r => setTimeout(r, 0));
+            expect(mockPut).not.toHaveBeenCalled();
+        });
+    });
+});

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

@@ -0,0 +1,11 @@
+import type { Task } from '@cccsaurora/howler-ui/models/entities/generated/Task';
+import { type FC } from 'react';
+declare const CaseTask: FC<{
+    task?: Task;
+    paths: string[];
+    onDelete?: () => Promise<void>;
+    onEdit: (task?: Partial<Task>) => Promise<void>;
+    loading?: boolean;
+    newTask?: boolean;
+}>;
+export default CaseTask;

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

@@ -0,0 +1,57 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Check, Close, Delete, Edit } from '@mui/icons-material';
+import { Autocomplete, Card, Checkbox, Chip, IconButton, LinearProgress, Stack, TextField, Tooltip, Typography } from '@mui/material';
+import UserList from '@cccsaurora/howler-ui/components/elements/UserList';
+import { useEffect, useState } from 'react';
+import { useTranslation } from 'react-i18next';
+import { Link } from 'react-router-dom';
+const CaseTask = ({ task, onEdit, onDelete, paths, newTask = false }) => {
+    const { t } = useTranslation();
+    const [loading, setLoading] = useState(false);
+    const [editing, setEditing] = useState(newTask);
+    const [summary, setSummary] = useState(task?.summary || '');
+    const [path, setPath] = useState(task?.path ?? null);
+    const [assignment, setAssignment] = useState(task?.assignment);
+    const [complete, setComplete] = useState(task?.complete ?? false);
+    const dirty = summary !== task?.summary || path !== task?.path || complete !== task?.complete || assignment !== task?.assignment;
+    const onSubmit = async () => {
+        if (dirty && editing) {
+            setLoading(true);
+            await onEdit({ summary, path: !path ? null : path, assignment, complete });
+            setLoading(false);
+        }
+    };
+    useEffect(() => {
+        if (!editing && task?.assignment !== assignment) {
+            setLoading(true);
+            onEdit({ assignment }).finally(() => setLoading(false));
+        }
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, [assignment]);
+    useEffect(() => {
+        if (!editing && task?.complete !== complete) {
+            setLoading(true);
+            onEdit({ complete }).finally(() => setLoading(false));
+        }
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, [complete]);
+    return (_jsxs(Card, { sx: { pl: 0.5, pr: 1, py: 0.5, position: 'relative' }, children: [_jsxs(Stack, { direction: "row", alignItems: "center", spacing: 1, children: [_jsx(Checkbox, { disabled: loading, color: "success", checked: complete, size: "small", onChange: (_ev, _complete) => setComplete(_complete) }), editing ? (_jsx(TextField, { disabled: loading, value: summary, onChange: e => setSummary(e.target.value), size: "small", fullWidth: true, sx: { minWidth: '40%' } })) : (_jsx(Typography, { sx: [complete && { textDecoration: 'line-through' }], children: task?.summary || summary })), !editing && path && _jsx(Chip, { clickable: true, component: Link, to: path, label: path }), editing && (_jsx(Autocomplete, { disabled: loading, value: path, options: paths, onChange: (_ev, value) => setPath(value), fullWidth: true, renderInput: params => _jsx(TextField, { ...params, size: "small" }) })), _jsx(UserList, { disabled: loading, userIds: [assignment], onChange: ([_assigment]) => setAssignment(_assigment), i18nLabel: "route.cases.task.set.assignment", avatarHeight: 24 }), _jsx("div", { style: { flex: 1 } }), editing && !newTask && (_jsx(Tooltip, { title: t('route.cases.task.delete'), children: _jsx(IconButton, { size: "small", color: "error", onClick: () => {
+                                setLoading(true);
+                                onDelete().then(() => setLoading(false));
+                            }, disabled: loading, children: _jsx(Delete, { fontSize: "small" }) }) })), _jsx(Tooltip, { title: t(editing ? 'route.cases.task.edit.save' : 'route.cases.task.edit'), children: _jsx("span", { children: _jsx(IconButton, { size: "small", color: editing ? 'success' : 'default', onClick: async () => {
+                                    if (!editing) {
+                                        setEditing(true);
+                                        return;
+                                    }
+                                    await onSubmit();
+                                    setEditing(false);
+                                }, disabled: (!dirty && editing) || loading || !summary, children: editing ? _jsx(Check, { fontSize: "small" }) : _jsx(Edit, { fontSize: "small" }) }) }) }), editing && (_jsx(Tooltip, { title: t('route.cases.task.edit.cancel'), children: _jsx(IconButton, { size: "small", onClick: () => {
+                                if (newTask) {
+                                    onDelete();
+                                }
+                                else {
+                                    setEditing(false);
+                                }
+                            }, disabled: loading, children: _jsx(Close, { fontSize: "small" }) }) }))] }), loading && _jsx(LinearProgress, { sx: { left: 0, bottom: 0, right: 0, position: 'absolute' } })] }));
+};
+export default CaseTask;

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

@@ -0,0 +1,12 @@
+import type { Case } from '@cccsaurora/howler-ui/models/entities/generated/Case';
+interface MitreOption {
+    id: string;
+    name: string;
+    kind: 'tactic' | 'technique';
+}
+export declare const buildFilters: (mitre: MitreOption[], escalations: string[]) => string[];
+declare const _default: import("react").NamedExoticComponent<{
+    case?: Case;
+    caseId?: string;
+}>;
+export default _default;

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

@@ -0,0 +1,106 @@
+import { createElement as _createElement } from "react";
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { FilterList } from '@mui/icons-material';
+import { Autocomplete, Box, Chip, Divider, Skeleton, Stack, TextField, Tooltip, Typography } from '@mui/material';
+import api from '@cccsaurora/howler-ui/api';
+import { ApiConfigContext } from '@cccsaurora/howler-ui/components/app/providers/ApiConfigProvider';
+import { RecordContext } from '@cccsaurora/howler-ui/components/app/providers/RecordProvider';
+import HitCard from '@cccsaurora/howler-ui/components/elements/hit/HitCard';
+import { HitLayout } from '@cccsaurora/howler-ui/components/elements/hit/HitLayout';
+import ObservableCard from '@cccsaurora/howler-ui/components/elements/observable/ObservableCard';
+import useMyApi from '@cccsaurora/howler-ui/components/hooks/useMyApi';
+import dayjs from 'dayjs';
+import { capitalize } from 'lodash-es';
+import { memo, useContext, useEffect, useMemo, useState } from 'react';
+import { useTranslation } from 'react-i18next';
+import { Link, useOutletContext } from 'react-router-dom';
+import { useContextSelector } from 'use-context-selector';
+import { ESCALATION_COLORS } from '@cccsaurora/howler-ui/utils/constants';
+import { isHit } from '@cccsaurora/howler-ui/utils/typeUtils';
+import useCase from '../hooks/useCase';
+// builds the additional filters for the lucene query
+export const buildFilters = (mitre, escalations) => {
+    const filters = [];
+    const tacticIds = mitre.filter(o => o.kind === 'tactic').map(o => o.id);
+    const techniqueIds = mitre.filter(o => o.kind === 'technique').map(o => o.id);
+    if (tacticIds.length) {
+        filters.push(`threat.tactic.id:(${tacticIds.join(' OR ')})`);
+    }
+    if (techniqueIds.length) {
+        filters.push(`threat.technique.id:(${techniqueIds.join(' OR ')})`);
+    }
+    if (escalations.length) {
+        filters.push(`howler.escalation:(${escalations.join(' OR ')})`);
+    }
+    return filters;
+};
+const CaseTimeline = ({ case: providedCase, caseId }) => {
+    const { t } = useTranslation();
+    const { dispatchApi } = useMyApi();
+    const { config } = useContext(ApiConfigContext);
+    const routeCase = useOutletContext();
+    const { case: _case } = useCase({ case: providedCase ?? routeCase, caseId });
+    const loadRecords = useContextSelector(RecordContext, ctx => ctx.loadRecords);
+    const [mitreOptions, setMitreOptions] = useState([]);
+    const [escalationOptions, setEscalationOptions] = useState([]);
+    const [displayedEntries, setDisplayedEntries] = useState([]);
+    const [loading, setLoading] = useState(false);
+    const [selectedMitres, setSelectedMitres] = useState([]);
+    const [selectedEscalations, setSelectedEscalations] = useState(['evidence']);
+    const ids = useMemo(() => (_case?.items ?? [])
+        .filter(item => ['hit', 'observable'].includes(item.type))
+        .map(item => item.value)
+        .filter(Boolean), [_case]);
+    const getPath = (value) => _case.items.find(item => item.value === value)?.path;
+    useEffect(() => {
+        if (ids.length < 1) {
+            return;
+        }
+        dispatchApi(api.v2.search.facet.post(['hit', 'observable'], {
+            fields: ['threat.tactic.id', 'threat.technique.id', 'howler.escalation'],
+            filters: [`howler.id:(${ids.join(' OR ')})`]
+        }), { throwError: false }).then(result => {
+            if (!result) {
+                return;
+            }
+            setEscalationOptions(Object.keys(result['howler.escalation'] ?? {}));
+            const tactics = Object.keys(result['threat.tactic.id'] ?? {}).map(tactic => ({
+                id: tactic,
+                name: config.lookups?.tactics?.[tactic].name ?? tactic,
+                kind: 'tactic'
+            }));
+            const techniques = Object.keys(result['threat.technique.id'] ?? {}).map(technique => ({
+                id: technique,
+                name: config.lookups?.techniques?.[technique].name ?? technique,
+                kind: 'technique'
+            }));
+            setMitreOptions([...tactics, ...techniques]);
+        });
+    }, [config.lookups?.tactics, config.lookups?.techniques, dispatchApi, ids]);
+    useEffect(() => {
+        if (!ids.length) {
+            setDisplayedEntries([]);
+            return;
+        }
+        setLoading(true);
+        const filters = buildFilters(selectedMitres, selectedEscalations);
+        dispatchApi(api.v2.search.post(['hit', 'observable'], {
+            query: `howler.id:(${ids.join(' OR ')})`,
+            sort: 'event.created asc',
+            rows: ids.length,
+            filters
+        }), { throwError: false }).then(response => {
+            setLoading(false);
+            if (!response) {
+                return;
+            }
+            loadRecords(response.items);
+            setDisplayedEntries(response.items);
+        });
+    }, [ids, selectedMitres, selectedEscalations, dispatchApi, loadRecords]);
+    if (!_case) {
+        return null;
+    }
+    return (_jsxs(Stack, { spacing: 0, sx: { height: '100%' }, children: [_jsxs(Stack, { direction: "row", spacing: 1, alignItems: "center", flexWrap: "wrap", sx: { p: 1, gap: 1 }, children: [_jsx(Tooltip, { title: t('page.cases.timeline.filter.label'), children: _jsx(FilterList, { fontSize: "small", color: "action" }) }), _jsx(Autocomplete, { multiple: true, size: "small", options: mitreOptions, value: selectedMitres, onChange: (_e, values) => setSelectedMitres(values), getOptionLabel: opt => `${opt.id} - ${opt.name}`, isOptionEqualToValue: (opt, val) => opt.id === val.id, groupBy: opt => capitalize(opt.kind), renderTags: (value, getTagProps) => value.map((opt, index) => (_createElement(Chip, { ...getTagProps({ index }), key: opt.id, size: "small", label: opt.id, color: "primary" }))), renderInput: params => (_jsx(TextField, { ...params, label: t('page.cases.timeline.filter.mitre'), sx: { minWidth: 260 } })), noOptionsText: t('page.cases.timeline.filter.mitre.empty') }), _jsx(Autocomplete, { multiple: true, size: "small", options: escalationOptions, value: selectedEscalations, onChange: (_e, value) => setSelectedEscalations(value), getOptionLabel: opt => t(`howler.escalation.${opt}`, opt), renderTags: (value, getTagProps) => value.map((opt, index) => (_createElement(Chip, { ...getTagProps({ index }), key: opt, size: "small", label: opt, color: ESCALATION_COLORS[opt] }))), renderInput: params => (_jsx(TextField, { ...params, label: t('page.cases.timeline.filter.escalation'), sx: { minWidth: 220 } })), noOptionsText: t('page.cases.timeline.filter.escalation.empty') })] }), _jsx(Divider, {}), loading ? (_jsx(Stack, { spacing: 2, sx: { px: 2, py: 1 }, children: [0, 1, 2].map(i => (_jsxs(Stack, { direction: "row", width: "100%", spacing: 1, children: [_jsx(Skeleton, { variant: "text", width: 120, height: 24 }), _jsx(Skeleton, { variant: "rounded", height: 120, sx: { flex: 1 } })] }, i))) })) : displayedEntries.length === 0 ? (_jsx(Box, { sx: { pt: 4, textAlign: 'center' }, children: _jsx(Typography, { color: "textSecondary", children: t('page.cases.timeline.empty') }) })) : (_jsx(Stack, { component: "ol", spacing: 0, sx: { px: 2, py: 1, listStyle: 'none', m: 0, overflow: 'auto' }, children: displayedEntries.map(entry => (_jsxs(Stack, { component: "li", spacing: 1, sx: { pb: 1 }, children: [_jsxs(Stack, { direction: "row", spacing: 2, alignItems: "flex-start", children: [_jsx(Typography, { variant: "caption", color: "textSecondary", sx: { whiteSpace: 'nowrap' }, children: dayjs(entry.event?.created ?? entry.timestamp).format('YYYY-MM-DD HH:mm:ss') }), _jsx(Box, { component: Link, to: `/cases/${_case.case_id}/${getPath(entry.howler.id)}`, sx: { flex: 1, minWidth: 0, textDecoration: 'none' }, children: isHit(entry) ? (_jsx(HitCard, { id: entry.howler.id, layout: HitLayout.DENSE, readOnly: true })) : (_jsx(ObservableCard, { id: entry.howler.id })) })] }), _jsx(Divider, { flexItem: true })] }, entry.howler.id))) }))] }));
+};
+export default memo(CaseTimeline);

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

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