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

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

@@ -1,363 +0,0 @@
-import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-import { fireEvent, render, screen, waitFor } from '@testing-library/react';
-import { act } from 'react';
-import { beforeEach, describe, expect, it, vi } from 'vitest';
-// ---------------------------------------------------------------------------
-// Mocks
-// ---------------------------------------------------------------------------
-vi.mock('components/elements/ContextMenu', () => ({
-    default: ({ items, children }) => (_jsxs("div", { children: [children, items.map((item) => {
-                if (item.kind === 'item') {
-                    return (_jsx("button", { id: item.id, onClick: item.onClick, children: item.label }, item.id));
-                }
-                if (item.kind === 'divider') {
-                    return _jsx("hr", {}, item.id);
-                }
-                return null;
-            })] }))
-}));
-const mockDispatchApi = vi.hoisted(() => vi.fn());
-vi.mock('components/hooks/useMyApi', () => ({
-    default: () => ({ dispatchApi: mockDispatchApi })
-}));
-const mockDel = vi.hoisted(() => vi.fn());
-const mockPatch = vi.hoisted(() => vi.fn());
-vi.mock('api', () => ({
-    default: {
-        v2: {
-            case: {
-                items: {
-                    del: (...args) => mockDel(...args),
-                    patch: (...args) => mockPatch(...args)
-                }
-            }
-        }
-    }
-}));
-const mockShowModal = vi.hoisted(() => vi.fn());
-vi.mock('components/app/providers/ModalProvider', async () => {
-    const { createContext } = await import('react');
-    return {
-        ModalContext: createContext({ showModal: mockShowModal, close: vi.fn(), setContent: vi.fn() })
-    };
-});
-vi.mock('components/routes/cases/modals/RenameItemModal', () => ({
-    default: () => _jsx("div", { id: "rename-item-modal" })
-}));
-// ---------------------------------------------------------------------------
-// Imports (after mocks so that module registry picks up the stubs)
-// ---------------------------------------------------------------------------
-import CaseFolderContextMenu, { collectAllLeaves, getOpenUrl } from './CaseFolderContextMenu';
-// ---------------------------------------------------------------------------
-// Fixtures
-// ---------------------------------------------------------------------------
-const mockCase = { case_id: 'case-1', title: 'Test Case', items: [] };
-const hitLeaf = { type: 'hit', value: 'hit-123', path: 'folder/hit-item' };
-const referenceLeaf = { type: 'reference', value: 'https://example.com', path: 'folder/ref-item' };
-const observableLeaf = { type: 'observable', value: 'obs-456', path: 'folder/obs-item' };
-const caseLeaf = { type: 'case', value: 'nested-case-id', path: 'folder/case-item' };
-const tableLeaf = { type: 'table', value: 'table-789', path: 'folder/table-item' };
-const leadLeaf = { type: 'lead', value: 'lead-999', path: 'folder/lead-item' };
-const renderMenu = (props) => render(_jsx(CaseFolderContextMenu, { _case: mockCase, ...props, children: _jsx("div", { id: "child", children: "child" }) }));
-// ---------------------------------------------------------------------------
-// Setup
-// ---------------------------------------------------------------------------
-beforeEach(() => {
-    mockDel.mockClear();
-    mockPatch.mockClear();
-    mockDispatchApi.mockClear();
-    mockShowModal.mockClear();
-    mockDispatchApi.mockImplementation((p) => p);
-    mockDel.mockResolvedValue(mockCase);
-    mockPatch.mockResolvedValue(mockCase);
-    vi.spyOn(window, 'open').mockReturnValue(null);
-});
-// ---------------------------------------------------------------------------
-// Unit tests for exported utilities
-// ---------------------------------------------------------------------------
-describe('collectAllLeaves', () => {
-    it('returns leaves at the root level', () => {
-        const tree = { path: '', leaves: [hitLeaf, referenceLeaf] };
-        expect(collectAllLeaves(tree)).toEqual([hitLeaf, referenceLeaf]);
-    });
-    it('returns leaves from nested subfolders', () => {
-        const tree = {
-            path: '',
-            leaves: [hitLeaf],
-            folders: {
-                subfolder: { path: 'subfolder', leaves: [referenceLeaf] }
-            }
-        };
-        expect(collectAllLeaves(tree)).toEqual([hitLeaf, referenceLeaf]);
-    });
-    it('returns leaves from deeply nested subfolders', () => {
-        const tree = {
-            path: '',
-            leaves: [],
-            folders: {
-                level1: {
-                    path: 'level1',
-                    leaves: [hitLeaf],
-                    folders: {
-                        level2: { path: 'level1/level2', leaves: [referenceLeaf] }
-                    }
-                }
-            }
-        };
-        const result = collectAllLeaves(tree);
-        expect(result).toContain(hitLeaf);
-        expect(result).toContain(referenceLeaf);
-    });
-    it('returns an empty array for an empty tree', () => {
-        expect(collectAllLeaves({ path: '', leaves: [] })).toEqual([]);
-    });
-});
-describe('getOpenUrl', () => {
-    it('returns the value directly for a reference item', () => {
-        expect(getOpenUrl(referenceLeaf)).toBe('https://example.com');
-    });
-    it('returns /hits/<id> for a hit item', () => {
-        expect(getOpenUrl(hitLeaf)).toBe('/hits/hit-123');
-    });
-    it('returns /observables/<id> for an observable item', () => {
-        expect(getOpenUrl(observableLeaf)).toBe('/observables/obs-456');
-    });
-    it('returns /cases/<id> for a case item', () => {
-        expect(getOpenUrl(caseLeaf)).toBe('/cases/nested-case-id');
-    });
-    it('returns null for a table item', () => {
-        expect(getOpenUrl(tableLeaf)).toBeNull();
-    });
-    it('returns null for a lead item', () => {
-        expect(getOpenUrl(leadLeaf)).toBeNull();
-    });
-    it('returns null when value is undefined', () => {
-        expect(getOpenUrl({ type: 'hit' })).toBeNull();
-    });
-    it('returns null when type is undefined', () => {
-        expect(getOpenUrl({ value: 'something' })).toBeNull();
-    });
-});
-// ---------------------------------------------------------------------------
-// Component tests
-// ---------------------------------------------------------------------------
-describe('CaseFolderContextMenu', () => {
-    describe('renders children', () => {
-        it('renders children content', () => {
-            renderMenu({ leaf: hitLeaf });
-            expect(screen.getByTestId('child')).toBeInTheDocument();
-        });
-    });
-    describe('menu items for leaf types', () => {
-        it('shows "Open item" and "Remove item" for a hit leaf', () => {
-            renderMenu({ leaf: hitLeaf });
-            expect(screen.getByTestId('open-item')).toBeInTheDocument();
-            expect(screen.getByTestId('remove-item')).toBeInTheDocument();
-        });
-        it('shows "Open item" and "Remove item" for a reference leaf', () => {
-            renderMenu({ leaf: referenceLeaf });
-            expect(screen.getByTestId('open-item')).toBeInTheDocument();
-            expect(screen.getByTestId('remove-item')).toBeInTheDocument();
-        });
-        it('shows "Open item" and "Remove item" for an observable leaf', () => {
-            renderMenu({ leaf: observableLeaf });
-            expect(screen.getByTestId('open-item')).toBeInTheDocument();
-            expect(screen.getByTestId('remove-item')).toBeInTheDocument();
-        });
-        it('shows "Open item" and "Remove item" for a case leaf', () => {
-            renderMenu({ leaf: caseLeaf });
-            expect(screen.getByTestId('open-item')).toBeInTheDocument();
-            expect(screen.getByTestId('remove-item')).toBeInTheDocument();
-        });
-        it('shows only "Remove item" for a table leaf (no open URL)', () => {
-            renderMenu({ leaf: tableLeaf });
-            expect(screen.queryByTestId('open-item')).not.toBeInTheDocument();
-            expect(screen.getByTestId('remove-item')).toBeInTheDocument();
-        });
-        it('shows only "Remove item" for a lead leaf (no open URL)', () => {
-            renderMenu({ leaf: leadLeaf });
-            expect(screen.queryByTestId('open-item')).not.toBeInTheDocument();
-            expect(screen.getByTestId('remove-item')).toBeInTheDocument();
-        });
-        it('labels the remove button "Remove item" for a leaf', () => {
-            renderMenu({ leaf: hitLeaf });
-            expect(screen.getByTestId('remove-item')).toHaveTextContent('page.cases.sidebar.item.remove');
-        });
-        it('shows a divider for all leaf types (between leaf actions and remove)', () => {
-            const { container: withOpen } = renderMenu({ leaf: hitLeaf });
-            expect(withOpen.querySelector('hr')).not.toBeNull();
-            const { container: withoutOpen } = renderMenu({ leaf: tableLeaf });
-            expect(withoutOpen.querySelector('hr')).not.toBeNull();
-            const { container: withFolder } = renderMenu({ tree: { path: 'folder', leaves: [hitLeaf] } });
-            expect(withFolder.querySelector('hr')).toBeNull();
-        });
-    });
-    describe('menu items for folders', () => {
-        const folderTree = { path: 'folder', leaves: [hitLeaf, referenceLeaf] };
-        it('shows only "Remove folder" for a folder (no open URL)', () => {
-            renderMenu({ tree: folderTree });
-            expect(screen.queryByTestId('open-item')).not.toBeInTheDocument();
-            expect(screen.getByTestId('remove-item')).toBeInTheDocument();
-        });
-        it('labels the remove button "Remove folder" for a tree', () => {
-            renderMenu({ tree: folderTree });
-            expect(screen.getByTestId('remove-item')).toHaveTextContent('page.cases.sidebar.folder.remove');
-        });
-    });
-    describe('"Open item" action', () => {
-        it('calls window.open with the hit URL', () => {
-            renderMenu({ leaf: hitLeaf });
-            act(() => {
-                fireEvent.click(screen.getByTestId('open-item'));
-            });
-            expect(window.open).toHaveBeenCalledWith('/hits/hit-123', '_blank', 'noopener noreferrer');
-        });
-        it('calls window.open with the reference URL directly', () => {
-            renderMenu({ leaf: referenceLeaf });
-            act(() => {
-                fireEvent.click(screen.getByTestId('open-item'));
-            });
-            expect(window.open).toHaveBeenCalledWith('https://example.com', '_blank', 'noopener noreferrer');
-        });
-        it('calls window.open with the observable URL', () => {
-            renderMenu({ leaf: observableLeaf });
-            act(() => {
-                fireEvent.click(screen.getByTestId('open-item'));
-            });
-            expect(window.open).toHaveBeenCalledWith('/observables/obs-456', '_blank', 'noopener noreferrer');
-        });
-        it('calls window.open with the case URL', () => {
-            renderMenu({ leaf: caseLeaf });
-            act(() => {
-                fireEvent.click(screen.getByTestId('open-item'));
-            });
-            expect(window.open).toHaveBeenCalledWith('/cases/nested-case-id', '_blank', 'noopener noreferrer');
-        });
-    });
-    describe('"Remove item" action for a leaf', () => {
-        it('calls dispatchApi with the delete call for the leaf', async () => {
-            renderMenu({ leaf: hitLeaf });
-            act(() => {
-                fireEvent.click(screen.getByTestId('remove-item'));
-            });
-            await waitFor(() => {
-                expect(mockDel).toHaveBeenCalledWith('case-1', ['hit-123']);
-            });
-        });
-        it('calls onUpdate with the updated case after the delete resolves', async () => {
-            const onUpdate = vi.fn();
-            renderMenu({ leaf: hitLeaf, onUpdate: onUpdate });
-            act(() => {
-                fireEvent.click(screen.getByTestId('remove-item'));
-            });
-            await waitFor(() => {
-                expect(onUpdate).toHaveBeenCalledWith(mockCase);
-            });
-        });
-        it('does not call the API when case_id is missing', () => {
-            renderMenu({ _case: { title: 'No ID' }, leaf: hitLeaf });
-            act(() => {
-                fireEvent.click(screen.getByTestId('remove-item'));
-            });
-            expect(mockDel).not.toHaveBeenCalled();
-        });
-        it('skips items with no value', async () => {
-            const noValueLeaf = { type: 'hit', path: 'folder/no-value' };
-            renderMenu({ leaf: noValueLeaf });
-            act(() => {
-                fireEvent.click(screen.getByTestId('remove-item'));
-            });
-            await waitFor(() => {
-                expect(mockDel).not.toHaveBeenCalled();
-            });
-        });
-    });
-    describe('"Rename item" action', () => {
-        it('shows "Rename item" entry for a hit leaf', () => {
-            renderMenu({ leaf: hitLeaf });
-            expect(screen.getByTestId('rename-item')).toBeInTheDocument();
-        });
-        it('shows "Rename item" for a table leaf', () => {
-            renderMenu({ leaf: tableLeaf });
-            expect(screen.getByTestId('rename-item')).toBeInTheDocument();
-        });
-        it('does not show "Rename item" for a folder', () => {
-            renderMenu({ tree: { path: 'folder', leaves: [hitLeaf] } });
-            expect(screen.queryByTestId('rename-item')).not.toBeInTheDocument();
-        });
-        it('calls showModal when "Rename item" is clicked', () => {
-            renderMenu({ leaf: hitLeaf });
-            act(() => {
-                fireEvent.click(screen.getByTestId('rename-item'));
-            });
-            expect(mockShowModal).toHaveBeenCalledTimes(1);
-        });
-        it('passes the current case and leaf to the rename modal', () => {
-            const onUpdate = vi.fn();
-            renderMenu({ leaf: hitLeaf, onUpdate: onUpdate });
-            act(() => {
-                fireEvent.click(screen.getByTestId('rename-item'));
-            });
-            const [modalElement] = mockShowModal.mock.calls[0];
-            expect(modalElement.props._case).toBe(mockCase);
-            expect(modalElement.props.leaf).toBe(hitLeaf);
-        });
-        it('works fine when onUpdate is not provided', () => {
-            renderMenu({ leaf: hitLeaf });
-            act(() => {
-                fireEvent.click(screen.getByTestId('rename-item'));
-            });
-            expect(mockShowModal).toHaveBeenCalledTimes(1);
-        });
-    });
-    describe('"Remove folder" action', () => {
-        it('calls dispatchApi with all leaf values in a single batch call', async () => {
-            const folderTree = { path: 'folder', leaves: [hitLeaf, referenceLeaf] };
-            renderMenu({ tree: folderTree });
-            act(() => {
-                fireEvent.click(screen.getByTestId('remove-item'));
-            });
-            await waitFor(() => {
-                expect(mockDel).toHaveBeenCalledWith('case-1', ['hit-123', 'https://example.com']);
-                expect(mockDel).toHaveBeenCalledTimes(1);
-            });
-        });
-        it('calls dispatchApi with leaves from nested subfolders in a single batch call', async () => {
-            const nestedTree = {
-                path: 'folder',
-                leaves: [hitLeaf],
-                folders: {
-                    subfolder: { path: 'folder/subfolder', leaves: [referenceLeaf] }
-                }
-            };
-            renderMenu({ tree: nestedTree });
-            act(() => {
-                fireEvent.click(screen.getByTestId('remove-item'));
-            });
-            await waitFor(() => {
-                expect(mockDel).toHaveBeenCalledWith('case-1', expect.arrayContaining(['hit-123', 'https://example.com']));
-                expect(mockDel).toHaveBeenCalledTimes(1);
-            });
-        });
-        it('calls onUpdate with the updated case after deletion', async () => {
-            const onUpdate = vi.fn();
-            const folderTree = { path: 'folder', leaves: [hitLeaf, referenceLeaf] };
-            renderMenu({ tree: folderTree, onUpdate: onUpdate });
-            act(() => {
-                fireEvent.click(screen.getByTestId('remove-item'));
-            });
-            await waitFor(() => {
-                expect(onUpdate).toHaveBeenCalledWith(mockCase);
-            });
-        });
-        it('does not call the API or onUpdate for an empty folder', () => {
-            const onUpdate = vi.fn();
-            renderMenu({ tree: { path: 'folder', leaves: [] }, onUpdate: onUpdate });
-            act(() => {
-                fireEvent.click(screen.getByTestId('remove-item'));
-            });
-            expect(mockDel).not.toHaveBeenCalled();
-            expect(onUpdate).not.toHaveBeenCalled();
-        });
-    });
-});

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

