@cccsaurora/howler-ui 3.1.0-dev.1656 → 3.1.0-dev.1675

package/components/routes/views/Views.test.js

@@ -0,0 +1,247 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+/// <reference types="vitest" />
+import { fireEvent, render, screen, waitFor } from '@testing-library/react';
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+const mockShowSuccessMessage = vi.hoisted(() => vi.fn());
+const mockNavigate = vi.hoisted(() => vi.fn());
+const mockSetSearchParams = vi.hoisted(() => vi.fn());
+const mockLoad = vi.hoisted(() => vi.fn());
+const mockRequest = vi.hoisted(() => vi.fn());
+const mockRemove = vi.hoisted(() => vi.fn());
+const mockGetSearchRequestData = vi.hoisted(() => vi.fn((data) => ({ offset: data.offset })));
+const mockAddFavourite = vi.hoisted(() => vi.fn());
+const mockRemoveFavourite = vi.hoisted(() => vi.fn());
+const mockRemoveView = vi.hoisted(() => vi.fn());
+const mockFetchViews = vi.hoisted(() => vi.fn(async () => undefined));
+const mockSetDefaultView = vi.hoisted(() => vi.fn());
+const modalContextToken = vi.hoisted(() => ({ name: 'modal-context' }));
+const viewContextToken = vi.hoisted(() => ({ name: 'view-context' }));
+const listMethodContextToken = vi.hoisted(() => ({ name: 'list-method-context' }));
+let searchParamsValue = new URLSearchParams();
+let responseValue = {
+    total: 2,
+    items: [
+        { view_id: 'view-1', title: 'Alpha', query: 'status:open', type: 'global', owner: 'demo', admins: [], members: [] },
+        {
+            view_id: 'view-2',
+            title: 'Bravo',
+            query: 'status:closed',
+            type: 'personal',
+            owner: 'other',
+            admins: ['demo'],
+            members: []
+        }
+    ]
+};
+let appUserValue = {
+    user: { username: 'demo', favourite_views: ['view-1'], is_admin: false }
+};
+let viewContextValue = {
+    fetchViews: mockFetchViews,
+    addFavourite: mockAddFavourite,
+    removeFavourite: mockRemoveFavourite,
+    removeView: mockRemoveView,
+    views: {
+        'view-1': { view_id: 'view-1', title: 'Alpha', query: 'status:open' },
+        'view-2': { view_id: 'view-2', title: 'Bravo', query: 'status:closed' }
+    },
+    defaultView: 'view-1',
+    setDefaultView: mockSetDefaultView
+};
+vi.mock('@mui/icons-material', async (importOriginal) => {
+    const actual = await importOriginal();
+    return {
+        ...actual,
+        Clear: () => _jsx("div", { children: "clear-icon" }),
+        Edit: () => _jsx("div", { children: "edit-icon" }),
+        SavedSearch: () => _jsx("div", { children: "saved-search-icon" }),
+        Star: () => _jsx("div", { children: "star" }),
+        StarBorder: () => _jsx("div", { children: "star-border" })
+    };
+});
+vi.mock('@mui/material', () => ({
+    Autocomplete: ({ onOpen, onChange }) => (_jsxs("div", { children: [_jsx("button", { onClick: () => onOpen?.(), children: "open-default" }), _jsx("button", { onClick: () => onChange?.(null, { view_id: 'view-2' }), children: "change-default" })] })),
+    Card: ({ children }) => _jsx("div", { children: children }),
+    Checkbox: ({ onChange }) => _jsx("button", { onClick: () => onChange?.(null, true), children: "toggle-favourites" }),
+    IconButton: ({ children, onClick }) => _jsx("button", { onClick: onClick, children: children }),
+    Skeleton: () => _jsx("div", { children: "loading" }),
+    Stack: ({ children }) => _jsx("div", { children: children }),
+    TextField: () => _jsx("div", { children: "text-field" }),
+    ToggleButton: ({ children }) => _jsx("button", { children: children }),
+    ToggleButtonGroup: ({ children, onChange }) => (_jsxs("div", { children: [_jsx("button", { onClick: () => onChange?.(null, 'personal'), children: "filter-personal" }), _jsx("button", { onClick: () => onChange?.(null, undefined), children: "filter-none" }), children] })),
+    Tooltip: ({ children }) => _jsx("div", { children: children }),
+    Typography: ({ children }) => _jsx("div", { children: children })
+}));
+vi.mock('@tui/core', () => ({
+    useAppUser: () => appUserValue
+}));
+vi.mock('api', () => ({
+    default: {
+        search: {
+            view: {
+                post: 'view-search'
+            }
+        }
+    }
+}));
+vi.mock('components/app/providers/ModalProvider', () => ({
+    ModalContext: modalContextToken
+}));
+vi.mock('components/app/providers/SearchResponseProvider', () => ({
+    __esModule: true,
+    default: ({ children }) => _jsx("div", { children: children }),
+    createSearchResponseContext: () => ({}),
+    useSearchResponseContext: () => ({
+        response: responseValue,
+        request: mockRequest,
+        remove: mockRemove,
+        getSearchRequestData: mockGetSearchRequestData
+    })
+}));
+vi.mock('components/app/providers/ViewProvider', () => ({
+    ViewContext: viewContextToken
+}));
+vi.mock('components/elements/addons/layout/FlexOne', () => ({
+    default: () => _jsx("div", { children: "flex" })
+}));
+vi.mock('components/elements/addons/lists', () => ({
+    TuiListProvider: ({ children }) => _jsx("div", { children: children })
+}));
+vi.mock('components/elements/addons/lists/TuiListProvider', () => ({
+    TuiListMethodContext: listMethodContextToken
+}));
+vi.mock('components/elements/display/ItemManager', () => ({
+    default: (props) => (_jsxs("div", { children: [_jsx("button", { onClick: () => props.onSearch(), children: "search" }), _jsx("button", { onClick: () => props.onPageChange(25), children: "page" }), _jsx("button", { onClick: () => props.onCreate(), children: "create" }), _jsx("div", { children: props.searchFilters }), _jsx("div", { children: props.afterSearch }), _jsx("div", { children: props.belowSearch }), props.response?.items?.map((item) => (_jsx("div", { children: props.renderer({ item: { item } }, () => 'card') }, item.view_id)))] }))
+}));
+vi.mock('components/elements/membership/Members', () => ({
+    default: ({ item }) => _jsx("div", { children: `members:${item.view_id}` })
+}));
+vi.mock('components/elements/view/ViewTitle', () => ({
+    ViewTitle: ({ title }) => _jsx("div", { children: title })
+}));
+vi.mock('components/hooks/useMyLocalStorage', () => ({
+    useMyLocalStorageItem: () => [25]
+}));
+vi.mock('components/hooks/useMySnackbar', () => ({
+    default: () => ({ showSuccessMessage: mockShowSuccessMessage })
+}));
+vi.mock('react-i18next', () => ({
+    useTranslation: () => ({ t: (key) => key })
+}));
+vi.mock('react-router', () => ({
+    Link: ({ children }) => _jsx("div", { children: children }),
+    useNavigate: () => mockNavigate,
+    useSearchParams: () => [searchParamsValue, mockSetSearchParams]
+}));
+vi.mock('use-context-selector', () => ({
+    useContextSelector: (_context, selector) => selector(viewContextValue)
+}));
+vi.mock('utils/viewUtils', () => ({
+    buildViewUrl: (view) => `/views/${view.view_id}`
+}));
+vi.mock('react', async (importOriginal) => {
+    const actual = await importOriginal();
+    return {
+        ...actual,
+        useContext: (context) => {
+            if (context === modalContextToken) {
+                return { withConfirmDeleteModal: async (fn) => fn() };
+            }
+            if (context === listMethodContextToken) {
+                return { load: mockLoad };
+            }
+            return actual.useContext(context);
+        }
+    };
+});
+import Views from './Views';
+describe('Views', () => {
+    beforeEach(() => {
+        searchParamsValue = new URLSearchParams();
+        responseValue = {
+            total: 2,
+            items: [
+                {
+                    view_id: 'view-1',
+                    title: 'Alpha',
+                    query: 'status:open',
+                    type: 'global',
+                    owner: 'demo',
+                    admins: [],
+                    members: []
+                },
+                {
+                    view_id: 'view-2',
+                    title: 'Bravo',
+                    query: 'status:closed',
+                    type: 'personal',
+                    owner: 'other',
+                    admins: ['demo'],
+                    members: []
+                }
+            ]
+        };
+        appUserValue = { user: { username: 'demo', favourite_views: ['view-1'], is_admin: false } };
+        viewContextValue = {
+            fetchViews: mockFetchViews,
+            addFavourite: mockAddFavourite,
+            removeFavourite: mockRemoveFavourite,
+            removeView: mockRemoveView,
+            views: {
+                'view-1': { view_id: 'view-1', title: 'Alpha', query: 'status:open' },
+                'view-2': { view_id: 'view-2', title: 'Bravo', query: 'status:closed' }
+            },
+            defaultView: 'view-1',
+            setDefaultView: mockSetDefaultView
+        };
+        mockShowSuccessMessage.mockReset();
+        mockNavigate.mockReset();
+        mockSetSearchParams.mockReset();
+        mockLoad.mockReset();
+        mockRequest.mockReset();
+        mockRemove.mockReset();
+        mockGetSearchRequestData.mockClear();
+        mockAddFavourite.mockReset();
+        mockRemoveFavourite.mockReset();
+        mockRemoveView.mockReset();
+        mockFetchViews.mockClear();
+        mockSetDefaultView.mockReset();
+    });
+    it('searches, paginates, filters, and manages favourites/default view', async () => {
+        render(_jsx(Views, {}));
+        await waitFor(() => expect(mockRequest).toHaveBeenCalledWith('view-search', {
+            query: '(title:* OR query:* OR sort:* OR type:* OR owner:*) AND (type:global OR owner:(demo OR none) OR admins:demo OR members:demo) AND type:(*)',
+            rows: 25,
+            offset: 0
+        }));
+        expect(mockLoad).toHaveBeenCalledWith([
+            expect.objectContaining({ id: 'view-1' }),
+            expect.objectContaining({ id: 'view-2' })
+        ]);
+        fireEvent.click(screen.getByText('filter-personal'));
+        await waitFor(() => expect(mockRequest).toHaveBeenLastCalledWith('view-search', expect.objectContaining({
+            query: expect.stringContaining('type:(personal OR readonly)')
+        })));
+        fireEvent.click(screen.getByText('page'));
+        expect(mockSetSearchParams).toHaveBeenCalled();
+        fireEvent.click(screen.getByText('filter-none'));
+        expect(screen.getByText('route.views.manager.favourites')).toBeInTheDocument();
+        fireEvent.click(screen.getByText('open-default'));
+        await waitFor(() => expect(mockFetchViews).toHaveBeenCalled());
+        fireEvent.click(screen.getByText('change-default'));
+        expect(mockSetDefaultView).toHaveBeenCalledWith('view-2');
+        fireEvent.click(screen.getByText('star'));
+        await waitFor(() => expect(mockRemoveFavourite).toHaveBeenCalledWith('view-1'));
+        fireEvent.click(screen.getByText('star-border'));
+        await waitFor(() => expect(mockAddFavourite).toHaveBeenCalledWith('view-2'));
+    });
+    it('creates, deletes, and shows success feedback', async () => {
+        render(_jsx(Views, {}));
+        fireEvent.click(screen.getByText('create'));
+        expect(mockNavigate).toHaveBeenCalledWith('/views/create');
+        fireEvent.click(screen.getAllByText('clear-icon')[0]);
+        await waitFor(() => expect(mockRemoveView).toHaveBeenCalledWith('view-1'));
+        expect(mockRemove).toHaveBeenCalledWith('view-1');
+        expect(mockShowSuccessMessage).toHaveBeenCalledWith('route.views.manager.delete.success');
+    });
+});

