@cccsaurora/howler-ui 3.1.0-dev.1697 → 3.1.0-dev.1700

package/components/app/providers/RecordSearchProvider.js

@@ -47,7 +47,7 @@ const RecordSearchProvider = ({ children }) => {
         'howler.id: *': new Date().toISOString()
     });
     const [fzfSearch, setFzfSearch] = useState(false);
-    const filters = useMemo(() => (allFilters ?? []).filter(filter => !filter.endsWith('*')), [allFilters]);
+    const filters = useMemo(() => (allFilters ?? []).filter(filter => filter.startsWith('-') || !filter.endsWith('*')), [allFilters]);
     // On load check to filter out any queries older than one month
     useEffect(() => {
         const filterQueryTime = dayjs().subtract(1, 'month').toISOString();

package/components/app/providers/RecordSearchProvider.test.js

@@ -122,6 +122,15 @@ describe('RecordSearchContext', () => {
         });
     });
     describe('search', () => {
+        it('should retain negated wildcard filters and omit positive placeholders', async () => {
+            mockParameterContext.filters = ['howler.assessment:*', '-howler.assessment:*'];
+            const hook = renderHook(() => useContextSelector(RecordSearchContext, ctx => ctx.getFilters), {
+                wrapper: Wrapper
+            });
+            const filters = await hook.result.current();
+            expect(filters).toContain('-howler.assessment:*');
+            expect(filters).not.toContain('howler.assessment:*');
+        });
         it('should perform a search and update response', async () => {
             const hook = renderHook(() => useContextSelector(RecordSearchContext, ctx => ({
                 search: ctx.search,
@@ -276,6 +285,28 @@ describe('RecordSearchContext', () => {
                 }));
             });
         });
+        it('should forward positive and negative grouped filters without changing their clauses', async () => {
+            mockParameterContext.filters = [
+                'event.provider:"azure"',
+                '-howler.outline.indicators:("a" OR "b")',
+                'event.provider:"\\*"',
+                '-event.provider:"\\*"'
+            ];
+            const hook = renderHook(() => useContextSelector(RecordSearchContext, ctx => ctx.search), { wrapper: Wrapper });
+            act(() => {
+                hook.result.current('test query');
+            });
+            await waitFor(() => {
+                expect(hpost).toHaveBeenCalledWith('/api/v2/search/hit', expect.objectContaining({
+                    filters: expect.arrayContaining([
+                        'event.provider:"azure"',
+                        '-howler.outline.indicators:("a" OR "b")',
+                        'event.provider:"\\*"',
+                        '-event.provider:"\\*"'
+                    ])
+                }));
+            });
+        });
         it('should reset offset if response total is less than current offset', async () => {
             mockParameterContext.offset = 100;
             vi.mocked(hpost).mockResolvedValueOnce({

package/components/elements/record/RecordContextMenu.js

@@ -20,7 +20,6 @@ import React, { useCallback, useContext, useEffect, useMemo, useState } from 're
 import { useTranslation } from 'react-i18next';
 import { usePluginStore } from 'react-pluggable';
 import { useContextSelector } from 'use-context-selector';
-import { DEFAULT_QUERY } from '@cccsaurora/howler-ui/utils/constants';
 import { sanitizeLuceneQuery } from '@cccsaurora/howler-ui/utils/stringUtils';
 import { isHit } from '@cccsaurora/howler-ui/utils/typeUtils';
 /**
@@ -49,8 +48,7 @@ const RecordContextMenu = ({ children, getSelectedId, Component }) => {
     const { showModal } = useContext(ModalContext);
     const pluginStore = usePluginStore();
     const { getMatchingAnalytic, getMatchingTemplate } = useMatchers();
-    const query = useContextSelector(ParameterContext, ctx => ctx?.query);
-    const setQuery = useContextSelector(ParameterContext, ctx => ctx?.setQuery);
+    const addFilter = useContextSelector(ParameterContext, ctx => ctx?.addFilter);
     const [id, setId] = useState(null);
     const record = useContextSelector(RecordContext, ctx => ctx.records[id]);
     const selectedRecords = useContextSelector(RecordContext, ctx => ctx.selectedRecords);
@@ -189,10 +187,10 @@ const RecordContextMenu = ({ children, getSelectedId, Component }) => {
                 }))
             });
             const filterKeys = uniq([
-                ...(template?.keys ?? []),
-                ...Object.keys(record.howler.outline ?? {}).map(key => `howler.outline.${key}`)
+                ...Object.keys(record.howler.outline ?? {}).map(key => `howler.outline.${key}`),
+                ...(template?.keys ?? [])
             ]);
-            if (!isEmpty(filterKeys) && setQuery) {
+            if (!isEmpty(filterKeys) && addFilter) {
                 result.push({ kind: 'divider', id: 'filter-divider' });
                 result.push({
                     kind: 'submenu',
@@ -200,28 +198,31 @@ const RecordContextMenu = ({ children, getSelectedId, Component }) => {
                     icon: _jsx(RemoveCircleOutline, {}),
                     label: t('hit.panel.exclude'),
                     items: filterKeys.flatMap(key => {
-                        let newQuery = '';
-                        if (query !== DEFAULT_QUERY) {
-                            newQuery = `(${query}) AND `;
-                        }
                         const value = get(record, key);
                         if (!value) {
                             return [];
                         }
-                        else if (Array.isArray(value)) {
+                        let filter = '';
+                        if (Array.isArray(value) && value.length > 0) {
                             const sanitizedValues = value
                                 .map(toString)
                                 .filter(val => !!val)
                                 .map(val => `"${sanitizeLuceneQuery(val)}"`);
-                            if (sanitizedValues.length < 1) {
-                                return [];
-                            }
-                            newQuery += `-${key}:(${sanitizedValues.join(' OR ')})`;
+                            filter = `-${key}:(${sanitizedValues.join(' OR ')})`;
                         }
-                        else {
-                            newQuery += `-${key}:"${sanitizeLuceneQuery(value.toString())}"`;
+                        else if (!Array.isArray(value)) {
+                            filter = `-${key}:"${sanitizeLuceneQuery(value.toString())}"`;
                         }
-                        return [{ key, label: key, onClick: () => setQuery(newQuery) }];
+                        if (!filter) {
+                            return [];
+                        }
+                        return [
+                            {
+                                key,
+                                label: key,
+                                onClick: () => addFilter(filter)
+                            }
+                        ];
                     })
                 });
                 result.push({
@@ -230,25 +231,31 @@ const RecordContextMenu = ({ children, getSelectedId, Component }) => {
                     icon: _jsx(AddCircleOutline, {}),
                     label: t('hit.panel.include'),
                     items: filterKeys.flatMap(key => {
-                        let newQuery = `(${query}) AND `;
                         const value = get(record, key);
                         if (!value) {
                             return [];
                         }
-                        else if (Array.isArray(value)) {
+                        let filter = '';
+                        if (Array.isArray(value) && value.length > 0) {
                             const sanitizedValues = value
                                 .map(toString)
                                 .filter(val => !!val)
                                 .map(val => `"${sanitizeLuceneQuery(val)}"`);
-                            if (sanitizedValues.length < 1) {
-                                return [];
-                            }
-                            newQuery += `${key}:(${sanitizedValues.join(' OR ')})`;
+                            filter = `${key}:(${sanitizedValues.join(' OR ')})`;
+                        }
+                        else if (!Array.isArray(value)) {
+                            filter = `${key}:"${sanitizeLuceneQuery(value.toString())}"`;
                         }
-                        else {
-                            newQuery += `${key}:"${sanitizeLuceneQuery(value.toString())}"`;
+                        if (!filter) {
+                            return [];
                         }
-                        return [{ key, label: key, onClick: () => setQuery(newQuery) }];
+                        return [
+                            {
+                                key,
+                                label: key,
+                                onClick: () => addFilter(filter)
+                            }
+                        ];
                     })
                 });
             }
@@ -272,7 +279,7 @@ const RecordContextMenu = ({ children, getSelectedId, Component }) => {
         });
         return result;
         // eslint-disable-next-line react-hooks/exhaustive-deps
-    }, [record, analytic, template, entries, rowStatus, actions, query, t, setQuery, executeAction, showModal, records]);
+    }, [record, analytic, template, entries, rowStatus, actions, t, addFilter, executeAction, showModal, records]);
     return (_jsx(ContextMenu, { id: "contextMenu", Component: Component, onOpen: onOpen, onClose: () => setAnalytic(undefined), items: items, children: children }));
 };
 export default RecordContextMenu;

package/components/elements/record/RecordContextMenu.test.js

@@ -128,7 +128,7 @@ const mockRecordContext = {
     },
     selectedRecords: []
 };
-const mockParameterContext = { query: DEFAULT_QUERY, setQuery: vi.fn() };
+const mockParameterContext = { query: DEFAULT_QUERY, setQuery: vi.fn(), addFilter: vi.fn() };
 // Test wrapper
 const Wrapper = ({ children }) => {
     return (_jsx(I18nextProvider, { i18n: i18n, children: _jsx(ApiConfigContext.Provider, { value: mockApiContext, children: _jsx(ModalContext.Provider, { value: { showModal: mockShowModal }, children: _jsx(RecordContext.Provider, { value: mockRecordContext, children: _jsx(ParameterContext.Provider, { value: mockParameterContext, children: children }) }) }) }) }));
@@ -145,6 +145,7 @@ describe('HitContextMenu', () => {
             'test-hit-1': createMockHit()
         };
         mockGetSelectedId.mockReturnValue('test-hit-1');
+        mockParameterContext.query = DEFAULT_QUERY;
         mockGetMatchingAnalytic.mockResolvedValue(createMockAnalytic());
         mockGetMatchingTemplate.mockResolvedValue(createMockTemplate());
         rerender = render(_jsx(Wrapper, { children: _jsx(RecordContextMenu, { getSelectedId: mockGetSelectedId, children: _jsx("div", { children: "Test Content" }) }) })).rerender;
@@ -602,7 +603,8 @@ describe('HitContextMenu', () => {
                 await user.click(detectionKey);
             });
             await waitFor(() => {
-                expect(mockParameterContext.setQuery).toHaveBeenCalledWith('-howler.detection:"Test Detection"');
+                expect(mockParameterContext.addFilter).toHaveBeenCalledWith('-howler.detection:"Test Detection"');
+                expect(mockParameterContext.setQuery).not.toHaveBeenCalled();
             });
         });
         it('should generate exclusion query for array values', async () => {
@@ -626,7 +628,7 @@ describe('HitContextMenu', () => {
                 await user.click(tagsKey);
             });
             await waitFor(() => {
-                expect(mockParameterContext.setQuery).toHaveBeenCalledWith('-howler.outline.indicators:("a" OR "b" OR "c")');
+                expect(mockParameterContext.addFilter).toHaveBeenCalledWith('-howler.outline.indicators:("a" OR "b" OR "c")');
             });
         });
         it('should preserve existing query when adding exclusion', async () => {
@@ -645,7 +647,9 @@ describe('HitContextMenu', () => {
                 await user.click(detectionKey);
             });
             await waitFor(() => {
-                expect(mockParameterContext.setQuery).toHaveBeenCalledWith('(howler.status:open) AND -howler.detection:"Test Detection"');
+                expect(mockParameterContext.addFilter).toHaveBeenCalledWith('-howler.detection:"Test Detection"');
+                expect(mockParameterContext.query).toBe('howler.status:open');
+                expect(mockParameterContext.setQuery).not.toHaveBeenCalled();
             });
         });
         it('should render outline fields in the exclusion menu when template has no keys', async () => {
@@ -718,6 +722,8 @@ describe('HitContextMenu', () => {
             });
         });
         it('should generate inclusion query for single value', async () => {
+            mockParameterContext.query = 'howler.status:open';
+            mockRecordContext.records['test-hit-1'].howler.detection = 'Test "Detection"';
             act(() => {
                 const contextMenuWrapper = screen.getByText('Test Content').parentElement;
                 fireEvent.contextMenu(contextMenuWrapper);
@@ -737,7 +743,9 @@ describe('HitContextMenu', () => {
                 await user.click(detectionKey);
             });
             await waitFor(() => {
-                expect(mockParameterContext.setQuery).toHaveBeenCalledWith('(howler.status:open) AND howler.detection:"Test Detection"');
+                expect(mockParameterContext.addFilter).toHaveBeenCalledWith('howler.detection:"Test \\"Detection\\""');
+                expect(mockParameterContext.query).toBe('howler.status:open');
+                expect(mockParameterContext.setQuery).not.toHaveBeenCalled();
             });
         });
         it('should generate inclusion query for array values', async () => {
@@ -761,7 +769,7 @@ describe('HitContextMenu', () => {
                 await user.click(tagsKey);
             });
             await waitFor(() => {
-                expect(mockParameterContext.setQuery).toHaveBeenCalledWith('(howler.status:open) AND howler.outline.indicators:("a" OR "b" OR "c")');
+                expect(mockParameterContext.addFilter).toHaveBeenCalledWith('howler.outline.indicators:("a" OR "b" OR "c")');
             });
         });
         it('should preserve existing query when adding inclusion', async () => {
@@ -780,7 +788,9 @@ describe('HitContextMenu', () => {
                 await user.click(detectionKey);
             });
             await waitFor(() => {
-                expect(mockParameterContext.setQuery).toHaveBeenCalledWith('(howler.status:open) AND howler.detection:"Test Detection"');
+                expect(mockParameterContext.addFilter).toHaveBeenCalledWith('howler.detection:"Test Detection"');
+                expect(mockParameterContext.query).toBe('howler.status:open');
+                expect(mockParameterContext.setQuery).not.toHaveBeenCalled();
             });
         });
         it('should render outline fields in the inclusion menu when template has no keys', async () => {
@@ -804,7 +814,7 @@ describe('HitContextMenu', () => {
             await act(async () => {
                 await user.click(screen.getByText('howler.outline.indicators'));
             });
-            expect(mockParameterContext.setQuery).toHaveBeenCalledWith(expect.stringContaining('howler.outline.indicators:("a" OR "b" OR "c")'));
+            expect(mockParameterContext.addFilter).toHaveBeenCalledWith(expect.stringContaining('howler.outline.indicators:("a" OR "b" OR "c")'));
         });
         it('should skip null field values in inclusion menu', async () => {
             act(() => {

package/components/routes/hits/search/QuerySettings.js

@@ -26,6 +26,6 @@ const QuerySettings = ({ boxSx }) => {
         await fetchViews();
         addView('');
     };
-    return (_jsx(Box, { sx: boxSx ?? { position: 'relative', maxWidth: '1200px' }, children: _jsxs(Stack, { direction: "row", spacing: 1, children: [_jsxs(Grid, { container: true, spacing: 1, children: [_jsx(Grid, { children: _jsx(IndexPicker, {}) }), _jsx(Grid, { children: _jsx(HitSort, {}) }), _jsx(Grid, { children: _jsx(SearchSpan, {}) }), currentViews?.map((view, id) => (_jsx(Grid, { children: _jsx(ViewLink, { id: id, viewId: view }) }, view))), filters?.map((filter, id) => (_jsx(Grid, { children: _jsx(HitFilter, { id: id, value: filter }) }, filter)))] }), _jsx(ChipPopper, { icon: _jsx(Add, {}), deleteIcon: _jsx(ArrowDropDown, {}), toggleOnDelete: true, closeOnClick: true, slotProps: { chip: { size: 'small', color: 'primary' }, paper: { sx: { p: 1 } } }, children: _jsxs(Stack, { spacing: 1, children: [_jsxs(Button, { id: "add-filter", "aria-label": t('hit.search.filter.add'), variant: "outlined", onClick: () => addFilter('howler.assessment:*'), disabled: filters?.some(filter => filter.endsWith('*')), sx: { display: 'flex', pl: 1 }, children: [_jsx(Add, { fontSize: "small", sx: { mr: 1 } }), _jsx("div", { style: { flex: 1 } }), _jsx("span", { children: t('hit.search.filter.add') })] }), _jsxs(Button, { id: "add-view", "aria-label": t('hit.search.view.add'), variant: "outlined", onClick: onAddView, disabled: !allowAddViews, sx: { display: 'flex', pl: 1 }, children: [_jsx(Add, { fontSize: "small", sx: { mr: 1 } }), _jsx("div", { style: { flex: 1 } }), _jsx("span", { children: t('hit.search.view.add') })] })] }) })] }) }));
+    return (_jsx(Box, { sx: boxSx ?? { position: 'relative', maxWidth: '1200px' }, children: _jsxs(Stack, { direction: "row", spacing: 1, children: [_jsxs(Grid, { container: true, spacing: 1, children: [_jsx(Grid, { children: _jsx(IndexPicker, {}) }), _jsx(Grid, { children: _jsx(HitSort, {}) }), _jsx(Grid, { children: _jsx(SearchSpan, {}) }), currentViews?.map((view, id) => (_jsx(Grid, { children: _jsx(ViewLink, { id: id, viewId: view }) }, view))), filters?.map((filter, id) => (_jsx(Grid, { children: _jsx(HitFilter, { id: id, value: filter }) }, filter)))] }), _jsx(ChipPopper, { icon: _jsx(Add, {}), deleteIcon: _jsx(ArrowDropDown, {}), toggleOnDelete: true, closeOnClick: true, slotProps: { chip: { size: 'small', color: 'primary' }, paper: { sx: { p: 1 } } }, children: _jsxs(Stack, { spacing: 1, children: [_jsxs(Button, { id: "add-filter", "aria-label": t('hit.search.filter.add'), variant: "outlined", onClick: () => addFilter('howler.assessment:*'), disabled: filters?.some(filter => !filter.startsWith('-') && filter.endsWith('*')), sx: { display: 'flex', pl: 1 }, children: [_jsx(Add, { fontSize: "small", sx: { mr: 1 } }), _jsx("div", { style: { flex: 1 } }), _jsx("span", { children: t('hit.search.filter.add') })] }), _jsxs(Button, { id: "add-view", "aria-label": t('hit.search.view.add'), variant: "outlined", onClick: onAddView, disabled: !allowAddViews, sx: { display: 'flex', pl: 1 }, children: [_jsx(Add, { fontSize: "small", sx: { mr: 1 } }), _jsx("div", { style: { flex: 1 } }), _jsx("span", { children: t('hit.search.view.add') })] })] }) })] }) }));
 };
 export default memo(QuerySettings);

package/components/routes/hits/search/QuerySettings.test.js

@@ -185,6 +185,16 @@ describe('QuerySettings', () => {
             expect(mockAddFilter).toHaveBeenCalledWith('howler.assessment:*');
             expect(mockAddFilter).toHaveBeenCalledTimes(1);
         });
+        it('should allow adding a filter when only negated wildcard filters exist', async () => {
+            mockParameterContext.filters = ['-howler.assessment:*'];
+            const { rerender } = render(_jsx(QuerySettings, {}), { wrapper: Wrapper });
+            await user.click(screen.getByRole('button'));
+            const addFilterButton = screen.getByLabelText(i18n.t('hit.search.filter.add'));
+            expect(addFilterButton).toBeEnabled();
+            mockParameterContext = { ...mockParameterContext, filters: ['howler.assessment:*'] };
+            rerender(_jsx(QuerySettings, {}));
+            expect(addFilterButton).toBeDisabled();
+        });
         it('should call fetchViews and addView when Add View button clicked', async () => {
             mockViewContext.views = {
                 'view-1': createMockView({ view_id: 'view-1' })

package/components/routes/hits/search/shared/HitFilter.js

@@ -1,15 +1,16 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-import { FilterList } from '@mui/icons-material';
-import { Autocomplete, Stack, TextField, Typography } from '@mui/material';
+import { AddCircleOutline, FilterList, RemoveCircleOutline } from '@mui/icons-material';
+import { Autocomplete, Checkbox, FormControlLabel, 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 { ParameterContext } from '@cccsaurora/howler-ui/components/app/providers/ParameterProvider';
 import ChipPopper from '@cccsaurora/howler-ui/components/elements/display/ChipPopper';
 import useMyApi from '@cccsaurora/howler-ui/components/hooks/useMyApi';
+import { isEmpty, isNil, uniq } from 'lodash-es';
 import { memo, useCallback, useContext, useEffect, useState } from 'react';
 import { useTranslation } from 'react-i18next';
 import { useContextSelector } from 'use-context-selector';
-import { sanitizeLuceneQuery } from '@cccsaurora/howler-ui/utils/stringUtils';
+import { parseQuotedValues, sanitizeLuceneQuery } from '@cccsaurora/howler-ui/utils/stringUtils';
 const ACCEPTED_LOOKUPS = [
     'howler.assessment',
     'howler.escalation',
@@ -18,60 +19,129 @@ const ACCEPTED_LOOKUPS = [
     'event.provider',
     'organization.name'
 ];
+const parseFilter = (value) => {
+    const negated = value.startsWith('-');
+    const positiveValue = negated ? value.slice(1) : value;
+    const separator = positiveValue.indexOf(':');
+    const category = separator > 0 ? positiveValue.slice(0, separator) : null;
+    const rawClause = category ? positiveValue.slice(separator + 1) : positiveValue;
+    const parsed = {
+        raw: value,
+        category,
+        rawClause,
+        values: [],
+        negated,
+        editable: false,
+        wildcard: false
+    };
+    // Only the editor's literal subset is safe to rewrite; leave arbitrary Lucene clauses opaque.
+    if (!category || !/^[A-Za-z_][A-Za-z0-9_.]*$/.test(category)) {
+        return parsed;
+    }
+    parsed.editable = true;
+    if (rawClause === '*') {
+        parsed.wildcard = true;
+        return parsed;
+    }
+    if (/^[A-Za-z_][A-Za-z0-9_.]*$/.test(rawClause) && !/^(true|false|AND|OR|NOT)$/i.test(rawClause)) {
+        parsed.values = [rawClause];
+        return parsed;
+    }
+    const parts = parseQuotedValues(rawClause);
+    if (!parts) {
+        parsed.editable = false;
+        return parsed;
+    }
+    parsed.values = parts;
+    return parsed;
+};
+const serializeFilter = (category, values, negated) => {
+    const filter = [];
+    if (negated) {
+        filter.push('-');
+    }
+    filter.push(category + ':');
+    const serializedValues = uniq(values)
+        .map(item => `"${sanitizeLuceneQuery(item)}"`)
+        .filter(item => !isEmpty(item));
+    if (serializedValues.length > 1) {
+        filter.push(`(${serializedValues.join(' OR ')})`);
+    }
+    else {
+        filter.push(serializedValues[0] ?? '*');
+    }
+    return filter.join('');
+};
 const HitFilter = ({ size, id, value }) => {
     const { t } = useTranslation();
     const { config } = useContext(ApiConfigContext);
     const { dispatchApi } = useMyApi();
     const setSavedFilter = useContextSelector(ParameterContext, ctx => ctx.setFilter);
     const removeSavedFilter = useContextSelector(ParameterContext, ctx => ctx.removeFilter);
-    const [category, setCategory] = useState(value?.split(':')[0] ?? ACCEPTED_LOOKUPS[0]);
-    const [filter, setFilter] = useState(value?.split(':')[1] ?? null);
-    const [loading, setLoading] = useState(false);
-    const [customLookups, setCustomLookups] = useState([]);
+    const [parsedFilter, setParsedFilter] = useState(() => parseFilter(value));
+    const [previousValue, setPreviousValue] = useState(value);
+    // Synchronize external replacements without resetting edits when only lookup config changes.
+    if (previousValue !== value) {
+        setPreviousValue(value);
+        setParsedFilter(parseFilter(value));
+    }
+    const [customLookups, setCustomLookups] = useState({
+        category: null,
+        options: []
+    });
+    const { category, values: filterValues, editable, negated } = parsedFilter;
+    const configuredLookup = category ? config.lookups?.[category] : undefined;
+    const needsLookups = !!category && editable && !Array.isArray(configuredLookup);
+    const loading = needsLookups && customLookups.category !== category;
     useEffect(() => {
         if (value) {
-            const [_category, _filter] = (value || ':').split(':');
-            if (_category) {
-                setCategory(_category);
-            }
-            if (_filter && _filter !== '*') {
-                setFilter(_filter);
-            }
-            if (_category && _filter) {
-                setSavedFilter(id, `${_category}:${_filter}`);
-            }
+            setSavedFilter(id, value);
         }
     }, [id, setSavedFilter, value]);
-    const onCategoryChange = useCallback(async (_, _category) => {
-        setCategory(_category);
-        setFilter(null);
-        if (!_category) {
+    useEffect(() => {
+        if (!category || !editable || !isNil(configuredLookup)) {
             return;
         }
-        if (!config.lookups?.[_category]) {
-            setLoading(true);
-            const facets = await dispatchApi(api.search.facet.hit.post({ query: 'howler.id:*', fields: [_category], rows: 100 }), {
-                throwError: false
-            });
-            setCustomLookups(Object.keys((facets ?? {})[_category] ?? {}));
-            setLoading(false);
-        }
-        else {
-            setCustomLookups([]);
-        }
-    }, [config.lookups, dispatchApi]);
-    const onValueChange = useCallback((_, newValue) => {
-        setFilter(newValue);
-        if (newValue && newValue !== '*') {
-            setSavedFilter(id, `${category}:"${sanitizeLuceneQuery(newValue)}"`);
-        }
-        else {
-            setSavedFilter(id, `${category}:*`);
+        // Ignore responses from a previous field or an unmounted editor.
+        let active = true;
+        void (async () => {
+            try {
+                const facets = await dispatchApi(api.search.facet.hit.post({ query: `${category}:*`, fields: [category], rows: 100 }), { throwError: false });
+                if (!active) {
+                    return;
+                }
+                setCustomLookups({ category, options: Object.keys((facets ?? {})[category] ?? {}) });
+            }
+            catch {
+                if (active) {
+                    setCustomLookups({ category, options: [] });
+                }
+            }
+        })();
+        return () => {
+            active = false;
+        };
+    }, [category, configuredLookup, dispatchApi, editable]);
+    const commitFilter = useCallback((nextValue) => {
+        setParsedFilter(parseFilter(nextValue));
+        setSavedFilter(id, nextValue);
+    }, [id, setSavedFilter]);
+    const onCategoryChange = useCallback((_, nextCategory) => {
+        commitFilter(`${negated ? '-' : ''}${nextCategory}:*`);
+    }, [commitFilter, negated]);
+    const onValuesChange = useCallback((_, newValues) => {
+        if (!category) {
+            return;
         }
-    }, [category, id, setSavedFilter]);
-    const filterValue = filter?.replaceAll('"', '').replaceAll('\\-', '-') || '';
-    const configuredLookup = category && category in (config.lookups ?? {}) ? config.lookups?.[category] : undefined;
-    const lookupOptions = Array.isArray(configuredLookup) ? configuredLookup : customLookups;
-    return (_jsx(ChipPopper, { icon: _jsx(FilterList, { fontSize: "small" }), label: category && _jsx(Typography, { variant: "body2", children: `${category}:${filterValue || '*'}` }), minWidth: "250px", onDelete: () => removeSavedFilter(value), slotProps: { chip: { size: 'small', color: value?.endsWith('*') ? 'warning' : 'default' } }, children: _jsxs(Stack, { spacing: 1, sx: { minWidth: '225px' }, children: [_jsx(Autocomplete, { fullWidth: true, size: size ?? 'small', value: category, options: ACCEPTED_LOOKUPS, renderInput: _params => _jsx(TextField, { ..._params, label: t('hit.search.filter.fields') }), onChange: onCategoryChange }), _jsx(Autocomplete, { fullWidth: true, freeSolo: true, disabled: !category, loading: loading, size: size ?? 'small', value: filter?.replaceAll('"', '').replaceAll('\\-', '-') || '', options: [...lookupOptions, '*'], renderInput: _params => _jsx(TextField, { ..._params, label: t('hit.search.filter.values') }), getOptionLabel: option => t(option), onChange: onValueChange })] }) }));
+        commitFilter(serializeFilter(category, newValues, negated));
+    }, [category, commitFilter, negated]);
+    const toggleNegation = useCallback((event, nextNegated) => {
+        event.stopPropagation();
+        // Toggle only the leading sign, including for opaque clauses the editor cannot parse.
+        commitFilter(parsedFilter.raw.replace(/^-?/, nextNegated ? '-' : ''));
+    }, [commitFilter, parsedFilter.raw]);
+    const lookupOptions = configuredLookup ?? (customLookups.category === category ? customLookups.options : []);
+    const chipLabel = `${parsedFilter.category ? `${parsedFilter.category}:` : ''}${parsedFilter.rawClause}`;
+    return (_jsx(Stack, { direction: "row", alignItems: "center", spacing: 0.5, children: _jsx(ChipPopper, { icon: _jsxs(Stack, { direction: "row", spacing: 0.25, alignItems: "center", children: [_jsx(FilterList, { fontSize: "small" }), parsedFilter.negated ? (_jsx(Tooltip, { title: t('hit.search.filter.excluded'), children: _jsx(RemoveCircleOutline, { fontSize: "small", color: "error" }) })) : (_jsx(Tooltip, { title: t('hit.search.filter.included'), children: _jsx(AddCircleOutline, { fontSize: "small", color: "success" }) }))] }), label: _jsx(Typography, { variant: "body2", children: chipLabel }), minWidth: "250px", onDelete: () => removeSavedFilter(value), slotProps: { chip: { size: 'small', color: parsedFilter.wildcard ? 'warning' : 'default' } }, children: _jsxs(Stack, { spacing: 1, sx: { minWidth: '225px' }, children: [_jsx(FormControlLabel, { label: t('hit.search.filter.exclude'), control: _jsx(Checkbox, { size: "small", checked: negated, onChange: toggleNegation }) }), _jsx(Autocomplete, { fullWidth: true, disableClearable: true, disabled: !editable, size: size ?? 'small', value: category ?? ACCEPTED_LOOKUPS[0], options: ACCEPTED_LOOKUPS, renderInput: _params => _jsx(TextField, { ..._params, label: t('hit.search.filter.fields') }), onChange: onCategoryChange }), _jsx(Autocomplete, { fullWidth: true, freeSolo: true, multiple: true, disabled: !category || !editable, loading: loading, size: size ?? 'small', value: filterValues, options: lookupOptions, renderInput: _params => _jsx(TextField, { ..._params, label: t('hit.search.filter.values') }), getOptionLabel: option => t(option), onChange: onValuesChange })] }) }) }));
 };
 export default memo(HitFilter);

package/components/routes/hits/search/shared/HitFilter.test.js

@@ -1,23 +1,45 @@
-import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { jsx as _jsx } from "react/jsx-runtime";
 /// <reference types="vitest" />
-import { fireEvent, render, screen, waitFor } from '@testing-library/react';
+import { act, fireEvent, render, screen, waitFor } from '@testing-library/react';
 import { beforeEach, describe, expect, it, vi } from 'vitest';
 const apiConfigContextToken = vi.hoisted(() => ({ name: 'api-config-context' }));
 const parameterContextToken = vi.hoisted(() => ({ name: 'parameter-context' }));
 const mockDispatchApi = vi.hoisted(() => vi.fn());
 const mockSetSavedFilter = vi.hoisted(() => vi.fn());
 const mockRemoveSavedFilter = vi.hoisted(() => vi.fn());
+const mockAutocompleteSelection = vi.hoisted(() => ({
+    value: 'normal'
+}));
 let configValue = { lookups: { 'howler.assessment': ['malicious'] } };
 vi.mock('@mui/icons-material', async (importOriginal) => {
     const actual = await importOriginal();
     return { ...actual, FilterList: () => _jsx("div", { children: "filter-icon" }) };
 });
-vi.mock('@mui/material', () => ({
-    Autocomplete: ({ onChange, options, disabled }) => (_jsx("button", { disabled: disabled, onClick: () => onChange(null, options.includes('event.provider') ? 'event.provider' : options[0]), children: "change-filter" })),
-    Stack: ({ children }) => _jsx("div", { children: children }),
-    TextField: ({ label }) => _jsx("div", { children: label }),
-    Typography: ({ children }) => _jsx("div", { children: children })
-}));
+vi.mock('@mui/material', async (importOriginal) => {
+    const actual = await importOriginal();
+    return {
+        ...actual,
+        Autocomplete: ({ onChange, options, disabled, multiple, value, loading }) => (_jsx("button", { disabled: disabled, "data-loading": Boolean(loading), "data-options": JSON.stringify(options), onClick: () => onChange(null, mockAutocompleteSelection.value === 'clear'
+                ? multiple
+                    ? []
+                    : null
+                : multiple
+                    ? mockAutocompleteSelection.value === 'unchanged'
+                        ? value
+                        : mockAutocompleteSelection.value === 'add'
+                            ? [...(value ?? []), 'added value']
+                            : mockAutocompleteSelection.value === 'single'
+                                ? (value ?? []).slice(0, 1)
+                                : (value?.length ?? 0) > 1
+                                    ? [value[0], value[0]?.startsWith('C:') ? 'new\\path' : 'changed two']
+                                    : [value?.[0] ?? options[0] ?? 'changed one']
+                    : value === '*'
+                        ? '*'
+                        : options.includes('event.provider')
+                            ? 'event.provider'
+                            : options[0]), children: "change-filter" }))
+    };
+});
 vi.mock('api', () => ({
     default: {
         search: {
@@ -35,9 +57,6 @@ vi.mock('components/app/providers/ApiConfigProvider', () => ({
 vi.mock('components/app/providers/ParameterProvider', () => ({
     ParameterContext: parameterContextToken
 }));
-vi.mock('components/elements/display/ChipPopper', () => ({
-    default: ({ children, label, onDelete }) => (_jsxs("div", { children: [_jsx("div", { children: label }), _jsx("button", { onClick: onDelete, children: "delete-filter" }), children] }))
-}));
 vi.mock('components/hooks/useMyApi', () => ({
     default: () => ({ dispatchApi: mockDispatchApi })
 }));
@@ -65,19 +84,192 @@ describe('HitFilter', () => {
         mockDispatchApi.mockReset().mockImplementation(async (_value) => ({ 'event.provider': { azure: 2 } }));
         mockSetSavedFilter.mockReset();
         mockRemoveSavedFilter.mockReset();
+        mockAutocompleteSelection.value = 'normal';
     });
     it('initializes from value, fetches custom lookups, updates values, and removes filters', async () => {
         render(_jsx(HitFilter, { id: 1, value: 'howler.assessment:*' }));
         await waitFor(() => expect(mockSetSavedFilter).toHaveBeenCalledWith(1, 'howler.assessment:*'));
+        fireEvent.click(screen.getByRole('button', { name: /howler.assessment:\*/ }));
         fireEvent.click(screen.getAllByText('change-filter')[0]);
-        await waitFor(() => expect(mockDispatchApi).toHaveBeenCalledWith({ query: 'howler.id:*', fields: ['event.provider'], rows: 100 }, { throwError: false }));
+        await waitFor(() => expect(mockDispatchApi).toHaveBeenCalledWith({ query: 'event.provider:*', fields: ['event.provider'], rows: 100 }, { throwError: false }));
         fireEvent.click(screen.getAllByText('change-filter')[1]);
         expect(mockSetSavedFilter).toHaveBeenCalledWith(1, 'event.provider:"azure"');
-        fireEvent.click(screen.getByText('delete-filter'));
+        const chip = screen.getByRole('button', { name: /event.provider:"azure"/ });
+        const deleteIcon = chip.querySelector('.MuiChip-deleteIcon');
+        expect(deleteIcon).not.toBeNull();
+        fireEvent.click(deleteIcon);
         expect(mockRemoveSavedFilter).toHaveBeenCalledWith('howler.assessment:*');
     });
+    it('commits a field change immediately while retaining negation', () => {
+        render(_jsx(HitFilter, { id: 13, value: '-howler.assessment:"malicious"' }));
+        fireEvent.click(screen.getByRole('button', { name: /howler.assessment:/ }));
+        fireEvent.click(screen.getAllByText('change-filter')[0]);
+        expect(mockSetSavedFilter).toHaveBeenLastCalledWith(13, '-event.provider:*');
+        expect(screen.getByRole('button', { name: /event.provider:\*/ })).toBeInTheDocument();
+    });
+    it('does not reset an edited filter when lookup configuration changes', () => {
+        const { rerender } = render(_jsx(HitFilter, { id: 14, value: 'event.provider:"a"' }));
+        fireEvent.click(screen.getByRole('button', { name: /event.provider:/ }));
+        fireEvent.click(screen.getByRole('checkbox', { name: 'hit.search.filter.exclude' }));
+        mockSetSavedFilter.mockClear();
+        configValue = { lookups: { 'event.provider': ['a'] } };
+        rerender(_jsx(HitFilter, { id: 14, value: 'event.provider:"a"', size: "medium" }));
+        expect(screen.getByRole('checkbox', { name: 'hit.search.filter.exclude' })).toBeChecked();
+        expect(mockSetSavedFilter).not.toHaveBeenCalled();
+    });
     it('uses configured lookups and wildcard values', async () => {
         render(_jsx(HitFilter, { id: 2, value: 'howler.assessment:*' }));
         await waitFor(() => expect(mockSetSavedFilter).toHaveBeenCalledWith(2, 'howler.assessment:*'));
     });
+    it('deduplicates decoded literals while preserving quoted OR text', () => {
+        const clause = String.raw `event.provider:("a" OR "\a" OR "text OR more" OR "escaped\"quote")`;
+        render(_jsx(HitFilter, { id: 15, value: clause }));
+        fireEvent.click(screen.getByRole('button', { name: /event.provider:/ }));
+        mockAutocompleteSelection.value = 'unchanged';
+        fireEvent.click(screen.getAllByText('change-filter')[1]);
+        expect(mockSetSavedFilter).toHaveBeenLastCalledWith(15, String.raw `event.provider:("a" OR "text OR more" OR "escaped\"quote")`);
+    });
+    it('collapses duplicate values to a canonical scalar while preserving negation', () => {
+        render(_jsx(HitFilter, { id: 20, value: String.raw `-event.provider:("\a" OR "a" OR "a")` }));
+        fireEvent.click(screen.getByRole('button', { name: /event.provider:/ }));
+        mockAutocompleteSelection.value = 'unchanged';
+        fireEvent.click(screen.getAllByText('change-filter')[1]);
+        expect(mockSetSavedFilter).toHaveBeenLastCalledWith(20, '-event.provider:"a"');
+    });
+    it.each(['plain', String.raw `"\plain"`, '"constructor"', '"__proto__"'])('canonically quotes a decoded scalar from %s', literal => {
+        render(_jsx(HitFilter, { id: 21, value: `event.provider:${literal}` }));
+        fireEvent.click(screen.getByRole('button', { name: /event.provider:/ }));
+        mockAutocompleteSelection.value = 'unchanged';
+        fireEvent.click(screen.getAllByText('change-filter')[1]);
+        const expected = literal.includes('plain') ? 'plain' : literal.slice(1, -1);
+        expect(mockSetSavedFilter).toHaveBeenLastCalledWith(21, `event.provider:"${expected}"`);
+    });
+    it('accepts whitespace-separated quoted OR values', () => {
+        render(_jsx(HitFilter, { id: 16, value: 'event.provider:( "a"\tOR\n"b" )' }));
+        fireEvent.click(screen.getByRole('button', { name: /event.provider:/ }));
+        mockAutocompleteSelection.value = 'unchanged';
+        fireEvent.click(screen.getAllByText('change-filter')[1]);
+        expect(mockSetSavedFilter).toHaveBeenLastCalledWith(16, 'event.provider:("a" OR "b")');
+    });
+    it('synchronizes externally replaced filters', () => {
+        const { rerender } = render(_jsx(HitFilter, { id: 17, value: 'event.provider:"a"' }));
+        rerender(_jsx(HitFilter, { id: 17, value: '-howler.assessment:*' }));
+        fireEvent.click(screen.getByRole('button', { name: /howler.assessment:/ }));
+        expect(screen.getByRole('checkbox', { name: 'hit.search.filter.exclude' })).toBeChecked();
+        expect(mockSetSavedFilter).toHaveBeenLastCalledWith(17, '-howler.assessment:*');
+    });
+    it('settles failed lookup requests without disabling free-text editing', async () => {
+        mockDispatchApi.mockRejectedValueOnce(new Error('offline'));
+        render(_jsx(HitFilter, { id: 18, value: 'event.provider:*' }));
+        fireEvent.click(screen.getByRole('button', { name: /event.provider:/ }));
+        const values = screen.getAllByText('change-filter')[1];
+        await waitFor(() => expect(values).toHaveAttribute('data-loading', 'false'));
+        expect(values).not.toBeDisabled();
+        expect(values).toHaveAttribute('data-options', '[]');
+        expect(mockSetSavedFilter).toHaveBeenCalledWith(18, 'event.provider:*');
+    });
+    it('ignores stale lookup responses after switching to a configured field', async () => {
+        let resolveFacets;
+        mockDispatchApi.mockImplementationOnce(() => new Promise(resolve => {
+            resolveFacets = resolve;
+        }));
+        const { rerender } = render(_jsx(HitFilter, { id: 19, value: 'event.provider:*' }));
+        await waitFor(() => expect(mockDispatchApi).toHaveBeenCalled());
+        rerender(_jsx(HitFilter, { id: 19, value: 'howler.assessment:*' }));
+        fireEvent.click(screen.getByRole('button', { name: /howler.assessment:/ }));
+        await act(async () => resolveFacets({ 'event.provider': { stale: 1 } }));
+        const values = screen.getAllByText('change-filter')[1];
+        expect(values).toHaveAttribute('data-options', '["malicious"]');
+        expect(values).toHaveAttribute('data-loading', 'false');
+    });
+    it('loads custom lookups when initialized with a custom category', async () => {
+        render(_jsx(HitFilter, { id: 11, value: 'event.provider:"azure"' }));
+        fireEvent.click(screen.getByRole('button', { name: /event.provider:/ }));
+        await waitFor(() => expect(mockDispatchApi).toHaveBeenCalledWith({ query: 'event.provider:*', fields: ['event.provider'], rows: 100 }, { throwError: false }));
+        fireEvent.click(screen.getAllByText('change-filter')[1]);
+        expect(mockSetSavedFilter).toHaveBeenLastCalledWith(11, 'event.provider:"azure"');
+    });
+    it('uses the clear action to set a scalar filter to wildcard', () => {
+        render(_jsx(HitFilter, { id: 9, value: 'howler.assessment:"malicious"' }));
+        fireEvent.click(screen.getByRole('button', { name: /howler.assessment:/ }));
+        mockAutocompleteSelection.value = 'clear';
+        fireEvent.click(screen.getAllByText('change-filter')[1]);
+        expect(mockSetSavedFilter).toHaveBeenLastCalledWith(9, 'howler.assessment:*');
+    });
+    it('uses the clear action to set grouped filters to wildcard', () => {
+        render(_jsx(HitFilter, { id: 10, value: 'event.provider:("a" OR "b")' }));
+        fireEvent.click(screen.getByRole('button', { name: /event.provider:/ }));
+        mockAutocompleteSelection.value = 'clear';
+        fireEvent.click(screen.getAllByText('change-filter')[1]);
+        expect(mockSetSavedFilter).toHaveBeenLastCalledWith(10, 'event.provider:*');
+    });
+    it('serializes selections by their current cardinality', () => {
+        render(_jsx(HitFilter, { id: 12, value: 'event.provider:"a"' }));
+        fireEvent.click(screen.getByRole('button', { name: /event.provider:/ }));
+        mockAutocompleteSelection.value = 'add';
+        fireEvent.click(screen.getAllByText('change-filter')[1]);
+        expect(mockSetSavedFilter).toHaveBeenLastCalledWith(12, 'event.provider:("a" OR "added value")');
+        mockAutocompleteSelection.value = 'single';
+        fireEvent.click(screen.getAllByText('change-filter')[1]);
+        expect(mockSetSavedFilter).toHaveBeenLastCalledWith(12, 'event.provider:"a"');
+    });
+    it('toggles negation without losing a grouped OR clause', async () => {
+        const { container } = render(_jsx(HitFilter, { id: 3, value: 'event.provider:("a" OR "b")' }));
+        const chip = screen.getByRole('button', { name: /event.provider:/ });
+        fireEvent.click(chip);
+        const toggle = screen.getByRole('checkbox', { name: 'hit.search.filter.exclude' });
+        expect(chip).toHaveClass('MuiChip-root');
+        expect(toggle).not.toBeChecked();
+        fireEvent.click(toggle);
+        expect(mockSetSavedFilter).toHaveBeenLastCalledWith(3, '-event.provider:("a" OR "b")');
+        expect(screen.getByRole('button', { name: /event.provider:/ })).toBeInTheDocument();
+        expect(container.querySelector('.MuiChip-icon [data-testid="RemoveCircleOutlineIcon"]')).not.toBeNull();
+        expect(toggle).toBeChecked();
+        fireEvent.click(toggle);
+        expect(mockSetSavedFilter).toHaveBeenLastCalledWith(3, 'event.provider:("a" OR "b")');
+    });
+    it.each([
+        'event.created:[a TO z]',
+        'event.enabled:true',
+        'other OR event.provider:"a"',
+        'event.provider:NOT',
+        'event.provider:("a" OR )',
+        'event.provider:("a" AND "b")',
+        'event.provider:"unterminated',
+        'free text'
+    ])('toggles unsupported clauses without rewriting %s', clause => {
+        render(_jsx(HitFilter, { id: 5, value: clause }));
+        expect(screen.getByText(clause)).toBeInTheDocument();
+        fireEvent.click(screen.getByText(clause).closest('.MuiChip-root'));
+        expect(screen.getAllByText('change-filter').every(button => button.disabled)).toBe(true);
+        fireEvent.click(screen.getByRole('checkbox', { name: 'hit.search.filter.exclude' }));
+        expect(mockSetSavedFilter).toHaveBeenLastCalledWith(5, `-${clause}`);
+    });
+    it('preserves an escaped literal star when toggling negation', () => {
+        const clause = 'event.provider:"\\*"';
+        render(_jsx(HitFilter, { id: 6, value: clause }));
+        fireEvent.click(screen.getByRole('button', { name: /event.provider:/ }));
+        fireEvent.click(screen.getByRole('checkbox', { name: 'hit.search.filter.exclude' }));
+        expect(mockSetSavedFilter).toHaveBeenLastCalledWith(6, `-${clause}`);
+    });
+    it('keeps an escaped literal star when recommitting a negative scalar filter', () => {
+        const clause = '-event.provider:"\\*"';
+        render(_jsx(HitFilter, { id: 7, value: clause }));
+        fireEvent.click(screen.getByRole('button', { name: /event.provider:/ }));
+        fireEvent.click(screen.getAllByText('change-filter')[1]);
+        expect(mockSetSavedFilter).toHaveBeenLastCalledWith(7, clause);
+    });
+    it('retains negation and grouped values when editing a grouped filter', async () => {
+        render(_jsx(HitFilter, { id: 4, value: '-event.provider:("a" OR "b")' }));
+        fireEvent.click(screen.getByRole('button', { name: /event.provider:/ }));
+        fireEvent.click(screen.getAllByText('change-filter')[1]);
+        expect(mockSetSavedFilter).toHaveBeenLastCalledWith(4, '-event.provider:("a" OR "changed two")');
+    });
+    it('canonically escapes paths without losing literal backslashes when editing a grouped filter', () => {
+        const clause = String.raw `-event.provider:("C:\\logs" OR "other")`;
+        render(_jsx(HitFilter, { id: 8, value: clause }));
+        fireEvent.click(screen.getByRole('button', { name: /event.provider:/ }));
+        fireEvent.click(screen.getAllByText('change-filter')[1]);
+        expect(mockSetSavedFilter).toHaveBeenLastCalledWith(8, String.raw `-event.provider:("C\:\\logs" OR "new\\path")`);
+    });
 });

