@cccsaurora/howler-ui 2.12.1 → 2.13.0-dev.75

package/api/search/facet/hit.d.ts

@@ -1,3 +1,5 @@
 import type { HowlerFacetSearchRequest, HowlerFacetSearchResponse } from '@cccsaurora/howler-ui/api/search/facet';
-export declare const uri: (field: string) => string;
-export declare const post: (field: string, request?: HowlerFacetSearchRequest) => Promise<HowlerFacetSearchResponse>;
+export declare const uri: () => string;
+export declare const post: (request?: HowlerFacetSearchRequest) => Promise<{
+    [index: string]: HowlerFacetSearchResponse;
+}>;

package/api/search/facet/hit.js

@@ -1,8 +1,8 @@
-import { hpost, joinAllUri } from '@cccsaurora/howler-ui/api';
+import { hpost, joinUri } from '@cccsaurora/howler-ui/api';
 import { uri as parentUri } from '@cccsaurora/howler-ui/api/search/facet';
-export const uri = (field) => {
-    return joinAllUri(parentUri(), 'hit', field);
+export const uri = () => {
+    return joinUri(parentUri(), 'hit');
 };
-export const post = (field, request) => {
-    return hpost(uri(field), { ...(request || {}), query: request?.query || 'howler.id:*' });
+export const post = (request) => {
+    return hpost(uri(), { ...(request || {}), query: request?.query || 'howler.id:*' });
 };

package/api/search/facet/index.d.ts

@@ -1,6 +1,7 @@
 import * as hit from '@cccsaurora/howler-ui/api/search/facet/hit';
 export declare const uri: () => string;
 export type HowlerFacetSearchRequest = {
+    fields?: string[];
     query?: string;
     mincount?: number;
     rows?: number;

package/components/elements/hit/HitSummary.js

@@ -84,10 +84,10 @@ const HitSummary = ({ query, response, onStart, onComplete }) => {
             setAggregateResults({});
             // Sort the fields based on the number of occurrences
             const sortedKeys = Object.keys(_keyCounts).sort((a, b) => (_keyCounts[b]?.count ?? 0) - (_keyCounts[a]?.count ?? 0));
-            setLoading(true);
-            // Facet each field
-            for (const key of sortedKeys) {
-                const result = await dispatchApi(api.search.facet.hit.post(key, {
+            if (sortedKeys.length > 0) {
+                setLoading(true);
+                const result = await dispatchApi(api.search.facet.hit.post({
+                    fields: sortedKeys,
                     query,
                     rows: pageCount,
                     filters
@@ -99,7 +99,7 @@ const HitSummary = ({ query, response, onStart, onComplete }) => {
                 if (result) {
                     setAggregateResults(_results => ({
                         ..._results,
-                        [key]: result
+                        ...result
                     }));
                 }
             }

package/components/elements/hit/aggregate/HitGraph.js

@@ -41,7 +41,6 @@ const HitGraph = ({ query }) => {
     const addHitToSelection = useContextSelector(HitContext, ctx => ctx.addHitToSelection);
     const removeHitFromSelection = useContextSelector(HitContext, ctx => ctx.removeHitFromSelection);
     const viewId = useContextSelector(HitSearchContext, ctx => ctx.viewId);
-    const searching = useContextSelector(HitSearchContext, ctx => ctx.searching);
     const error = useContextSelector(HitSearchContext, ctx => ctx.error);
     const chartRef = useRef();
     const [loading, setLoading] = useState(false);
@@ -63,6 +62,9 @@ const HitGraph = ({ query }) => {
             else if (startDate && endDate) {
                 filters.push(`event.created:${convertCustomDateRangeToLucene(startDate, endDate)}`);
             }
+            if (escalationFilter) {
+                filters.push(`howler.escalation:${escalationFilter}`);
+            }
             const total = (await dispatchApi(api.search.count.hit.post({
                 query,
                 filters
@@ -75,13 +77,8 @@ const HitGraph = ({ query }) => {
             else {
                 setDisabled(false);
             }
-            const subQueries = [query || 'howler.id:*'];
-            if (escalationFilter) {
-                subQueries.push(`howler.escalation:${escalationFilter}`);
-            }
-            const graphQuery = subQueries.map(_query => `(${_query})`).join(' AND ');
             const _data = await dispatchApi(api.search.grouped.hit.post(filterField, {
-                query: graphQuery,
+                query: query || 'howler.id:*',
                 fl: 'event.created,howler.assessment,howler.analytic,howler.detection,howler.outline.threat,howler.outline.target,howler.outline.summary,howler.id',
                 // We want a generally random sample across all date ranges, so we use hash.
                 // If we used event.created instead, when 1 million hits/hour are created, you'd only see hits from this past minute
@@ -116,12 +113,12 @@ const HitGraph = ({ query }) => {
         }
     }, [dispatchApi, endDate, escalationFilter, filterField, override, query, span, startDate]);
     useEffect(() => {
-        if ((!query && !viewId) || searching || error) {
+        if ((!query && !viewId) || error) {
             return;
         }
         performQuery();
         // eslint-disable-next-line react-hooks/exhaustive-deps
-    }, [query, viewId, searching, error]);
+    }, [query, viewId, error, span]);
     const options = useMemo(() => {
         const parentOptions = scatter('hit.summary.title', 'hit.summary.subtitle');
         return {

package/components/routes/advanced/luceneCompletionProvider.js

@@ -41,10 +41,12 @@ const useLuceneCompletionProvider = () => {
                     };
                 }
                 else {
-                    const options = await api.search.facet.hit.post(key, { query: 'howler.id:*', rows: 250 }).catch(() => ({}));
+                    const options = await api.search.facet.hit
+                        .post({ query: 'howler.id:*', rows: 250, fields: [key] })
+                        .catch(() => ({}));
                     const _position = model.getWordUntilPosition(position);
                     return {
-                        suggestions: Object.keys(options).map(_value => ({
+                        suggestions: Object.keys(options[key] || {}).map(_value => ({
                             label: _value,
                             kind: monaco.languages.CompletionItemKind.Constant,
                             insertText: `"${_value}"`,

package/components/routes/analytics/widgets/Assessment.js

@@ -18,10 +18,11 @@ const Assessment = forwardRef(({ analytic }, ref) => {
         }
         setLoading(true);
         api.search.facet.hit
-            .post('howler.assessment', {
+            .post({
+            fields: ['howler.assessment'],
             query: `howler.analytic:("${analytic.name}")`
         })
-            .then(data => setAssessmentData(data))
+            .then(data => setAssessmentData(data['howler.assessment']))
             .finally(() => setLoading(false));
     }, [analytic]);
     if (!loading && assessmentData.length < 1) {

package/components/routes/analytics/widgets/Escalation.js

@@ -18,10 +18,11 @@ const Escalation = forwardRef(({ analytic, maxWidth = '45%' }, ref) => {
         }
         setLoading(true);
         api.search.facet.hit
-            .post('howler.escalation', {
-            query: `howler.analytic:("${analytic.name}")`
+            .post({
+            query: `howler.analytic:("${analytic.name}")`,
+            fields: ['howler.escalation']
         })
-            .then(data => setEscalationData(data))
+            .then(data => setEscalationData(data['howler.escalation']))
             .finally(() => setLoading(false));
     }, [analytic]);
     return analytic && !loading ? (_jsx("div", { style: { maxWidth }, children: _jsx(Doughnut, { ref: ref, options: doughnut('route.analytics.escalation.title', ''), data: {

package/components/routes/analytics/widgets/Stacked.js

@@ -13,10 +13,11 @@ const Stacked = forwardRef(({ analytic, field, color }, ref) => {
     const fetchData = useCallback(async () => {
         try {
             setLoading(true);
-            const result = await api.search.facet.hit.post(field, {
-                query: `howler.analytic:("${analytic.name}")`
+            const result = await api.search.facet.hit.post({
+                query: `howler.analytic:("${analytic.name}")`,
+                fields: [field]
             });
-            const values = Object.entries(result)
+            const values = Object.entries(result[field])
                 .sort(([__, valA], [___, valB]) => valB - valA)
                 .map(([key]) => key);
             setDatasets(await Promise.all(values.map(async (_value) => {

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

@@ -42,8 +42,8 @@ const HitFilter = ({ size }) => {
         setFilter('');
         setSavedFilter(null);
         if (!config.lookups[_category]) {
-            const facets = await api.search.facet.hit.post(_category, { query: 'howler.id:*' });
-            setCustomLookups(Object.keys(facets));
+            const facets = await api.search.facet.hit.post({ query: 'howler.id:*', fields: [_category] });
+            setCustomLookups(Object.keys(facets[_category]));
         }
         else {
             setCustomLookups([]);

package/package.json

@@ -96,7 +96,7 @@
     "internal-slot": "1.0.7"
   },
   "type": "module",
-  "version": "2.12.1",
+  "version": "2.13.0-dev.75",
   "exports": {
     "./i18n": "./i18n.js",
     "./index.css": "./index.css",
@@ -201,6 +201,10 @@
     "./components/routes/analytics/widgets/*": "./components/routes/analytics/widgets/*.js",
     "./components/logins/hooks/*": "./components/logins/hooks/*.js",
     "./components/logins/auth/*": "./components/logins/auth/*.js",
+    "./plugins/borealis/*": "./plugins/borealis/*.js",
+    "./plugins/borealis": "./plugins/borealis/index.js",
+    "./plugins/borealis/components/*": "./plugins/borealis/components/*.js",
+    "./plugins/borealis/locales/*": "./plugins/borealis/locales/*.js",
     "./api/search/*": "./api/search/*.js",
     "./api/search": "./api/search/index.js",
     "./api/analytic/*": "./api/analytic/*.js",

package/plugins/borealis/Provider.d.ts

@@ -0,0 +1,3 @@
+import { type PropsWithChildren } from 'react';
+declare const Provider: React.FC<PropsWithChildren<{}>>;
+export default Provider;

package/plugins/borealis/Provider.js

@@ -0,0 +1,14 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { BorealisProvider } from 'borealis-ui/dist/hooks/BorealisProvider';
+import { ApiConfigContext } from '@cccsaurora/howler-ui/components/app/providers/ApiConfigProvider';
+import { useContext } from 'react';
+import { useTranslation } from 'react-i18next';
+import { StorageKey } from '@cccsaurora/howler-ui/utils/constants';
+import { getStored } from '@cccsaurora/howler-ui/utils/localStorage';
+const Provider = ({ children }) => {
+    const apiConfig = useContext(ApiConfigContext);
+    return (_jsx(BorealisProvider, { baseURL: location.origin + '/api/v1/borealis', getToken: () => getStored(StorageKey.APP_TOKEN), enabled: apiConfig.config?.configuration?.features?.borealis, publicIconify: false, customIconify: location.origin.includes('localhost')
+            ? 'https://icons.dev.analysis.cyber.gc.ca'
+            : location.origin.replace(/howler(-stg)?/, 'icons'), defaultTimeout: 5, i18next: useTranslation('borealis'), chunkSize: 50, children: children }));
+};
+export default Provider;

package/plugins/borealis/components/BorealisChip.d.ts

@@ -0,0 +1,3 @@
+import type { PluginChipProps } from '@cccsaurora/howler-ui/components/elements/PluginChip';
+declare const _default: import("react").NamedExoticComponent<PluginChipProps>;
+export default _default;

package/plugins/borealis/components/BorealisChip.js

@@ -0,0 +1,27 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { Chip } from '@mui/material';
+import { EnrichedChip, useBorealisEnrichSelector } from 'borealis-ui';
+import { memo } from 'react';
+const BorealisChip = ({ children, value, context, ...props }) => {
+    const guessType = useBorealisEnrichSelector(ctx => ctx.guessType);
+    const type = guessType(value);
+    if (!type) {
+        return _jsx(Chip, { ...props, children: children });
+    }
+    let enrichedProps = {
+        ...props,
+        value
+    };
+    delete enrichedProps.label;
+    if (context === 'summary') {
+        enrichedProps = {
+            ...enrichedProps,
+            sx: [
+                ...(Array.isArray(enrichedProps.sx) ? enrichedProps.sx : [enrichedProps.sx]),
+                [{ height: '24px', '& .iconify': { fontSize: '1em' } }]
+            ]
+        };
+    }
+    return _jsx(EnrichedChip, { ...enrichedProps, type: type });
+};
+export default memo(BorealisChip);

package/plugins/borealis/components/BorealisLeadForm.d.ts

@@ -0,0 +1,4 @@
+import type { LeadFormProps } from '@cccsaurora/howler-ui/components/routes/dossiers/LeadEditor';
+import { type FC } from 'react';
+declare const BorealisLeadForm: FC<LeadFormProps>;
+export default BorealisLeadForm;

package/plugins/borealis/components/BorealisLeadForm.js

@@ -0,0 +1,23 @@
+import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
+import { Autocomplete, Divider, ListItemText, TextField, Typography } from '@mui/material';
+import { useBorealisEnrichSelector, useBorealisFetcherSelector } from 'borealis-ui';
+import { ApiConfigContext } from '@cccsaurora/howler-ui/components/app/providers/ApiConfigProvider';
+import { useContext, useState } from 'react';
+import { useTranslation } from 'react-i18next';
+const BorealisLeadForm = ({ lead, metadata, update, updateMetadata }) => {
+    const { t } = useTranslation();
+    const { config } = useContext(ApiConfigContext);
+    const fetchers = useBorealisFetcherSelector(ctx => ctx.fetchers);
+    const types = useBorealisEnrichSelector(ctx => ctx.typesDetection);
+    const [showCustom, setShowCustom] = useState(false);
+    return (_jsxs(_Fragment, { children: [_jsx(Divider, { orientation: "horizontal" }), _jsx(Autocomplete, { disabled: !lead, options: Object.keys(fetchers), renderInput: params => _jsx(TextField, { ...params, size: "small", label: t('route.dossiers.manager.borealis') }), value: Object.keys(fetchers).includes(lead?.content) ? lead.content : '', onChange: (_ev, content) => update({ content, metadata: '{}' }), renderOption: (props, option) => (_jsx(ListItemText, { ...props, sx: { flexDirection: 'column', alignItems: 'start !important' }, primary: _jsx("code", { children: option }), secondary: fetchers[option].description })) }), _jsx(Autocomplete, { options: Object.keys(types), renderInput: params => _jsx(TextField, { ...params, size: "small", label: t('route.dossiers.manager.borealis.type') }), value: metadata?.type ?? '', onChange: (_ev, type) => updateMetadata({ type }) }), _jsx(Autocomplete, { options: ['custom', ...Object.keys(config.indexes.hit)], disabled: !metadata?.type || !types[metadata.type], renderInput: params => (_jsx(TextField, { ...params, size: "small", label: t('route.dossiers.manager.borealis.value') })), getOptionLabel: opt => t(opt), value: metadata?.value ?? '', onChange: (_ev, value) => {
+                    if (value === 'custom') {
+                        setShowCustom(true);
+                    }
+                    else {
+                        setShowCustom(false);
+                        updateMetadata({ value });
+                    }
+                } }), showCustom && (_jsxs(_Fragment, { children: [_jsx(TextField, { size: "small", label: t('route.dossiers.manager.borealis.value.custom'), value: metadata?.value ?? '', disabled: !metadata?.type || !types[metadata.type], fullWidth: true, onChange: ev => updateMetadata({ value: ev.target.value }) }), _jsx(Typography, { variant: "caption", color: "text.secondary", sx: { mt: '0 !important' }, children: t('route.dossiers.manager.borealis.value.description') })] }))] }));
+};
+export default BorealisLeadForm;

package/plugins/borealis/components/BorealisPivot.d.ts

@@ -0,0 +1,3 @@
+import type { PivotLinkProps } from '@cccsaurora/howler-ui/components/elements/hit/related/PivotLink';
+declare const _default: import("react").NamedExoticComponent<PivotLinkProps>;
+export default _default;

package/plugins/borealis/components/BorealisPivot.js

@@ -0,0 +1,83 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Icon } from '@iconify/react/dist/iconify.js';
+import { Settings } from '@mui/icons-material';
+import { Divider, IconButton, Stack, Typography } from '@mui/material';
+import { useBorealisActionsSelector, useBorealisEnrichSelector } from 'borealis-ui';
+import HowlerCard from '@cccsaurora/howler-ui/components/elements/display/HowlerCard';
+import useMySnackbar from '@cccsaurora/howler-ui/components/hooks/useMySnackbar';
+import { get } from 'lodash-es';
+import { memo, useCallback, useState } from 'react';
+import { useTranslation } from 'react-i18next';
+const BorealisPivot = ({ pivot, hit, compact }) => {
+    const guessType = useBorealisEnrichSelector(ctx => ctx?.guessType);
+    const { showErrorMessage } = useMySnackbar();
+    const { i18n, t } = useTranslation();
+    const actions = useBorealisActionsSelector(ctx => ctx?.availableActions ?? {});
+    const executeAction = useBorealisActionsSelector(ctx => ctx?.executeAction);
+    const [loading, setLoading] = useState(false);
+    const onBorealisClick = useCallback(async (event, forceMenu = false) => {
+        event.preventDefault();
+        event.stopPropagation();
+        if (loading) {
+            return;
+        }
+        if (!actions[pivot.value]) {
+            showErrorMessage(t('pivot.borealis.missing'));
+            return;
+        }
+        setLoading(true);
+        const data = Object.fromEntries(pivot.mappings.map(_mapping => {
+            const value = _mapping.field !== 'custom' ? get(hit, _mapping.field) : _mapping.custom_value;
+            if (['selector', 'selectors'].includes(_mapping.key)) {
+                if (Array.isArray(value)) {
+                    return [
+                        _mapping.key,
+                        value.map(val => ({
+                            // TODO: Use the mapped borealis values here eventually
+                            type: guessType(val),
+                            value: val
+                        }))
+                    ];
+                }
+                return [
+                    _mapping.key,
+                    {
+                        // TODO: Use the mapped borealis values here eventually
+                        type: guessType(value),
+                        value
+                    }
+                ];
+            }
+            return [_mapping.key, value];
+        }));
+        const selectors = (actions[pivot.value].accept_multiple ? [data.selectors] : [data.selector]).flat();
+        delete data.selector;
+        delete data.selectors;
+        try {
+            await executeAction(pivot.value, selectors, data, { forceMenu });
+        }
+        finally {
+            setLoading(false);
+        }
+    }, [actions, executeAction, guessType, hit, loading, pivot.mappings, pivot.value, showErrorMessage, t]);
+    if (!actions[pivot.value]) {
+        return;
+    }
+    return (_jsx(HowlerCard, { variant: compact ? 'outlined' : 'elevation', onClick: e => onBorealisClick(e), sx: [
+            theme => ({
+                backgroundColor: 'transparent',
+                transition: theme.transitions.create(['border-color']),
+                '&:hover': { borderColor: 'primary.main' },
+                '& > div': {
+                    height: '100%'
+                }
+            }),
+            loading
+                ? { opacity: 0.5, pointerEvents: 'none' }
+                : {
+                    cursor: 'pointer'
+                },
+            !compact && { border: 'thin solid', borderColor: 'transparent' }
+        ], children: _jsxs(Stack, { direction: "row", p: compact ? 0.5 : 1, spacing: 1, alignItems: "center", children: [_jsx(Icon, { fontSize: "1.5rem", icon: pivot.icon }), _jsx(Typography, { children: pivot.label[i18n.language] }), _jsx(Divider, { orientation: "vertical", flexItem: true }), _jsx(IconButton, { size: "small", onClick: e => onBorealisClick(e, true), children: _jsx(Settings, { fontSize: "small" }) })] }) }));
+};
+export default memo(BorealisPivot);

package/plugins/borealis/components/BorealisPivotForm.d.ts

@@ -0,0 +1,4 @@
+import type { PivotFormProps } from '@cccsaurora/howler-ui/components/routes/dossiers/PivotForm';
+import { type FC } from 'react';
+declare const BorealisPivotForm: FC<PivotFormProps>;
+export default BorealisPivotForm;

package/plugins/borealis/components/BorealisPivotForm.js

@@ -0,0 +1,44 @@
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import { Autocomplete, Divider, Stack, TextField, Typography, useTheme } from '@mui/material';
+import { useBorealisActionsSelector } from 'borealis-ui';
+import { ApiConfigContext } from '@cccsaurora/howler-ui/components/app/providers/ApiConfigProvider';
+import { Fragment, useContext } from 'react';
+import { useTranslation } from 'react-i18next';
+const BorealisPivotForm = ({ pivot, update }) => {
+    const theme = useTheme();
+    const { t } = useTranslation();
+    const { config } = useContext(ApiConfigContext);
+    const actions = useBorealisActionsSelector(ctx => ctx?.availableActions);
+    return (_jsxs(_Fragment, { children: [_jsx(Autocomplete, { fullWidth: true, disabled: !pivot, options: Object.entries(actions)
+                    .filter(([_key, definition]) => !!definition && definition.format == 'pivot')
+                    .map(([key]) => key), renderOption: ({ key, ...optionProps }, actionId) => {
+                    const definition = actions[actionId];
+                    return (_jsxs(Stack, { component: "li", ...optionProps, spacing: 1, children: [_jsxs(Stack, { direction: "row", spacing: 1, alignSelf: "start", alignItems: "center", children: [_jsx(Typography, { children: definition.name }), _jsx("pre", { style: {
+                                            fontSize: '0.85rem',
+                                            border: `thin solid ${theme.palette.divider}`,
+                                            padding: theme.spacing(0.5),
+                                            borderRadius: theme.shape.borderRadius
+                                        }, children: actionId })] }), _jsx(Typography, { variant: "body2", color: "text.secondary", alignSelf: "start", children: definition.summary })] }, key));
+                }, getOptionLabel: opt => actions[opt]?.name ?? '', renderInput: params => (_jsx(TextField, { ...params, size: "small", fullWidth: true, label: t('route.dossiers.manager.pivot.value') })), value: pivot?.value ?? '', onChange: (_ev, value) => update({
+                    value,
+                    mappings: [
+                        { key: actions[value].accept_multiple ? 'selectors' : 'selector', field: 'howler.id' },
+                        ...Object.entries(actions[value].params?.properties ?? [])
+                            .filter(([property]) => !['selector', 'selectors'].includes(property))
+                            .map(([prop, schema]) => ({
+                            key: prop,
+                            field: typeof schema === 'boolean' || !schema.default ? null : 'custom',
+                            custom_value: typeof schema !== 'boolean' && !!schema.default ? schema.default.toString() : null
+                        }))
+                    ]
+                }) }), _jsx(Divider, { flexItem: true }), _jsx(Typography, { children: t('route.dossiers.manager.pivot.mappings') }), pivot?.mappings?.map((_mapping, index) => (
+            // eslint-disable-next-line react/no-array-index-key
+            _jsxs(Fragment, { children: [_jsxs(Stack, { direction: "row", spacing: 1, children: [_jsx(TextField, { size: "small", label: t('route.dossiers.manager.pivot.mapping.key'), disabled: !pivot, value: _mapping?.key ?? '', onChange: ev => update({
+                                    mappings: pivot.mappings.map((_m, _index) => index === _index ? { ..._m, key: ev.target.value } : _m)
+                                }) }), _jsx(Autocomplete, { fullWidth: true, disabled: !pivot, options: ['custom', 'unset', ...Object.keys(config.indexes.hit)], renderInput: params => (_jsx(TextField, { ...params, size: "small", fullWidth: true, label: t('route.dossiers.manager.pivot.mapping.field'), sx: { minWidth: '150px' } })), getOptionLabel: opt => t(opt), value: _mapping.field ?? '', onChange: (_ev, field) => update({
+                                    mappings: pivot.mappings.map((_m, _index) => (index === _index ? { ..._m, field } : _m))
+                                }) })] }), _mapping.field === 'custom' && (_jsx(TextField, { size: "small", label: t('route.dossiers.manager.pivot.mapping.custom'), disabled: !pivot, value: _mapping?.custom_value ?? '', onChange: ev => update({
+                            mappings: pivot.mappings.map((_m, _index) => index === _index ? { ..._m, custom_value: ev.target.value } : _m)
+                        }) }))] }, index)))] }));
+};
+export default BorealisPivotForm;

package/plugins/borealis/components/BorealisTypography.d.ts

@@ -0,0 +1,3 @@
+import type { PluginTypographyProps } from '@cccsaurora/howler-ui/components/elements/PluginTypography';
+declare const _default: import("react").NamedExoticComponent<PluginTypographyProps>;
+export default _default;

package/plugins/borealis/components/BorealisTypography.js

@@ -0,0 +1,53 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { Typography } from '@mui/material';
+import { EnrichedTypography, useBorealisEnrichSelector } from 'borealis-ui';
+import { memo } from 'react';
+const BorealisTypography = ({ children, value, context, ...props }) => {
+    const guessType = useBorealisEnrichSelector(ctx => ctx.guessType);
+    const type = guessType(value);
+    if (!type) {
+        return _jsx(Typography, { ...props, children: children });
+    }
+    let enrichedProps = {
+        ...props,
+        value
+    };
+    if (context === 'banner') {
+        enrichedProps = {
+            ...enrichedProps,
+            slotProps: { stack: { component: 'span' } }
+        };
+    }
+    else if (context === 'outline') {
+        enrichedProps = {
+            ...enrichedProps,
+            hideLoading: true,
+            slotProps: {
+                stack: {
+                    sx: { mr: 'auto' },
+                    onClick: e => {
+                        e.preventDefault();
+                        e.stopPropagation();
+                    }
+                },
+                popover: {
+                    onClick: e => {
+                        e.preventDefault();
+                        e.stopPropagation();
+                    }
+                }
+            }
+        };
+    }
+    else if (context === 'table') {
+        enrichedProps = {
+            ...enrichedProps,
+            hideLoading: true,
+            slotProps: {
+                stack: { sx: { width: '100%', '& > p': { textOverflow: 'ellipsis', overflow: 'hidden' } } }
+            }
+        };
+    }
+    return _jsx(EnrichedTypography, { ...enrichedProps, type: type });
+};
+export default memo(BorealisTypography);

package/plugins/borealis/helpers.d.ts

@@ -0,0 +1,6 @@
+declare const HELPERS: {
+    keyword: string;
+    documentation: string;
+    componentCallback: (...args: any[]) => import("react/jsx-runtime").JSX.Element;
+}[];
+export default HELPERS;

package/plugins/borealis/helpers.js

@@ -0,0 +1,137 @@
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+/* eslint-disable no-console */
+import { Checkbox, Paper, Stack, Table, TableBody, TableCell, TableHead, TableRow } from '@mui/material';
+import { EnrichedTypography, Entry, Fetcher, Group, useBorealisEnrichSelector } from 'borealis-ui';
+import FlexOne from '@cccsaurora/howler-ui/components/elements/addons/layout/FlexOne';
+import i18nInstance from '@cccsaurora/howler-ui/i18n';
+import { capitalize, groupBy, uniq } from 'lodash-es';
+import { useState } from 'react';
+import { useTranslation } from 'react-i18next';
+const BorealisTypography = props => {
+    const { t } = useTranslation();
+    try {
+        const guessType = useBorealisEnrichSelector(ctx => ctx.guessType);
+        let type = props.type;
+        if (!type || type?.toLowerCase() === 'guess') {
+            type = guessType(props.value);
+        }
+        if (!type) {
+            return _jsx("span", { children: props.value });
+        }
+        return _jsx(EnrichedTypography, { ...props, type: type });
+    }
+    catch (err) {
+        return (_jsxs(Stack, { children: [_jsx("strong", { style: { color: 'red' }, children: t('markdown.error') }), _jsx("strong", { children: err.toString() }), _jsx("code", { style: { fontSize: '0.8rem' }, children: _jsx("pre", { children: err.stack }) })] }));
+    }
+};
+const BorealisGroup = props => {
+    if (!props.enabled) {
+        return _jsx(_Fragment, { children: props.children });
+    }
+    if (!props.type) {
+        console.error('Missing required props for group helper');
+        return (_jsxs(Stack, { spacing: 1, children: [_jsx("strong", { style: { color: 'red' }, children: i18nInstance.t('markdown.error') }), _jsxs("code", { style: { fontSize: '0.8rem' }, children: [i18nInstance.t('markdown.props.missing'), ": type"] })] }));
+    }
+    return _jsx(Group, { type: props.type, children: props.children });
+};
+const BorealisEntry = ({ value }) => {
+    const [checked, setChecked] = useState(false);
+    return (_jsx(Entry, { entry: value, selected: checked, children: _jsx(Paper, { sx: { p: 1 }, children: _jsxs(Stack, { direction: "row", spacing: 1, children: [_jsx(Checkbox, { checked: checked, onChange: (_event, _checked) => setChecked(_checked) }), _jsx(BorealisTypography, { value: value }), _jsx(FlexOne, {})] }) }) }));
+};
+const BorealisCheckbox = ({ value }) => {
+    const [checked, setChecked] = useState(false);
+    return (_jsx(Entry, { entry: value, selected: checked, children: _jsx(Checkbox, { checked: checked, onChange: (_event, _checked) => setChecked(_checked) }) }));
+};
+const HELPERS = [
+    {
+        keyword: 'borealis',
+        documentation: 'Given a selector, this helper enriches the selector through borealis.',
+        componentCallback: (type, value) => {
+            if (typeof type !== 'string' || typeof value !== 'string') {
+                return (_jsxs(Stack, { spacing: 1, children: [_jsx("strong", { style: { color: 'red' }, children: i18nInstance.t('markdown.error') }), _jsx("code", { style: { fontSize: '0.8rem' }, children: "You must provide at least two arguments: type and value." })] }));
+            }
+            return (_jsx(BorealisTypography, { slotProps: { stack: { component: 'span', sx: { width: 'fit-content' } } }, component: "span", type: type, value: typeof value === 'string' ? value : null }));
+        }
+    },
+    {
+        keyword: 'fetcher',
+        documentation: 'Given a selector, this helper fetches data for the selector through borealis.',
+        componentCallback: (...args) => {
+            const options = args.pop();
+            const props = options?.hash ?? {};
+            if (!props.type || !props.value || !props.fetcherId) {
+                console.error('Missing required props for fetcher helper');
+                return (_jsxs(Stack, { spacing: 1, children: [_jsx("strong", { style: { color: 'red' }, children: i18nInstance.t('markdown.error') }), _jsxs("code", { style: { fontSize: '0.8rem' }, children: [i18nInstance.t('markdown.props.missing'), ":", ' ', ['type', 'value', 'fetcherId'].filter(key => !props[key]).join(', ')] })] }));
+            }
+            console.debug(`Rendering fetcher (${props.fetcherId}) for selector ${props.type}:${props.value}`);
+            return (_jsx(Fetcher, { slotProps: { stack: { component: 'span', sx: { width: 'fit-content' } } }, component: "span", ...props }));
+        }
+    },
+    {
+        keyword: 'borealis_group',
+        documentation: 'Initializes a borealis group',
+        componentCallback: (values, ...args) => {
+            const options = args.pop();
+            const props = options?.hash ?? {};
+            const missing = [];
+            if (!Array.isArray(values)) {
+                missing.push('values');
+            }
+            if (!props.type) {
+                missing.push('type');
+            }
+            if (missing.length > 0) {
+                return (_jsxs(Stack, { spacing: 1, children: [_jsx("strong", { style: { color: 'red' }, children: i18nInstance.t('markdown.error') }), _jsxs("code", { style: { fontSize: '0.8rem' }, children: [i18nInstance.t('markdown.props.missing'), ": ", missing.join(', ')] })] }));
+            }
+            return (_jsx(BorealisGroup, { type: props.type, enabled: true, children: _jsx(Stack, { spacing: 1, mt: 1, children: uniq(values).map(value => (_jsx(BorealisEntry, { value: value }, value))) }) }));
+        }
+    },
+    {
+        keyword: 'borealis_table',
+        documentation: `Render a table with optional Borealis enrichments and actions.
+
+Borealis enrichments are performed for cells with a borealis_type.
+
+Borealis actions are enabled by specifying a borealis action type using the optional borealis_action_type parameter. If enabled, cells with borealis_entity==true will be selectable for use with Borealis enrichments and actions, with a value of action_value if present, and otherwise value.
+
+Example:
+\`\`\`markdown
+{{curly 'borealis_table borealis_table_cells borealis_action_type="ip"'}}
+\`\`\`
+where borealis_table_cells is an array with properties:
+
+\`\`\`
+  column: string;
+  row: string;
+  value: string;
+  borealis_type (optional): string;
+  borealis_entity (optional): boolean;
+  action_value (optional): string;
+\`\`\`
+    `,
+        componentCallback: (cells, ...args) => {
+            const options = args.pop();
+            const props = options?.hash ?? {};
+            const columns = Object.keys(groupBy(cells, 'column'));
+            const rows = groupBy(cells, 'row');
+            const enableBorealisActions = !props.borealis_action_type ? false : true;
+            const borealisActionType = !props.borealis_action_type ? 'false' : props.borealis_action_type;
+            return (_jsx(Paper, { sx: { width: '95%', overflowX: 'auto', m: 1 }, children: _jsx(BorealisGroup, { type: borealisActionType, enabled: enableBorealisActions, children: _jsxs(Table, { children: [_jsx(TableHead, { children: _jsx(TableRow, { children: columns.map(col => (_jsx(TableCell, { sx: { maxWidth: '150px' }, children: col
+                                            .split(/[_-]/)
+                                            .map(word => capitalize(word))
+                                            .join(' ') }, col))) }) }), _jsx(TableBody, { sx: { '& td': { wordBreak: 'break-word' } }, children: Object.entries(rows).map(([rowId, _cells]) => {
+                                    return (_jsx(TableRow, { children: columns.map(col => {
+                                            const cell = _cells.find(row => row.column === col);
+                                            return (_jsxs(TableCell, { children: [enableBorealisActions && cell.borealis_entity === true ? (_jsx(BorealisCheckbox, { value: cell.action_value ?? cell.value })) : null, typeof cell.borealis_type === 'string' ? (_jsx(BorealisTypography, { slotProps: {
+                                                            stack: {
+                                                                component: 'span',
+                                                                sx: { width: 'fit-content' },
+                                                                display: 'inline-flex'
+                                                            }
+                                                        }, component: "span", type: cell?.borealis_type, value: cell?.value })) : ((cell?.value ?? 'N/A'))] }, col + cell?.value));
+                                        }) }, rowId));
+                                }) })] }) }) }));
+        }
+    }
+];
+export default HELPERS;

package/plugins/borealis/index.d.ts

@@ -0,0 +1,21 @@
+import type { HowlerHelper } from '@cccsaurora/howler-ui/components/elements/display/handlebars/helpers';
+import type { PluginChipProps } from '@cccsaurora/howler-ui/components/elements/PluginChip';
+import type { PluginTypographyProps } from '@cccsaurora/howler-ui/components/elements/PluginTypography';
+import { type i18n as I18N } from 'i18next';
+import HowlerPlugin from '@cccsaurora/howler-ui/plugins/HowlerPlugin';
+declare class BorealisPlugin extends HowlerPlugin {
+    name: string;
+    version: string;
+    author: string;
+    description: string;
+    activate(): void;
+    provider(): import("react").FC<{
+        children?: import("react").ReactNode | undefined;
+    }>;
+    setup(): () => void;
+    localization(i18nInstance: I18N): void;
+    helpers(): HowlerHelper[];
+    typography(_props: PluginTypographyProps): import("react/jsx-runtime").JSX.Element;
+    chip(_props: PluginChipProps): import("react/jsx-runtime").JSX.Element;
+}
+export default BorealisPlugin;

package/plugins/borealis/index.js

@@ -0,0 +1,46 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { Box } from '@mui/material';
+import { Fetcher } from 'borealis-ui';
+import borealisEN from 'borealis-ui/dist/en/translation.json';
+import borealisFR from 'borealis-ui/dist/fr/translation.json';
+import {} from 'i18next';
+import HowlerPlugin from '@cccsaurora/howler-ui/plugins/HowlerPlugin';
+import BorealisChip from './components/BorealisChip';
+import BorealisLeadForm from './components/BorealisLeadForm';
+import BorealisPivot from './components/BorealisPivot';
+import BorealisPivotForm from './components/BorealisPivotForm';
+import BorealisTypography from './components/BorealisTypography';
+import HELPERS from './helpers';
+import Provider from './Provider';
+import useSetup from './setup';
+class BorealisPlugin extends HowlerPlugin {
+    name = 'BorealisPlugin';
+    version = '0.0.1';
+    author = 'Matthew Rafuse <matthew.rafuse@cyber.gc.ca>';
+    description = 'This plugin enables borealis enrichment in Howler.';
+    activate() {
+        super.activate();
+        super.addLead('borealis', props => _jsx(BorealisLeadForm, { ...props }), (content, metadata) => (_jsx(Box, { p: 1, flex: 1, display: "flex", alignItems: "stretch", children: _jsx(Fetcher, { fetcherId: content, ...JSON.parse(metadata) }) })));
+        super.addPivot('borealis', props => _jsx(BorealisPivotForm, { ...props }), props => _jsx(BorealisPivot, { ...props }));
+    }
+    provider() {
+        return Provider;
+    }
+    setup() {
+        return useSetup;
+    }
+    localization(i18nInstance) {
+        i18nInstance.addResourceBundle('en', 'borealis', borealisEN, true, true);
+        i18nInstance.addResourceBundle('fr', 'borealis', borealisFR, true, true);
+    }
+    helpers() {
+        return HELPERS;
+    }
+    typography(_props) {
+        return _jsx(BorealisTypography, { ..._props });
+    }
+    chip(_props) {
+        return _jsx(BorealisChip, { ..._props });
+    }
+}
+export default BorealisPlugin;

package/plugins/borealis/locales/borealis.en.json

@@ -0,0 +1,7 @@
+{
+    "route.dossiers.manager.borealis": "Borealis Fetcher ID",
+    "route.dossiers.manager.borealis.type": "Selector Type",
+    "route.dossiers.manager.borealis.value": "Selector Value",
+    "route.dossiers.manager.borealis.value.custom": "Custom Selector Value",
+    "route.dossiers.manager.borealis.value.description": "You can use handlebars notation to insert fields from the corresponding alert (i.e. {{howler.id}})."
+}

package/plugins/borealis/locales/borealis.fr.json

@@ -0,0 +1,7 @@
+{
+    "route.dossiers.manager.borealis": "ID du sélecteur Borealis",
+    "route.dossiers.manager.borealis.type": "Type de sélecteur",
+    "route.dossiers.manager.borealis.value": "Valeur du sélecteur",
+    "route.dossiers.manager.borealis.value.custom": "Valeur du sélecteur personnalisé",
+    "route.dossiers.manager.borealis.value.description": "Vous pouvez utiliser la notation « handlebars » pour insérer des champs à partir de l'alerte correspondante (c'est-à-dire {{howler.id}})."
+}

package/plugins/borealis/setup.d.ts

@@ -0,0 +1,2 @@
+declare const useSetup: () => void;
+export default useSetup;

package/plugins/borealis/setup.js

@@ -0,0 +1,44 @@
+import { SNACKBAR_EVENT_ID, useBorealis } from 'borealis-ui';
+import { useAppUser } from '@cccsaurora/howler-ui/commons/components/app/hooks';
+import { ApiConfigContext } from '@cccsaurora/howler-ui/components/app/providers/ApiConfigProvider';
+import useMySnackbar from '@cccsaurora/howler-ui/components/hooks/useMySnackbar';
+import { useContext, useEffect } from 'react';
+const useSetup = () => {
+    const borealis = useBorealis();
+    const appUser = useAppUser();
+    const apiConfig = useContext(ApiConfigContext);
+    const { showSuccessMessage, showErrorMessage, showInfoMessage, showWarningMessage } = useMySnackbar();
+    useEffect(() => {
+        // eslint-disable-next-line no-console
+        console.debug('Initializing borealis snackbar event handler');
+        const handleMessage = (event) => {
+            const { detail } = event;
+            if (detail.level === 'success') {
+                showSuccessMessage(detail.message, detail.timeout, detail.options);
+            }
+            else if (detail.level === 'error') {
+                showErrorMessage(detail.message, detail.timeout, detail.options);
+            }
+            else if (detail.level === 'info') {
+                showInfoMessage(detail.message, detail.timeout, detail.options);
+            }
+            else if (detail.level === 'warning') {
+                showWarningMessage(detail.message, detail.timeout, detail.options);
+            }
+        };
+        window.addEventListener(SNACKBAR_EVENT_ID, handleMessage);
+        return () => {
+            window.removeEventListener(SNACKBAR_EVENT_ID, handleMessage);
+        };
+    }, [showErrorMessage, showInfoMessage, showSuccessMessage, showWarningMessage]);
+    useEffect(() => {
+        if (!appUser.isReady()) {
+            return;
+        }
+        if (apiConfig.config.configuration?.features?.borealis) {
+            borealis.setReady(true);
+        }
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, [apiConfig.config.configuration?.features?.borealis, appUser.isReady()]);
+};
+export default useSetup;