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

package/components/routes/cases/detail/sidebar/RootDropZone.d.ts

@@ -0,0 +1,5 @@
+import type { FC } from 'react';
+declare const RootDropZone: FC<{
+    caseId: string;
+}>;
+export default RootDropZone;

package/components/routes/cases/detail/sidebar/RootDropZone.js

@@ -0,0 +1,33 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useDndContext, useDroppable } from '@dnd-kit/core';
+import { Inbox } from '@mui/icons-material';
+import { alpha, Box, Typography } from '@mui/material';
+import { useTranslation } from 'react-i18next';
+const RootDropZone = ({ caseId }) => {
+    const { t } = useTranslation();
+    const { active } = useDndContext();
+    const { setNodeRef, isOver } = useDroppable({
+        id: `${caseId}:folder:__root__`,
+        data: { path: '', caseId, folderId: null }
+    });
+    if (!active) {
+        return null;
+    }
+    return (_jsxs(Box, { ref: setNodeRef, sx: theme => ({
+            minHeight: '250px',
+            display: 'flex',
+            flexDirection: 'column',
+            alignItems: 'center',
+            justifyContent: 'center',
+            gap: 1,
+            border: '2px dashed',
+            borderColor: isOver ? theme.palette.primary.main : theme.palette.divider,
+            borderRadius: 1,
+            mx: 1,
+            mt: 1,
+            transition: theme.transitions.create(['border-color', 'background-color']),
+            bgcolor: isOver ? alpha(theme.palette.primary.main, 0.08) : 'transparent',
+            color: isOver ? theme.palette.primary.main : theme.palette.text.secondary
+        }), children: [_jsx(Inbox, { fontSize: "large", sx: { opacity: 0.6 } }), _jsx(Typography, { variant: "caption", children: t('page.cases.folder.drop.root') })] }));
+};
+export default RootDropZone;

package/components/routes/cases/detail/sidebar/types.d.ts

@@ -0,0 +1,9 @@
+import type { Item } from 'models/entities/generated/Item';
+
+export type Tree = {
+  item: Item;
+  leaves?: Item[];
+  folders?: {
+    [key: string]: Tree;
+  };
+};

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

@@ -0,0 +1,10 @@
+import type { Item } from '@cccsaurora/howler-ui/models/entities/generated/Item';
+import type { Tree } from './types';
+/**
+ * Build a tree from a flat array of items using parent-based relationships.
+ *
+ * Folder items (type=folder) become tree nodes whose children are items
+ * referencing the folder's `id` as their `parent`.
+ * Items with `parent=null` or `parent=undefined` are root-level.
+ */
+export declare const buildTree: (items?: Item[]) => Tree;

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

@@ -0,0 +1,51 @@
+import { sortBy } from 'lodash-es';
+/**
+ * Build a tree from a flat array of items using parent-based relationships.
+ *
+ * Folder items (type=folder) become tree nodes whose children are items
+ * referencing the folder's `id` as their `parent`.
+ * Items with `parent=null` or `parent=undefined` are root-level.
+ */
+export const buildTree = (items = []) => {
+    const root = { item: null, leaves: [], folders: {} };
+    // Index folders by id
+    const folderNodes = {};
+    const folderItems = items.filter(item => item.type === 'folder');
+    for (const folder of folderItems) {
+        if (folder.id) {
+            folderNodes[folder.id] = {
+                leaves: [],
+                folders: {},
+                item: folder
+            };
+        }
+    }
+    // Build folder hierarchy
+    for (const folder of folderItems) {
+        if (!folder.id) {
+            continue;
+        }
+        const node = folderNodes[folder.id];
+        const folderName = folder.name ?? folder.value ?? folder.id;
+        if (!folderName) {
+            continue;
+        }
+        if (folder.parent && folderNodes[folder.parent]) {
+            folderNodes[folder.parent].folders[folderName] = node;
+        }
+        else {
+            root.folders[folderName] = node;
+        }
+    }
+    // Place non-folder items
+    const nonFolderItems = items.filter(item => item.type !== 'folder');
+    for (const item of sortBy(nonFolderItems, 'value')) {
+        if (item.parent && folderNodes[item.parent]) {
+            folderNodes[item.parent].leaves.push(item);
+        }
+        else {
+            root.leaves.push(item);
+        }
+    }
+    return root;
+};

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

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

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

