@cccsaurora/howler-ui 2.14.0-dev.269 → 2.14.0-dev.272

package/components/routes/templates/TemplateEditor.js

@@ -0,0 +1,54 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { closestCorners, DndContext } from '@dnd-kit/core';
+import { arrayMove, SortableContext } from '@dnd-kit/sortable';
+import { Add } from '@mui/icons-material';
+import { Button, Stack, Typography } from '@mui/material';
+import { ApiConfigContext } from '@cccsaurora/howler-ui/components/app/providers/ApiConfigProvider';
+import { FieldContext } from '@cccsaurora/howler-ui/components/app/providers/FieldProvider';
+import Phrase from '@cccsaurora/howler-ui/components/elements/addons/search/phrase/Phrase';
+import { get, isObject } from 'lodash-es';
+import { memo, useCallback, useContext, useEffect, useState } from 'react';
+import { useTranslation } from 'react-i18next';
+import TemplateDnD from './TemplateDnD';
+const TemplateEditor = ({ hit, fields, setFields, onRemove, onAdd }) => {
+    const { t } = useTranslation();
+    const { config } = useContext(ApiConfigContext);
+    const { getHitFields } = useContext(FieldContext);
+    const [phrase, setPhrase] = useState('');
+    const [suggestions, setSuggestions] = useState([]);
+    const tryAddField = useCallback(() => {
+        if (suggestions.includes(phrase)) {
+            if (!fields.includes(phrase)) {
+                onAdd(phrase);
+                setPhrase('');
+            }
+        }
+    }, [fields, onAdd, phrase, suggestions]);
+    const checkForActions = useCallback((e) => {
+        if (e.isEnter) {
+            tryAddField();
+        }
+    }, [tryAddField]);
+    useEffect(() => {
+        getHitFields().then(suggestionFields => setSuggestions(suggestionFields.map(f => f.key)));
+    }, [getHitFields]);
+    const handleDragEnd = useCallback((event) => {
+        const { active, over } = event;
+        if (active.id !== over.id) {
+            const oldIndex = (fields ?? []).findIndex(entry => entry === active.id);
+            const newIndex = (fields ?? []).findIndex(entry => entry === over.id);
+            setFields(arrayMove(fields, oldIndex, newIndex));
+        }
+    }, [fields, setFields]);
+    return (_jsxs(Stack, { spacing: 1, width: "100%", alignItems: "stretch", children: [_jsx(DndContext, { collisionDetection: closestCorners, onDragEnd: handleDragEnd, children: _jsx(SortableContext, { items: (fields ?? []).map(entry => entry), children: fields.map(field => {
+                        let data = get(hit, field);
+                        if (!data) {
+                            data = 'N/A';
+                        }
+                        else if (isObject(data)) {
+                            data = JSON.stringify(data);
+                        }
+                        return (_jsx(TemplateDnD, { field: field, data: data, onRemove: onRemove, tooltipTitle: (config.indexes.hit[field].description ?? t('none')).split('\n')[0] }, field));
+                    }) }) }), _jsxs(Stack, { direction: "row", sx: { '& > div': { flex: 1 } }, spacing: 1, children: [_jsx(Phrase, { suggestions: suggestions, value: phrase, onChange: setPhrase, onKeyDown: checkForActions, size: "small" }), _jsx(Button, { variant: "outlined", size: "small", sx: { marginLeft: 'auto' }, startIcon: _jsx(Add, { fontSize: "small" }), disabled: !suggestions.includes(phrase) || fields.includes(phrase), onClick: tryAddField, children: t('button.add') })] }), _jsx(Typography, { variant: "caption", color: "text.secondary", children: t('route.templates.prompt') })] }));
+};
+export default memo(TemplateEditor);

package/components/routes/templates/TemplateViewer.d.ts

@@ -0,0 +1,2 @@
+declare const TemplateViewer: () => import("react/jsx-runtime").JSX.Element;
+export default TemplateViewer;

package/components/routes/templates/TemplateViewer.js