package/locales/en/translation.json

@@ -242,7 +242,11 @@
     "hit.search.custom": "Custom Sort",
     "hit.search.filter.add": "Add filter",
     "hit.search.filter.button": "Use lookup filters with predefined values",
+    "hit.search.filter.exclude": "Omit by this filter",
+    "hit.search.filter.excluded": "Omitting by",
     "hit.search.filter.fields": "Fields",
+    "hit.search.filter.include": "Include this filter",
+    "hit.search.filter.included": "Including by",
     "hit.search.filter.label": "Lookup Filters",
     "hit.search.filter.values": "Values",
     "hit.search.index": "Indexes",
@@ -323,11 +327,11 @@
     "membership.message.error": "There was an error when updating permissions.",
     "membership.message.success": "Permissions updated.",
     "membership.message.warning": "No users selected.",
-    "membership.role": "Role",
     "membership.privilege.admins": "Administrator",
     "membership.privilege.manage": "Manage Privileges",
     "membership.privilege.members": "Member",
     "membership.privilege.owner": "Owner",
+    "membership.role": "Role",
     "modal.action.description": "Provide a name that allows other users to identify the purpose of this action.",
     "modal.action.empty": "Action Name cannot be empty.",
     "modal.action.label": "Action Name",

package/locales/fr/translation.json