@@ -1,25 +0,0 @@
-import type { SvgIconProps } from '@mui/material';
-import type { Item } from '@cccsaurora/howler-ui/models/entities/generated/Item';
-import { type FC } from 'react';
-import type { Tree } from './types';
-interface FolderEntryProps {
-    caseId?: string | null;
-    path: string;
-    /** MUI `pl` value for indentation */
-    indent: number;
-    /** Text displayed as the entry label */
-    label: string;
-    /** MUI icon color token applied to the entry icon (default: 'inherit') */
-    iconColor?: SvgIconProps['color'];
-    /** MUI color token for the label Typography (default: 'text.secondary') */
-    labelColor?: string;
-    /** Whether the chevron is rotated 90° (expanded state) */
-    chevronOpen?: boolean;
-    /** When provided the entry renders as a react-router Link */
-    to?: string;
-    onClick?: () => void;
-    itemType: string;
-    entry?: Item | Tree;
-}
-declare const FolderEntry: FC<FolderEntryProps>;
-export default FolderEntry;

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

@@ -1,88 +0,0 @@
-import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-import { useDraggable, useDroppable } from '@dnd-kit/core';
-import { CSS } from '@dnd-kit/utilities';
-import { BookRounded, CheckCircle, ChevronRight, Folder, Lightbulb, Link as LinkIcon, TableChart, Visibility } from '@mui/icons-material';
-import { alpha, Box, Stack, Typography, useTheme } from '@mui/material';
-import {} from 'react';
-import { Link, useLocation } from 'react-router-dom';
-// Static map: item type → MUI icon component (avoids re-creating closures on each render)
-const ICON_FOR_TYPE = {
-    folder: Folder,
-    case: BookRounded,
-    observable: Visibility,
-    hit: CheckCircle,
-    table: TableChart,
-    lead: Lightbulb,
-    reference: LinkIcon
-};
-const FolderEntry = ({ caseId, path, indent, label, itemType, iconColor = 'disabled', labelColor = 'text.secondary', chevronOpen = false, to, onClick, entry }) => {
-    const location = useLocation();
-    const theme = useTheme();
-    const isCase = itemType === 'case';
-    const isFolder = itemType === 'folder';
-    const dndId = `${caseId ?? ''}:${itemType}:${path}`;
-    const { attributes, listeners, setNodeRef: setDraggableNodeRef, transform, isDragging } = useDraggable({
-        id: dndId,
-        data: {
-            type: itemType,
-            label,
-            entry,
-            caseId
-        },
-        disabled: !caseId
-    });
-    const { setNodeRef: setDroppableNodeRef, isOver } = useDroppable({
-        id: dndId,
-        disabled: !isFolder || isDragging || !caseId,
-        data: {
-            path,
-            caseId
-        }
-    });
-    const isLink = to != null && !isDragging;
-    const active = decodeURIComponent(location.pathname) === to;
-    const Icon = ICON_FOR_TYPE[itemType] ?? Folder;
-    return (_jsxs(Stack, { ref: el => {
-            setDroppableNodeRef(el);
-            setDraggableNodeRef(el);
-        }, direction: "row", pl: indent, style: { transform: CSS.Transform.toString(transform), opacity: isDragging ? 0 : undefined }, sx: [
-            {
-                cursor: 'pointer',
-                overflow: 'visible',
-                color: `${theme.palette.text.secondary} !important`,
-                textDecoration: 'none',
-                background: 'transparent',
-                position: 'relative',
-                ...(isLink && { borderRight: '3px solid transparent' })
-            },
-            isLink &&
-                active && {
-                background: alpha(theme.palette.grey[600], 0.15),
-                borderRightColor: theme.palette.primary.main
-            }
-        ], onClick: onClick, ...attributes, ...listeners, ...(isLink && {
-            component: Link,
-            to,
-            target: itemType === 'reference' ? '_blank' : undefined,
-            rel: itemType === 'reference' ? 'noopener noreferrer' : undefined
-        }), children: [_jsx(Box, { sx: [
-                    {
-                        position: 'absolute',
-                        top: 0,
-                        bottom: 0,
-                        left: 0,
-                        right: 0,
-                        border: '2px dashed transparent',
-                        borderRadius: '5px',
-                        transition: theme.transitions.create('border-color')
-                    },
-                    isOver && caseId && { borderColor: theme.palette.primary.main }
-                ] }), _jsx(ChevronRight, { fontSize: "small", color: "disabled", sx: [
-                    !(isCase || isFolder) && { opacity: 0 },
-                    {
-                        transition: theme.transitions.create('transform', { duration: 100 }),
-                        transform: chevronOpen ? 'rotate(90deg)' : 'rotate(0deg)'
-                    }
-                ] }), _jsx(Icon, { fontSize: "small", color: iconColor }), _jsx(Typography, { variant: "caption", color: labelColor, sx: { userSelect: 'none', pl: 0.5, textWrap: 'nowrap' }, children: label })] }));
-};
-export default FolderEntry;

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

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