@@ -0,0 +1,156 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Autocomplete, Button, CircularProgress, Divider, FormControl, LinearProgress, Stack, TextField, ToggleButton, ToggleButtonGroup, Tooltip } from '@mui/material';
+import api from '@cccsaurora/howler-ui/api';
+import PageCenter from '@cccsaurora/howler-ui/commons/components/pages/PageCenter';
+import TemplateEditor from '@cccsaurora/howler-ui/components/routes/templates/TemplateEditor';
+import { useCallback, useEffect, useMemo, useState } from 'react';
+import { useTranslation } from 'react-i18next';
+import { Check, Delete, SsidChart } from '@mui/icons-material';
+import AppInfoPanel from '@cccsaurora/howler-ui/commons/components/display/AppInfoPanel';
+import { DEFAULT_FIELDS } from '@cccsaurora/howler-ui/components/elements/hit/HitOutline';
+import useMyApi from '@cccsaurora/howler-ui/components/hooks/useMyApi';
+import isEqual from 'lodash-es/isEqual';
+import { useSearchParams } from 'react-router-dom';
+import hitsData from '@cccsaurora/howler-ui/utils/hit.json';
+import { sanitizeLuceneQuery } from '@cccsaurora/howler-ui/utils/stringUtils';
+const TemplateViewer = () => {
+    const { t } = useTranslation();
+    const [params, setParams] = useSearchParams();
+    const { dispatchApi } = useMyApi();
+    const [templateList, setTemplateList] = useState([]);
+    const [selectedTemplate, setSelectedTemplate] = useState(null);
+    const [displayFields, setDisplayFields] = useState([]);
+    const [analytics, setAnalytics] = useState([]);
+    const [detections, setDetections] = useState([]);
+    const [analytic, setAnalytic] = useState(params.get('analytic') ?? '');
+    const [detection, setDetection] = useState(params.get('detection') ?? 'ANY');
+    const [type, setType] = useState((params.get('type') ?? 'personal').replace('readonly', 'global'));
+    const [loading, setLoading] = useState(false);
+    const [templateLoading, setTemplateLoading] = useState(false);
+    useEffect(() => {
+        setLoading(true);
+        dispatchApi(api.search.analytic.post({ query: 'analytic_id:*', rows: 1000 }), {
+            logError: false,
+            showError: true,
+            throwError: true
+        })
+            .finally(() => setLoading(false))
+            .then(result => result.items)
+            .then(_analytics => {
+            if (!_analytics.some(_analytic => _analytic.name.toLowerCase() === analytic.toLowerCase())) {
+                setAnalytic('');
+            }
+            setAnalytics(_analytics);
+        });
+        dispatchApi(api.template.get()).then(setTemplateList);
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, [analytic, dispatchApi]);
+    useEffect(() => {
+        if (!analytic) {
+            return;
+        }
+        setLoading(true);
+        dispatchApi(api.search.grouped.hit.post('howler.detection', {
+            limit: 0,
+            query: `howler.analytic:"${sanitizeLuceneQuery(analytic)}"`
+        }), {
+            logError: false,
+            showError: true,
+            throwError: true
+        })
+            .finally(() => setLoading(false))
+            .then(result => result.items.map(i => i.value))
+            .then(_detections => {
+            if (_detections.length < 1) {
+                setDetection('ANY');
+            }
+            if (detection && !_detections.includes(detection)) {
+                setDetection('ANY');
+            }
+            setDetections(_detections);
+        });
+    }, [analytic, detection, dispatchApi, params, setParams, type]);
+    useEffect(() => {
+        if (analytic && detection) {
+            const template = (templateList ?? []).find(_template => _template.analytic === analytic &&
+                ((detection === 'ANY' && !_template.detection) || _template.detection === detection) &&
+                _template.type === type);
+            if (template) {
+                setSelectedTemplate(template);
+                setDisplayFields(template.keys);
+            }
+            else {
+                setSelectedTemplate(null);
+                setDisplayFields(DEFAULT_FIELDS);
+            }
+        }
+    }, [analytic, detection, templateList, type]);
+    useEffect(() => {
+        if (analytic) {
+            params.set('analytic', analytic);
+        }
+        else {
+            params.delete('analytic');
+        }
+        if (detection && detection !== 'ANY') {
+            params.set('detection', detection);
+        }
+        else {
+            params.delete('detection');
+        }
+        params.set('type', type);
+        params.sort();
+        setParams(params, {
+            replace: true
+        });
+    }, [analytic, detection, params, setParams, type]);
+    const exampleHit = useMemo(() => {
+        const _hit = hitsData.GET[Object.keys(hitsData.GET)[0]];
+        if (analytic) {
+            _hit.howler.analytic = analytic;
+        }
+        return { ..._hit };
+    }, [analytic]);
+    const onDelete = useCallback(async () => {
+        await dispatchApi(api.template.del(selectedTemplate.template_id), {
+            logError: false,
+            showError: true,
+            throwError: false
+        });
+        setSelectedTemplate(null);
+        setDisplayFields(DEFAULT_FIELDS);
+    }, [dispatchApi, selectedTemplate?.template_id]);
+    const onSave = useCallback(async () => {
+        if (analytic && detection) {
+            try {
+                setTemplateLoading(true);
+                const result = await dispatchApi(selectedTemplate
+                    ? api.template.put(selectedTemplate.template_id, displayFields)
+                    : api.template.post({
+                        analytic,
+                        detection: detection !== 'ANY' ? detection : null,
+                        type,
+                        keys: displayFields
+                    }), {
+                    logError: false,
+                    showError: true,
+                    throwError: true
+                });
+                setSelectedTemplate(result);
+                const newList = [result, ...templateList];
+                setTemplateList(newList.filter((v1, i) => newList.findIndex(v2 => v1.template_id === v2.template_id) === i));
+            }
+            finally {
+                setTemplateLoading(false);
+            }
+        }
+    }, [analytic, detection, dispatchApi, displayFields, selectedTemplate, templateList, type]);
+    const analyticOrDetectionMissing = useMemo(() => !analytic || !detection, [analytic, detection]);
+    const noFieldChange = useMemo(() => displayFields.length < 1 || isEqual(selectedTemplate?.keys ?? DEFAULT_FIELDS, displayFields), [displayFields, selectedTemplate?.keys]);
+    return (_jsxs(PageCenter, { maxWidth: "1500px", textAlign: "left", height: "100%", children: [_jsx(LinearProgress, { sx: { mb: 1, opacity: +loading } }), _jsxs(Stack, { direction: "column", spacing: 2, divider: _jsx(Divider, { orientation: "horizontal", flexItem: true }), height: "100%", children: [_jsxs(Stack, { direction: "row", spacing: 2, mb: 2, alignItems: "stretch", children: [_jsx(FormControl, { sx: { flex: 1, maxWidth: '450px' }, children: _jsx(Autocomplete, { id: "analytic", options: analytics.sort((a, b) => a.name.toLowerCase().localeCompare(b.name.toLowerCase())), getOptionLabel: option => option.name, value: analytics.find(a => a.name === analytic) || null, onChange: (__, newValue) => setAnalytic(newValue ? newValue.name : ''), renderInput: autocompleteAnalyticParams => (_jsx(TextField, { ...autocompleteAnalyticParams, label: t('route.templates.analytic'), size: "small" })) }) }), !(detections?.length < 2 && detections[0]?.toLowerCase() === 'rule') ? (_jsx(FormControl, { sx: { flex: 1, maxWidth: '300px' }, disabled: !analytic, children: _jsx(Autocomplete, { id: "detection", options: ['ANY', ...detections.sort()], getOptionLabel: option => option, value: detection ?? '', onChange: (__, newValue) => setDetection(newValue), renderInput: autocompleteDetectionParams => (_jsx(TextField, { ...autocompleteDetectionParams, label: t('route.templates.detection'), size: "small" })) }) })) : (_jsx(Tooltip, { title: t('route.templates.rule.explanation'), children: _jsx(SsidChart, { color: "info", sx: { alignSelf: 'center' } }) })), _jsxs(ToggleButtonGroup, { sx: { display: 'grid', gridTemplateColumns: '1fr 1fr' }, size: "small", exclusive: true, value: type, disabled: analyticOrDetectionMissing, onChange: (__, _type) => {
+                                    if (_type) {
+                                        setType(_type);
+                                    }
+                                }, children: [_jsx(ToggleButton, { sx: { flex: 1 }, value: "personal", "aria-label": "personal", children: t('route.templates.personal') }), _jsx(ToggleButton, { sx: { flex: 1 }, value: "global", "aria-label": "global", children: t('route.templates.global') })] }), selectedTemplate && (_jsx(Button, { variant: "outlined", startIcon: _jsx(Delete, {}), onClick: onDelete, children: t('button.delete') })), _jsx(Button, { variant: "outlined", disabled: analyticOrDetectionMissing || noFieldChange, startIcon: templateLoading ? _jsx(CircularProgress, { size: 16 }) : _jsx(Check, {}), onClick: onSave, children: t(!analyticOrDetectionMissing && !noFieldChange ? 'button.save' : 'button.saved') })] }), analyticOrDetectionMissing ? (_jsx(AppInfoPanel, { i18nKey: "route.templates.select", sx: { width: '100%', alignSelf: 'start' } })) : (_jsx(TemplateEditor, { hit: exampleHit, fields: displayFields, setFields: setDisplayFields, onAdd: field => setDisplayFields([...displayFields, field]), onRemove: field => setDisplayFields(displayFields.filter(f => f !== field)) }))] })] }));
+};
+export default TemplateViewer;

package/components/routes/templates/Templates.d.ts

@@ -0,0 +1,2 @@
+declare const Templates: () => import("react/jsx-runtime").JSX.Element;
+export default Templates;

package/components/routes/templates/Templates.js

@@ -0,0 +1,109 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Article } from '@mui/icons-material';
+import { Stack, ToggleButton, ToggleButtonGroup, Typography } from '@mui/material';
+import api from '@cccsaurora/howler-ui/api';
+import { useAppUser } from '@cccsaurora/howler-ui/commons/components/app/hooks';
+import { TuiListProvider } from '@cccsaurora/howler-ui/components/elements/addons/lists';
+import { TuiListMethodContext } from '@cccsaurora/howler-ui/components/elements/addons/lists/TuiListProvider';
+import ItemManager from '@cccsaurora/howler-ui/components/elements/display/ItemManager';
+import useMyApi from '@cccsaurora/howler-ui/components/hooks/useMyApi';
+import { useMyLocalStorageItem } from '@cccsaurora/howler-ui/components/hooks/useMyLocalStorage';
+import { useCallback, useContext, useEffect, useState } from 'react';
+import { useTranslation } from 'react-i18next';
+import { useNavigate, useSearchParams } from 'react-router-dom';
+import { StorageKey } from '@cccsaurora/howler-ui/utils/constants';
+import TemplateCard from './TemplateCard';
+const TemplatesBase = () => {
+    const { t } = useTranslation();
+    const { user } = useAppUser();
+    const navigate = useNavigate();
+    const { dispatchApi } = useMyApi();
+    const [searchParams, setSearchParams] = useSearchParams();
+    const { load } = useContext(TuiListMethodContext);
+    const pageCount = useMyLocalStorageItem(StorageKey.PAGE_COUNT, 25)[0];
+    const [phrase, setPhrase] = useState('');
+    const [offset, setOffset] = useState(parseInt(searchParams.get('offset')) || 0);
+    const [response, setResponse] = useState(null);
+    const [types, setTypes] = useState([]);
+    const [hasError, setHasError] = useState(false);
+    const [searching, setSearching] = useState(false);
+    const onSearch = useCallback(async () => {
+        try {
+            setSearching(true);
+            setHasError(false);
+            if (phrase) {
+                searchParams.set('phrase', phrase);
+            }
+            else {
+                searchParams.delete('phrase');
+            }
+            setSearchParams(searchParams, { replace: true });
+            // Check for the actual search query
+            const phraseQuery = phrase ? `*:*${phrase}*` : '*:*';
+            // Ensure the template should be visible and/or matches the type we are filtering for
+            const typeQuery = `(type:global OR owner:(${user.username} OR none)) AND type:(${types.join(' ') || '*'})`;
+            setResponse(await dispatchApi(api.search.template.post({
+                query: `${phraseQuery} AND ${typeQuery}`,
+                rows: pageCount,
+                offset
+            })));
+        }
+        catch (e) {
+            setHasError(true);
+        }
+        finally {
+            setSearching(false);
+        }
+    }, [phrase, setSearchParams, searchParams, user.username, types, dispatchApi, pageCount, offset]);
+    // Load the items into list when response changes.
+    // This hook should only trigger when the 'response' changes.
+    useEffect(() => {
+        if (response) {
+            load(response.items.map((item) => ({
+                id: item.template_id,
+                item,
+                selected: false,
+                cursor: false
+            })));
+        }
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, [response, load]);
+    const onPageChange = useCallback((_offset) => {
+        if (_offset !== offset) {
+            searchParams.set('offset', _offset.toString());
+            setSearchParams(searchParams, { replace: true });
+            setOffset(_offset);
+        }
+    }, [offset, searchParams, setSearchParams]);
+    useEffect(() => {
+        onSearch();
+        if (!searchParams.has('offset')) {
+            searchParams.set('offset', '0');
+            setSearchParams(searchParams, { replace: true });
+        }
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, [dispatchApi, types]);
+    useEffect(() => {
+        if (response?.total <= offset) {
+            setOffset(0);
+            searchParams.set('offset', '0');
+            setSearchParams(searchParams, { replace: true });
+        }
+    }, [offset, response?.total, searchParams, setSearchParams]);
+    useEffect(() => {
+        if (!searching) {
+            onSearch();
+        }
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, [offset]);
+    const renderer = useCallback((item, className) => _jsx(TemplateCard, { template: item, className: className }), []);
+    return (_jsx(ItemManager, { onSearch: onSearch, onPageChange: onPageChange, phrase: phrase, setPhrase: setPhrase, hasError: hasError, searching: searching, searchFilters: _jsx(Stack, { direction: "row", spacing: 1, alignItems: "center", children: _jsxs(ToggleButtonGroup, { sx: { display: 'grid', gridTemplateColumns: '1fr 1fr', alignSelf: 'start' }, size: "small", value: types, onChange: (__, _types) => {
+                    if (_types) {
+                        setTypes(_types.length < 2 ? _types : []);
+                    }
+                }, children: [_jsx(ToggleButton, { value: "personal", "aria-label": "personal", children: t('route.templates.manager.personal') }), _jsx(ToggleButton, { value: "global", "aria-label": "global", children: t('route.templates.manager.global') })] }) }), aboveSearch: _jsx(Typography, { sx: theme => ({ fontStyle: 'italic', color: theme.palette.text.disabled, mb: 0.5 }), variant: "body2", children: t('route.templates.search.prompt') }), renderer: ({ item }, classRenderer) => renderer(item.item, classRenderer()), response: response, onSelect: (item) => navigate(`/templates/view?type=${item.item.type}&analytic=${item.item.analytic}${item.item.detection ? '&detection=' + item.item.detection : ''}`), onCreate: () => navigate('/templates/view'), createPrompt: "route.templates.create", searchPrompt: "route.templates.manager.search", createIcon: _jsx(Article, { sx: { mr: 1 } }) }));
+};
+const Templates = () => {
+    return (_jsx(TuiListProvider, { children: _jsx(TemplatesBase, {}) }));
+};
+export default Templates;

package/components/routes/views/ViewComposer.d.ts

@@ -0,0 +1,3 @@
+import type { FC } from 'react';
+declare const ViewComposer: FC;
+export default ViewComposer;

package/components/routes/views/ViewComposer.js

@@ -0,0 +1,175 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useCallback, useEffect, useState } from 'react';
+import { useTranslation } from 'react-i18next';
+import { HelpOutline, Save } from '@mui/icons-material';
+import { Alert, Checkbox, CircularProgress, Divider, LinearProgress, Stack, TextField, ToggleButton, ToggleButtonGroup, Tooltip, Typography } from '@mui/material';
+import api from '@cccsaurora/howler-ui/api';
+import AppListEmpty from '@cccsaurora/howler-ui/commons/components/display/AppListEmpty';
+import PageCenter from '@cccsaurora/howler-ui/commons/components/pages/PageCenter';
+import { HitContext } from '@cccsaurora/howler-ui/components/app/providers/HitProvider';
+import { ParameterContext } from '@cccsaurora/howler-ui/components/app/providers/ParameterProvider';
+import { ViewContext } from '@cccsaurora/howler-ui/components/app/providers/ViewProvider';
+import CustomButton from '@cccsaurora/howler-ui/components/elements/addons/buttons/CustomButton';
+import FlexPort from '@cccsaurora/howler-ui/components/elements/addons/layout/FlexPort';
+import VSBox from '@cccsaurora/howler-ui/components/elements/addons/layout/vsbox/VSBox';
+import VSBoxContent from '@cccsaurora/howler-ui/components/elements/addons/layout/vsbox/VSBoxContent';
+import VSBoxHeader from '@cccsaurora/howler-ui/components/elements/addons/layout/vsbox/VSBoxHeader';
+import SearchTotal from '@cccsaurora/howler-ui/components/elements/addons/search/SearchTotal';
+import HitCard from '@cccsaurora/howler-ui/components/elements/hit/HitCard';
+import { HitLayout } from '@cccsaurora/howler-ui/components/elements/hit/HitLayout';
+import useMyApi from '@cccsaurora/howler-ui/components/hooks/useMyApi';
+import { useMyLocalStorageItem } from '@cccsaurora/howler-ui/components/hooks/useMyLocalStorage';
+import useMySnackbar from '@cccsaurora/howler-ui/components/hooks/useMySnackbar';
+import { useNavigate, useParams } from 'react-router-dom';
+import { useContextSelector } from 'use-context-selector';
+import { StorageKey } from '@cccsaurora/howler-ui/utils/constants';
+import { convertDateToLucene } from '@cccsaurora/howler-ui/utils/utils';
+import ErrorBoundary from '../ErrorBoundary';
+import HitQuery from '../hits/search/HitQuery';
+import HitSort from '../hits/search/shared/HitSort';
+import SearchSpan from '../hits/search/shared/SearchSpan';
+const ViewComposer = () => {
+    const { t } = useTranslation();
+    const { dispatchApi } = useMyApi();
+    const { showSuccessMessage, showErrorMessage } = useMySnackbar();
+    const routeParams = useParams();
+    const navigate = useNavigate();
+    const addView = useContextSelector(ViewContext, ctx => ctx.addView);
+    const editView = useContextSelector(ViewContext, ctx => ctx.editView);
+    const getCurrentView = useContextSelector(ViewContext, ctx => ctx.getCurrentView);
+    const pageCount = useMyLocalStorageItem(StorageKey.PAGE_COUNT, 25)[0];
+    const loadHits = useContextSelector(HitContext, ctx => ctx.loadHits);
+    // view state
+    const [title, setTitle] = useState('');
+    const [type, setType] = useState('global');
+    const [advanceOnTriage, setAdvanceOnTriage] = useState(false);
+    const query = useContextSelector(ParameterContext, ctx => ctx.query);
+    const setQuery = useContextSelector(ParameterContext, ctx => ctx.setQuery);
+    const sort = useContextSelector(ParameterContext, ctx => ctx.sort);
+    const setSort = useContextSelector(ParameterContext, ctx => ctx.setSort);
+    const span = useContextSelector(ParameterContext, ctx => ctx.span);
+    const setSpan = useContextSelector(ParameterContext, ctx => ctx.setSpan);
+    // Non-view state
+    const [loading, setLoading] = useState(false);
+    const [isSearchDirty, setIsSearchDirty] = useState(false);
+    const [searching, setSearching] = useState(false);
+    const [error, setError] = useState(null);
+    const [response, setResponse] = useState();
+    const onSave = useCallback(async () => {
+        setLoading(true);
+        try {
+            if (!routeParams.id) {
+                const newView = await addView({
+                    title,
+                    type,
+                    query,
+                    sort: sort || null,
+                    span: span || null,
+                    settings: {
+                        advance_on_triage: advanceOnTriage
+                    }
+                });
+                navigate(`/views/${newView.view_id}`);
+            }
+            else {
+                await editView(routeParams.id, {
+                    title,
+                    type,
+                    query,
+                    sort,
+                    span,
+                    settings: { advance_on_triage: advanceOnTriage }
+                });
+            }
+            showSuccessMessage(t(routeParams.id ? 'route.views.update.success' : 'route.views.create.success'));
+        }
+        catch (e) {
+            showErrorMessage(e.message);
+        }
+        finally {
+            setLoading(false);
+        }
+    }, [
+        routeParams.id,
+        showSuccessMessage,
+        t,
+        addView,
+        title,
+        type,
+        query,
+        sort,
+        span,
+        advanceOnTriage,
+        navigate,
+        editView,
+        showErrorMessage
+    ]);
+    const search = useCallback(async (_query) => {
+        setQuery(_query);
+        setSearching(true);
+        setError(null);
+        try {
+            const _response = await dispatchApi(api.search.hit.post({
+                rows: pageCount,
+                query: _query,
+                sort,
+                filters: span ? [`event.created:${convertDateToLucene(span)}`] : []
+            }), { showError: false, throwError: true });
+            loadHits(_response.items);
+            setResponse(_response);
+        }
+        catch (e) {
+            setError(e.message);
+        }
+        finally {
+            setSearching(false);
+        }
+    }, [dispatchApi, loadHits, pageCount, setQuery, sort, span]);
+    useEffect(() => {
+        search(query || 'howler.id:*');
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, []);
+    // We only run this when ancillary properties (i.e. filters, sorting) change
+    useEffect(() => {
+        if (query) {
+            search(query);
+        }
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, [sort, span]);
+    useEffect(() => {
+        if (!routeParams.id) {
+            return;
+        }
+        (async () => {
+            const viewToEdit = await getCurrentView();
+            if (!viewToEdit) {
+                setError('route.views.missing');
+                return;
+            }
+            else {
+                setError(null);
+            }
+            setTitle(viewToEdit.title);
+            setAdvanceOnTriage(viewToEdit.settings?.advance_on_triage ?? false);
+            setQuery(viewToEdit.query);
+            if (viewToEdit.sort) {
+                setSort(viewToEdit.sort);
+            }
+            if (viewToEdit.span) {
+                setSpan(viewToEdit.span);
+            }
+        })();
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, [routeParams.id, getCurrentView]);
+    return (_jsx(FlexPort, { children: _jsx(ErrorBoundary, { children: _jsx(PageCenter, { maxWidth: "1500px", textAlign: "left", height: "100%", children: _jsxs(VSBox, { top: 0, children: [_jsx(VSBoxHeader, { pb: 1, children: _jsxs(Stack, { spacing: 1, children: [error && (_jsx(Alert, { variant: "outlined", severity: "error", children: t(error) })), _jsxs(Stack, { direction: "row", spacing: 1, children: [_jsx(TextField, { label: t('route.views.name'), size: "small", value: title, onChange: e => setTitle(e.target.value), fullWidth: true }), _jsxs(ToggleButtonGroup, { sx: { display: 'grid', gridTemplateColumns: '1fr 1fr' }, size: "small", exclusive: true, value: type, onChange: (__, _type) => {
+                                                    if (_type) {
+                                                        setType(_type);
+                                                    }
+                                                }, children: [_jsx(ToggleButton, { value: "personal", "aria-label": "personal", children: t('route.views.manager.personal') }), _jsx(ToggleButton, { value: "global", "aria-label": "global", children: t('route.views.manager.global') })] }), _jsx(CustomButton, { variant: "outlined", disabled: !title || !type || !query || !response || loading || searching || isSearchDirty, startIcon: loading ? _jsx(CircularProgress, { size: 20 }) : _jsx(Save, {}), onClick: onSave, children: t('save') })] }), _jsx(Typography, { sx: theme => ({
+                                            color: theme.palette.text.secondary,
+                                            fontSize: '0.9em',
+                                            fontStyle: 'italic',
+                                            mb: 0.5
+                                        }), variant: "body2", children: t('hit.search.prompt') }), _jsx(HitQuery, { triggerSearch: search, searching: searching, onChange: (_query, isDirty) => setIsSearchDirty(isDirty) }), _jsxs(Stack, { direction: "row", spacing: 1, sx: { '& > :not(.MuiDivider-root)': { flex: 1 } }, divider: _jsx(Divider, { flexItem: true, orientation: "vertical" }), children: [_jsx(HitSort, {}), _jsx(SearchSpan, { omitCustom: true }), _jsxs(Stack, { spacing: 1, direction: "row", alignItems: "center", sx: { flex: '0 !important', minWidth: '300px' }, children: [_jsx(Typography, { component: "span", children: t('view.settings.advance_on_triage') }), _jsx(Tooltip, { title: t('view.settings.advance_on_triage.description'), children: _jsx(HelpOutline, { sx: { fontSize: '16px' } }) }), _jsx(Checkbox, { size: "small", checked: advanceOnTriage, onChange: (_event, checked) => setAdvanceOnTriage(checked) })] })] }), response?.total ? (_jsx(SearchTotal, { total: response.total, pageLength: response.items.length, offset: response.offset, sx: theme => ({ color: theme.palette.text.secondary, fontSize: '0.9em', fontStyle: 'italic' }) })) : null, _jsx(LinearProgress, { sx: [!searching && { opacity: 0 }] })] }) }), _jsx(VSBoxContent, { children: _jsxs(Stack, { spacing: 1, children: [!response?.total && _jsx(AppListEmpty, {}), response?.items.map(hit => (_jsx(HitCard, { id: hit.howler.id, layout: HitLayout.DENSE }, hit.howler.id)))] }) })] }) }) }) }));
+};
+export default ViewComposer;

package/components/routes/views/Views.d.ts

@@ -0,0 +1,2 @@
+declare const Views: () => import("react/jsx-runtime").JSX.Element;
+export default Views;