@cccsaurora/howler-ui 2.12.2 → 2.13.0-dev.102

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;