@@ -0,0 +1,82 @@
+import { describe, expect, it } from 'vitest';
+import { buildTree } from './utils';
+describe('buildTree', () => {
+    it('returns an empty tree for no items', () => {
+        const result = buildTree();
+        expect(result.leaves).toEqual([]);
+        expect(result.folders).toEqual({});
+    });
+    it('returns an empty tree for an empty array', () => {
+        const result = buildTree([]);
+        expect(result.leaves).toEqual([]);
+        expect(result.folders).toEqual({});
+    });
+    it('places items at root when parent is null', () => {
+        const item = { id: 'item-1', type: 'hit', value: 'hit-001', parent: null };
+        const result = buildTree([item]);
+        expect(result.leaves).toEqual([item]);
+    });
+    it('places items at root when parent is undefined', () => {
+        const item = { id: 'item-1', type: 'hit', value: 'hit-001' };
+        const result = buildTree([item]);
+        expect(result.leaves).toEqual([item]);
+    });
+    it('places items inside a folder by parent reference', () => {
+        const folder = { id: 'folder-1', type: 'folder', value: 'My Folder', name: 'My Folder', parent: null };
+        const item = { id: 'item-1', type: 'hit', value: 'hit-001', parent: 'folder-1' };
+        const result = buildTree([folder, item]);
+        expect(result.folders?.['My Folder']).toBeDefined();
+        expect(result.folders?.['My Folder'].leaves).toEqual([item]);
+    });
+    it('renders empty folders', () => {
+        const folder = { id: 'folder-1', type: 'folder', value: 'Empty', name: 'Empty', parent: null };
+        const result = buildTree([folder]);
+        expect(result.folders?.Empty).toBeDefined();
+        expect(result.folders?.Empty.leaves).toEqual([]);
+    });
+    it('nests folders inside other folders', () => {
+        const parent = { id: 'f1', type: 'folder', value: 'Parent', name: 'Parent', parent: null };
+        const child = { id: 'f2', type: 'folder', value: 'Child', name: 'Child', parent: 'f1' };
+        const item = { id: 'i1', type: 'hit', value: 'hit-1', parent: 'f2' };
+        const result = buildTree([parent, child, item]);
+        expect(result.folders?.Parent.folders?.Child.leaves).toEqual([item]);
+    });
+    it('includes folder id in tree nodes', () => {
+        const folder = { id: 'folder-1', type: 'folder', value: 'Folder', name: 'Folder', parent: null };
+        const result = buildTree([folder]);
+        expect(result.folders?.Folder.item?.id).toBe('folder-1');
+    });
+    it('places orphaned items at root when parent folder is missing', () => {
+        const item = { id: 'i1', type: 'hit', value: 'hit-1', parent: 'missing-folder' };
+        const result = buildTree([item]);
+        expect(result.leaves).toEqual([item]);
+    });
+    it('handles markdown items', () => {
+        const markdown = { id: 'md-1', type: 'markdown', value: '# Hello', parent: null };
+        const result = buildTree([markdown]);
+        expect(result.leaves).toEqual([markdown]);
+    });
+    it('handles multiple root-level items', () => {
+        const a = { id: 'a', type: 'hit', value: 'hit-a' };
+        const b = { id: 'b', type: 'event', value: 'event-b' };
+        const result = buildTree([a, b]);
+        expect(result.leaves).toHaveLength(2);
+    });
+    it('handles multiple items in the same folder', () => {
+        const folder = { id: 'f1', type: 'folder', value: 'Alerts', name: 'Alerts', parent: null };
+        const a = { id: 'a', type: 'hit', value: 'hit-a', parent: 'f1' };
+        const b = { id: 'b', type: 'hit', value: 'hit-b', parent: 'f1' };
+        const result = buildTree([folder, a, b]);
+        expect(result.folders?.Alerts.leaves).toHaveLength(2);
+    });
+    it('handles items with name field', () => {
+        const item = { id: 'i1', type: 'hit', value: 'hit-1', name: 'My Hit' };
+        const result = buildTree([item]);
+        expect(result.leaves?.[0].name).toBe('My Hit');
+    });
+    it('preserves all item fields on leaves', () => {
+        const rich = { id: 'r1', type: 'reference', value: 'https://example.com', name: 'Example', parent: null };
+        const result = buildTree([rich]);
+        expect(result.leaves?.[0]).toEqual(rich);
+    });
+});

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

@@ -0,0 +1,22 @@
+export type ObservableType = 'hash' | 'hosts' | 'ip' | 'user' | 'ids' | 'id' | 'uri' | 'signature';
+
+export type ObservableRole = 'threat' | 'target' | 'indicator';
+
+export interface ObservableSource {
+  id: string;
+  type: 'hit' | 'event' | 'case';
+  path?: string;
+  label?: string;
+  escalation?: string;
+}
+
+export interface ObservableEntry {
+  type: ObservableType;
+  value: string;
+  /** Resolved source metadata for each seenIn item */
+  sources?: ObservableSource[];
+  /** Classified role of this observable */
+  role?: ObservableRole;
+}
+
+export type OriginType = 'hit' | 'event';

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