@@ -243,6 +243,10 @@
     "hit.search.filter.add": "Ajouter un filtre",
     "hit.search.filter.button": "Utiliser des filtres de recherche avec des valeurs prédéfinies",
     "hit.search.filter.fields": "Paramètres",
+    "hit.search.filter.exclude": "Exclure les résultats correspondant à ce filtre",
+    "hit.search.filter.excluded": "Filtre exclu",
+    "hit.search.filter.include": "Inclure ce filtre",
+    "hit.search.filter.included": "Filtre inclus",
     "hit.search.filter.label": "Filtres de recherche",
     "hit.search.filter.values": "Valeurs",
     "hit.search.index": "Indexes",

package/package.json

@@ -97,7 +97,7 @@
     "url": "https://github.com/CybercentreCanada/howler"
   },
   "type": "module",
-  "version": "3.1.0-dev.1697",
+  "version": "3.1.0-dev.1700",
   "exports": {
     "./i18n": "./i18n.js",
     "./index.css": "./index.css",

package/utils/stringUtils.d.ts

@@ -3,6 +3,8 @@ export declare const maxLenStr: (str: string, len: number) => string;
 export declare const safeFieldValue: (data: string | number | boolean) => string;
 export declare const safeFieldValueURI: (data: string | number | boolean) => string;
 export declare const sanitizeLuceneQuery: (query: string) => string;
+export declare const unescapeLucene: (value: string) => string;
+export declare const parseQuotedValues: (value: string) => string[] | null;
 export declare const safeStringPropertyCompare: (propertyPath: string) => (a: unknown, b: unknown) => any;
 export declare const sanitizeMultilineLucene: (query: string) => string;
 export declare const validateRegex: (regex: string) => boolean;

package/utils/stringUtils.js

@@ -25,6 +25,38 @@ export const sanitizeLuceneQuery = (query) => {
         .replace('&&', '\\&&')
         .replace('||', '\\||');
 };
+// Decode escaped literals, not full Lucene expressions; original escape spelling is not retained.
+export const unescapeLucene = (value) => value.replace(/\\(.)/gs, '$1');
+// Sticky matching consumes every character without repeatedly slicing the remaining clause.
+export const parseQuotedValues = (value) => {
+    const unwrappedClause = value.replace(/^\((.*)\)$/s, '$1');
+    const clause = unwrappedClause.trim();
+    const parts = [];
+    const quoted = /"((?:\\.|[^"\\])*)"/sy;
+    const separator = /\s+OR\s+/y;
+    let offset = 0;
+    while (offset < clause.length) {
+        quoted.lastIndex = offset;
+        const match = quoted.exec(clause);
+        if (!match) {
+            return null;
+        }
+        parts.push(unescapeLucene(match[1] ?? ''));
+        offset = quoted.lastIndex;
+        if (offset === clause.length) {
+            return parts;
+        }
+        if (unwrappedClause === value) {
+            return null;
+        }
+        separator.lastIndex = offset;
+        if (!separator.exec(clause)) {
+            return null;
+        }
+        offset = separator.lastIndex;
+    }
+    return null;
+};
 // Supports : prop or any form of nested object.. prop.object.prop2, prop.object[0].prop2
 export const safeStringPropertyCompare = (propertyPath) => {
     return (a, b) => {

package/utils/stringUtils.test.js

@@ -1,6 +1,6 @@
 /// <reference types="vitest" />
 import { describe, expect, it } from 'vitest';
-import { maxLenStr, nameToInitials, parsePixelSizeStringToInt, safeFieldValue, safeFieldValueURI, safeStringPropertyCompare, sanitizeLuceneQuery, sanitizeMultilineLucene, validateRegex } from './stringUtils';
+import { maxLenStr, nameToInitials, parsePixelSizeStringToInt, parseQuotedValues, safeFieldValue, safeFieldValueURI, safeStringPropertyCompare, sanitizeLuceneQuery, sanitizeMultilineLucene, unescapeLucene, validateRegex } from './stringUtils';
 describe('nameToInitials', () => {
     it('returns initials from a standard first-last name', () => {
         expect(nameToInitials('John Doe')).toEqual(['J', 'D']);
@@ -98,6 +98,43 @@ describe('sanitizeLuceneQuery', () => {
         expect(sanitizeLuceneQuery('plainterm')).toBe('plainterm');
     });
 });
+describe('unescapeLucene', () => {
+    it.each([
+        '',
+        'plain text',
+        '^"~*?:\\/()[]{}-!',
+        'a && b && c || d || e',
+        String.raw `C:\logs\file`,
+        String.raw `backslash before quote: \"`,
+        'line\nbreak',
+        'trailing\\'
+    ])('reverses sanitizeLuceneQuery for %j', value => {
+        expect(unescapeLucene(sanitizeLuceneQuery(value))).toBe(value);
+    });
+    it('decodes noncanonical escapes to their literal value', () => {
+        expect(unescapeLucene(String.raw `\a\*`)).toBe('a*');
+    });
+    it('decodes an escaped newline', () => {
+        expect(unescapeLucene('\\\n')).toBe('\n');
+    });
+    it('leaves a trailing unmatched backslash unchanged', () => {
+        expect(unescapeLucene('trailing\\')).toBe('trailing\\');
+    });
+});
+describe('parseQuotedValues', () => {
+    it('parses and unescapes a quoted scalar', () => {
+        expect(parseQuotedValues(String.raw `"escaped\"quote"`)).toEqual(['escaped"quote']);
+    });
+    it('parses grouped alternatives without splitting OR inside a quoted value', () => {
+        expect(parseQuotedValues('( "a"\tOR\n"text OR more" )')).toEqual(['a', 'text OR more']);
+    });
+    it.each(['"a" OR "b"', '"a" OR "b" '])('rejects ungrouped alternatives: %j', clause => {
+        expect(parseQuotedValues(clause)).toBeNull();
+    });
+    it.each(['()', '("a" OR)', '("a" "b")', '("unterminated)'])('rejects malformed groups: %j', clause => {
+        expect(parseQuotedValues(clause)).toBeNull();
+    });
+});
 describe('safeStringPropertyCompare', () => {
     const compare = safeStringPropertyCompare('name');
     it('returns a negative number when a sorts before b', () => {