package/package.json

@@ -38,7 +38,7 @@
     "chartjs-adapter-dayjs-4": "^1.0.4",
     "chartjs-plugin-zoom": "^2.2.0",
     "dayjs": "^1.11.23",
-    "dompurify": "^3.4.15",
+    "dompurify": "^3.4.16",
     "flat": "^6.0.1",
     "fuse.js": "^7.5.0",
     "handlebars": "^4.7.9",
@@ -97,7 +97,7 @@
     "url": "https://github.com/CybercentreCanada/howler"
   },
   "type": "module",
-  "version": "3.1.0-dev.1656",
+  "version": "3.1.0-dev.1675",
   "exports": {
     "./i18n": "./i18n.js",
     "./index.css": "./index.css",

package/plugins/HowlerPlugin.test.d.ts

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

package/plugins/HowlerPlugin.test.js

@@ -0,0 +1,103 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+const mockHowlerPluginStore = vi.hoisted(() => ({
+    addAdminMenuItem: vi.fn(),
+    addLead: vi.fn(),
+    addMainMenuOperation: vi.fn(),
+    addOperation: vi.fn(),
+    addPivot: vi.fn(),
+    addRoute: vi.fn(),
+    addUserMenuItem: vi.fn()
+}));
+vi.mock('./store', () => ({
+    default: mockHowlerPluginStore
+}));
+vi.mock('@cccsaurora/howler-ui/i18n', () => ({
+    default: { language: 'en' }
+}));
+import HowlerPlugin from './HowlerPlugin';
+class TestPlugin extends HowlerPlugin {
+    name = 'demo';
+    version = '1.2.3';
+    author = 'copilot';
+    description = 'test plugin';
+    localization = vi.fn();
+    provider = vi.fn(() => null);
+}
+describe('HowlerPlugin', () => {
+    const addFunction = vi.fn();
+    const removeFunction = vi.fn();
+    let plugin;
+    beforeEach(() => {
+        vi.clearAllMocks();
+        plugin = new TestPlugin();
+        plugin.init({ addFunction, removeFunction });
+    });
+    afterEach(() => {
+        vi.restoreAllMocks();
+    });
+    it('formats the plugin name with its version', () => {
+        expect(plugin.getPluginName()).toBe('demo@1.2.3');
+        expect(plugin.getDependencies()).toEqual([]);
+    });
+    it('registers extension hooks and calls localization on activation', () => {
+        plugin.activate();
+        expect(addFunction).toHaveBeenCalledWith('demo.provider', expect.any(Function));
+        expect(addFunction).toHaveBeenCalledWith('demo.localization', expect.any(Function));
+        expect(plugin.localization).toHaveBeenCalledWith({ language: 'en' });
+    });
+    it('removes registered extension hooks on deactivation', () => {
+        plugin.activate();
+        plugin.deactivate();
+        expect(removeFunction).toHaveBeenCalledWith('demo.provider');
+        expect(removeFunction).toHaveBeenCalledWith('demo.localization');
+    });
+    it('adds lead renderers and forms when the lead format is available', () => {
+        mockHowlerPluginStore.addLead.mockReturnValue(true);
+        const renderer = vi.fn();
+        const form = vi.fn();
+        plugin.addLead('markdown', form, renderer);
+        expect(mockHowlerPluginStore.addLead).toHaveBeenCalledWith('markdown');
+        expect(addFunction).toHaveBeenCalledWith('lead.markdown', renderer);
+        expect(addFunction).toHaveBeenCalledWith('lead.markdown.form', form);
+    });
+    it('skips duplicate lead formats', () => {
+        mockHowlerPluginStore.addLead.mockReturnValue(false);
+        const errorSpy = vi.spyOn(console, 'error').mockImplementation(() => undefined);
+        plugin.addLead('markdown', vi.fn(), vi.fn());
+        expect(addFunction).not.toHaveBeenCalledWith('lead.markdown', expect.any(Function));
+        expect(errorSpy).toHaveBeenCalledWith('Lead format markdown already configured, not enabling for plugin demo@1.2.3');
+    });
+    it('adds pivots, routes, menu items, and operations through the plugin store', () => {
+        mockHowlerPluginStore.addPivot.mockReturnValue(true);
+        mockHowlerPluginStore.addOperation.mockReturnValue(true);
+        const element = { type: 'icon' };
+        plugin.addPivot('link', vi.fn(), vi.fn());
+        plugin.addUserMenuItem('menu.user', '/me', element);
+        plugin.addAdminMenuItem('menu.admin', '/admin', element);
+        plugin.addRoute('custom', element, []);
+        plugin.addMainMenuItem({ type: 'append', parentId: 'root', item: { id: 'new-item' } });
+        plugin.addOperation('custom', vi.fn(), { title: 'Docs', description: 'Help' });
+        expect(mockHowlerPluginStore.addPivot).toHaveBeenCalledWith('link');
+        expect(addFunction).toHaveBeenCalledWith('pivot.link', expect.any(Function));
+        expect(addFunction).toHaveBeenCalledWith('pivot.link.form', expect.any(Function));
+        expect(mockHowlerPluginStore.addUserMenuItem).toHaveBeenCalledWith({
+            i18nKey: 'menu.user',
+            route: '/me',
+            icon: element
+        });
+        expect(mockHowlerPluginStore.addAdminMenuItem).toHaveBeenCalledWith({
+            i18nKey: 'menu.admin',
+            route: '/admin',
+            icon: element
+        });
+        expect(mockHowlerPluginStore.addRoute).toHaveBeenCalledWith({ path: 'custom', element, children: [] });
+        expect(mockHowlerPluginStore.addMainMenuOperation).toHaveBeenCalledWith({
+            type: 'append',
+            parentId: 'root',
+            item: { id: 'new-item' }
+        });
+        expect(mockHowlerPluginStore.addOperation).toHaveBeenCalledWith('custom');
+        expect(addFunction).toHaveBeenCalledWith('operation.custom', expect.any(Function));
+        expect(addFunction).toHaveBeenCalledWith('operation.custom.documentation', expect.any(Function));
+    });
+});

package/plugins/clue/components/ClueChip.js

@@ -1,12 +1,12 @@
 import { jsx as _jsx } from "react/jsx-runtime";
 import EnrichedChip from '@cccsaurora/clue-ui/components/EnrichedChip';
 import { Chip } from '@mui/material';
-import { memo } from 'react';
+import { createElement, memo } from 'react';
 import { useType } from '../utils';
 const ClueChip = ({ children, value, context, field, hit, ...props }) => {
     const type = useType(hit, field, value);
     if (!type) {
-        return _jsx(Chip, { ...props, children: children });
+        return createElement(Chip, { ...props, children });
     }
     let enrichedProps = {
         ...props,

package/plugins/clue/helpers.test.d.ts

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

package/plugins/clue/helpers.test.js

@@ -0,0 +1,100 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+/// <reference types="vitest" />
+import { fireEvent, render, screen } from '@testing-library/react';
+import { describe, expect, it, vi } from 'vitest';
+const mockGuessType = vi.hoisted(() => vi.fn());
+vi.mock('@cccsaurora/clue-ui/components/EnrichedTypography', () => ({
+    default: ({ type, value }) => _jsx("div", { children: `${type}:${value}` })
+}));
+vi.mock('@cccsaurora/clue-ui/components/fetchers/Fetcher', () => ({
+    default: ({ fetcherId, type, value }) => _jsx("div", { children: `${fetcherId}:${type}:${value}` })
+}));
+vi.mock('@cccsaurora/clue-ui/components/group/Entry', () => ({
+    default: ({ children, entry, selected }) => (_jsxs("div", { children: [`${entry}:${selected}`, children] }))
+}));
+vi.mock('@cccsaurora/clue-ui/components/group/Group', () => ({
+    default: ({ children, type }) => (_jsxs("div", { children: [`${type}-group`, children] }))
+}));
+vi.mock('@cccsaurora/clue-ui/hooks/selectors', () => ({
+    useClueEnrichSelector: () => mockGuessType
+}));
+vi.mock('@mui/material', () => ({
+    Checkbox: ({ checked, onChange }) => (_jsx("input", { "aria-label": "checkbox", checked: checked, onChange: event => onChange(event, !checked), type: "checkbox" })),
+    Paper: ({ children }) => _jsx("div", { children: children }),
+    Stack: ({ children }) => _jsx("div", { children: children }),
+    Table: ({ children }) => _jsx("table", { children: children }),
+    TableBody: ({ children }) => _jsx("tbody", { children: children }),
+    TableCell: ({ children }) => _jsx("td", { children: children }),
+    TableHead: ({ children }) => _jsx("thead", { children: children }),
+    TableRow: ({ children }) => _jsx("tr", { children: children })
+}));
+vi.mock('components/elements/addons/layout/FlexOne', () => ({
+    default: () => _jsx("div", { children: "flex" })
+}));
+vi.mock('@cccsaurora/howler-ui/i18n', () => ({
+    default: {
+        t: (key) => key
+    }
+}));
+vi.mock('react-i18next', () => ({
+    useTranslation: () => ({ t: (key) => key })
+}));
+import HELPERS from './helpers';
+describe('clue helpers', () => {
+    it('renders clue helper errors and enriched values', () => {
+        const clue = HELPERS.find(entry => entry.keyword === 'clue');
+        render(clue.componentCallback?.(null, 'value'));
+        expect(screen.getByText('markdown.error')).toBeInTheDocument();
+        expect(screen.getByText('markdown.helpers.clue.arguments')).toBeInTheDocument();
+        mockGuessType.mockReturnValue('ip');
+        const { rerender } = render(clue.componentCallback?.('guess', '1.2.3.4'));
+        expect(screen.getByText('ip:1.2.3.4')).toBeInTheDocument();
+        mockGuessType.mockImplementation(() => {
+            throw new Error('bad selector');
+        });
+        rerender(clue.componentCallback?.('guess', 'broken'));
+        expect(screen.getByText('Error: bad selector')).toBeInTheDocument();
+    });
+    it('renders fetcher and clue group helper states', () => {
+        const fetcher = HELPERS.find(entry => entry.keyword === 'fetcher');
+        const clueGroup = HELPERS.find(entry => entry.keyword === 'clue_group');
+        const errorSpy = vi.spyOn(console, 'error').mockImplementation(() => undefined);
+        const { rerender } = render(fetcher.componentCallback?.({}, { hash: {} }));
+        expect(screen.getByText(/markdown.props.missing/)).toHaveTextContent('markdown.props.missing: type, value, fetcherId');
+        expect(errorSpy).toHaveBeenCalledWith('Missing required props for fetcher helper');
+        rerender(fetcher.componentCallback?.({}, { hash: { type: 'ip', value: '1.2.3.4', fetcherId: 'eml-lookup' } }));
+        expect(screen.getByText('email-lookup:ip:1.2.3.4')).toBeInTheDocument();
+        rerender(clueGroup.componentCallback?.('bad', { hash: {} }));
+        expect(screen.getByText(/markdown.props.missing/)).toHaveTextContent('markdown.props.missing: values, type');
+        rerender(clueGroup.componentCallback?.(['one', 'one', 'two'], { hash: { type: 'domain' } }));
+        expect(screen.getByText('domain-group')).toBeInTheDocument();
+        expect(screen.getByText('one:false')).toBeInTheDocument();
+        expect(screen.getByText('two:false')).toBeInTheDocument();
+        fireEvent.click(screen.getAllByLabelText('checkbox')[0]);
+        expect(screen.getByText('one:true')).toBeInTheDocument();
+    });
+    it('renders clue tables with enrichers, fetchers, and selection checkboxes', () => {
+        const clueTable = HELPERS.find(entry => entry.keyword === 'clue_table');
+        mockGuessType.mockReturnValue(undefined);
+        render(clueTable.componentCallback?.([
+            { column: 'entity_name', row: '1', value: 'alpha', clue_type: 'guess', clue_entity: true, action_value: 'A' },
+            {
+                column: 'entity_type',
+                row: '1',
+                value: '1.2.3.4',
+                clue_type: 'ip',
+                clue_fetcher: 'geo',
+                fetcher_width: '100px'
+            },
+            { column: 'notes', row: '2', value: 'freeform' }
+        ], { hash: { clue_action_type: 'ip' } }));
+        expect(screen.getByText('Entity Name')).toBeInTheDocument();
+        expect(screen.getByText('Entity Type')).toBeInTheDocument();
+        expect(screen.getByText('ip-group')).toBeInTheDocument();
+        expect(screen.getByText('geo:ip:1.2.3.4')).toBeInTheDocument();
+        expect(screen.getByText('freeform')).toBeInTheDocument();
+        expect(screen.getByText('A:false')).toBeInTheDocument();
+        fireEvent.click(screen.getAllByLabelText('checkbox')[0]);
+        expect(screen.getByText('A:true')).toBeInTheDocument();
+    });
+});

package/plugins/store.test.d.ts

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

package/plugins/store.test.js

@@ -0,0 +1,53 @@
+/// <reference types="vitest" />
+import { describe, expect, it, vi } from 'vitest';
+const mockInstall = vi.hoisted(() => vi.fn());
+vi.mock('react-pluggable', () => ({
+    Event: class {
+        type;
+        constructor(type) {
+            this.type = type;
+        }
+    },
+    createPluginStore: () => ({ install: mockInstall })
+}));
+describe('plugins/store', () => {
+    it('tracks plugin registration and menu extensions', async () => {
+        vi.resetModules();
+        const { default: store } = await import('./store');
+        const plugin = {
+            name: 'demo',
+            author: 'copilot',
+            getPluginName: () => 'demo@1.0.0'
+        };
+        store.install(plugin);
+        store.install(plugin);
+        expect(store.plugins).toEqual(['demo']);
+        expect(mockInstall).toHaveBeenCalledTimes(1);
+        expect(store.addLead('markdown')).toBe(true);
+        expect(store.addLead('markdown')).toBe(false);
+        expect(store.addPivot('pivot')).toBe(true);
+        expect(store.addPivot('pivot')).toBe(false);
+        expect(store.addOperation('triage')).toBe(true);
+        expect(store.addOperation('triage')).toBe(false);
+        store.addUserMenuItem({ i18nKey: 'user.profile', route: '/profile', icon: {} });
+        store.addAdminMenuItem({ i18nKey: 'admin.users', route: '/admin', icon: {} });
+        store.addMainMenuOperation({ type: 'append', parentId: 'root', item: { id: 'demo' } });
+        store.addRoute({ path: 'custom', element: {}, children: [] });
+        expect(store.leadFormats).toEqual(['markdown']);
+        expect(store.pivotFormats).toEqual(['pivot']);
+        expect(store.operations).toEqual(['triage']);
+        expect(store.userMenuItems).toHaveLength(1);
+        expect(store.adminMenuItems).toHaveLength(1);
+        expect(store.routes).toHaveLength(1);
+        const ops = store.mainMenuOperations;
+        expect(ops).toEqual([{ type: 'append', parentId: 'root', item: { id: 'demo' } }]);
+        ops.push({ type: 'remove', targetId: 'root' });
+        expect(store.mainMenuOperations).toHaveLength(1);
+    });
+    it('stores hit data on emitted hit events', async () => {
+        vi.resetModules();
+        const { HitEvent } = await import('./store');
+        const event = new HitEvent('hit.opened', { id: 'abc123' });
+        expect(event.hit).toEqual({ id: 'abc123' });
+    });
+});

package/utils/classificationParser.test.d.ts

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