@@ -0,0 +1,28 @@
+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) => {
+    type: ObservableType;
+    value: string;
+}[];
+/** Deduplicate observables and resolve their record IDs to case-item sources */
+export declare const buildObservableEntries: (_case: Case, records: (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 observable's record IDs */
+export declare const resolveSource: (record: Hit | Event, _case: Case) => ObservableSource;

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

@@ -0,0 +1,117 @@
+import { has } from 'lodash-es';
+import { buildPathFromID } from '../utils';
+/** 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) => {
+    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) });
+            }
+        }
+    }
+    return results;
+};
+/** Deduplicate observables and resolve their record IDs to case-item sources */
+export const buildObservableEntries = (_case, records) => {
+    const 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 } of extractObservables(related)) {
+            const key = `${type}:${value}`;
+            if (!has(map, key)) {
+                map[key] = { type, value, sources: [], role: classifyRole(value, _case, records) };
+            }
+            const entry = map[key];
+            if (entry.sources.some(existingSource => existingSource.id === recordId)) {
+                continue;
+            }
+            const source = resolveSource(record, _case);
+            if (!source) {
+                continue;
+            }
+            entry.sources.push(source);
+        }
+    }
+    return Object.values(map).filter(Boolean);
+};
+/**
+ * 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 observable's record IDs */
+export const resolveSource = (record, _case) => {
+    if (!_case?.items?.length) {
+        return null;
+    }
+    const item = _case.items.find(i => i.value === record.howler.id);
+    if (!item) {
+        return null;
+    }
+    return {
+        id: record.howler.id,
+        type: item.type,
+        path: item.id ? buildPathFromID(_case, item.id) : undefined,
+        label: item.name ?? item.value,
+        escalation: record.howler.escalation
+    };
+};

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

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

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

@@ -0,0 +1,166 @@
+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(createMockCase(), [createMockHit({ howler: { id: 'h1' } })])).toEqual([]);
+    });
+    it('extracts a single IP with a resolved source', () => {
+        const _case = createMockCase({
+            items: [{ id: 'hit-item', type: 'hit', value: 'h1', name: 'First hit' }]
+        });
+        const result = buildObservableEntries(_case, [
+            createMockHit({ howler: { id: 'h1', escalation: 'evidence' }, related: { ip: ['1.2.3.4'] } })
+        ]);
+        expect(result).toHaveLength(1);
+        expect(result[0]).toEqual({
+            type: 'ip',
+            value: '1.2.3.4',
+            role: 'indicator',
+            sources: [{ id: 'h1', type: 'hit', path: 'First hit', label: 'First hit', escalation: 'evidence' }]
+        });
+    });
+    it('extracts multiple fields from a single record', () => {
+        const result = buildObservableEntries(createMockCase(), [
+            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 _case = createMockCase({
+            items: [
+                { id: 'hit-item', type: 'hit', value: 'h1', name: 'First hit' },
+                { id: 'event-item', type: 'event', value: 'obs1', name: 'First event' }
+            ]
+        });
+        const result = buildObservableEntries(_case, [
+            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].sources).toEqual([
+            { id: 'h1', type: 'hit', path: 'First hit', label: 'First hit', escalation: undefined },
+            { id: 'obs1', type: 'event', path: 'First event', label: 'First event', escalation: undefined }
+        ]);
+    });
+    it('keeps distinct observable values as separate entries', () => {
+        const result = buildObservableEntries(createMockCase(), [
+            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 sources when the same record appears twice for the same observable', () => {
+        const _case = createMockCase({ items: [{ id: 'hit-item', type: 'hit', value: 'h1' }] });
+        const result = buildObservableEntries(_case, [
+            createMockHit({ howler: { id: 'h1' }, related: { ip: ['1.2.3.4'] } }),
+            createMockHit({ howler: { id: 'h1' }, related: { ip: ['1.2.3.4'] } })
+        ]);
+        expect(result[0].sources).toEqual([{ id: 'h1', type: 'hit', path: 'h1', label: 'h1', escalation: undefined }]);
+    });
+    it('skips records with no howler.id', () => {
+        const noId = { related: { ip: ['1.2.3.4'] } };
+        expect(buildObservableEntries(createMockCase(), [noId])).toEqual([]);
+    });
+    it('handles the scalar `id` field on Related', () => {
+        const result = buildObservableEntries(createMockCase(), [
+            createMockHit({ howler: { id: 'h1' }, related: { id: 'some-id' } })
+        ]);
+        expect(result).toHaveLength(1);
+        expect(result[0]).toEqual({ type: 'id', value: 'some-id', role: 'indicator', sources: [] });
+    });
+    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(createMockCase(), [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,67 @@
+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, useId, 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 listenerId = useId();
+    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);
+            void dispatchApi(api.v2.case.get(caseId), { throwError: false })
+                .then(setCase)
+                .finally(() => setLoading(false));
+        }
+    }, [caseId, dispatchApi]);
+    useEffect(() => {
+        if (!activeCaseId) {
+            return;
+        }
+        const listenerKey = `case-update-${activeCaseId}-${listenerId}`;
+        addListener(listenerKey, data => {
+            if (isCaseUpdate(data) && data.case.case_id === activeCaseId) {
+                setCase(data.case);
+            }
+        });
+        return () => {
+            removeListener(listenerKey);
+        };
+    }, [activeCaseId, addListener, listenerId, 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 {
+            setMissing(true);
+        }
+    }, [activeCaseId, dispatchApi]);
+    return { case: _case, update, loading, missing };
+};
+export default useCase;

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

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