@cccsaurora/howler-ui 3.1.0-dev.1466 → 3.1.0-dev.1602

package/utils/menuUtils.js

@@ -1,239 +1,78 @@
-import { isNil } from 'lodash-es';
-import { MainMenuInsertOperation } from '../plugins/store';
-class AppMenuBuilder {
-    items;
-    indexMap;
-    constructor(defaultMenu) {
-        this.items = defaultMenu;
-        this.updateMenuMap();
+const hasId = (menu, id) => {
+    if (menu.id === id) {
+        return true;
     }
-    /**
-     * Applies a collection of Menu Operation objects created by the plugin system
-     *
-     * @param operations Operations created by the plugin system
-     */
-    applyOperations(operations) {
-        for (const operation of operations) {
-            switch (operation.operation) {
-                case MainMenuInsertOperation.Insert:
-                    // Inserts at end or adds to sub-elements
-                    this.insert(operation.targetId, operation.item);
-                    break;
-                case MainMenuInsertOperation.InsertBefore:
-                    // Inserts before target element
-                    this.insertBefore(operation.targetId, operation.item);
-                    break;
-                case MainMenuInsertOperation.InsertAfter:
-                    // Inserts after target element
-                    this.insertAfter(operation.targetId, operation.item);
-                    break;
-            }
-            this.updateMenuMap();
-        }
+    return menu.items.some(item => item.id === id || (item.type === 'menu' && hasId(item, id)));
+};
+const updateMenu = (menu, menuId, updater) => {
+    if (menu.id === menuId) {
+        return updater(menu);
     }
-    /**
-     * Get the completed menu structure
-     */
-    get menu() {
-        return this.items;
-    }
-    /**
-     * Insert provided menu item at the menu object identified by targetId.
-     *
-     * If the target menu is a group then item will be placed at end of sub items
-     *
-     * If the target menu is a standard item then group will be created and new item added, warning this removes
-     * the route from the new group parent item, be sure to add it back.
-     *
-     * If the target is 'root' then item will be added to end of root menu
-     *
-     * @param targetId Identifier of menu to insert to
-     * @param item Menu Item to insert
-     */
-    insert(targetId, item) {
-        const menuLocation = this.indexOfMenuId(targetId);
-        const target = this.menuFromIndex(menuLocation.index, menuLocation.subIndex);
-        if (!Array.isArray(target) && this.isGroupElement(target)) {
-            if (item.type === 'divider') {
-                return;
-            }
-            const group = target.element;
-            const newItem = { ...item.element, nested: true };
-            group.items = [...group.items, newItem];
-            return;
+    let updated = false;
+    const items = menu.items.map(item => {
+        if (item.type !== 'menu') {
+            return item;
         }
-        if (Array.isArray(target)) {
-            target.push(item);
-            return;
-        }
-        if (menuLocation.index !== -1 && isNil(menuLocation.subIndex)) {
-            if (item.type === 'divider') {
-                return;
-            }
-            if (!this.isItemElement(target)) {
-                return;
-            }
-            const header = target.element;
-            const inserted = { ...item.element, nested: true };
-            const newGroup = {
-                type: 'group',
-                element: {
-                    id: header.id,
-                    open: true,
-                    i18nKey: header.i18nKey,
-                    title: header.text,
-                    userPropValidators: header.userPropValidators,
-                    icon: header.icon,
-                    items: [inserted]
-                }
-            };
-            this.items[menuLocation.index] = newGroup;
-            return;
+        const next = updateMenu(item, menuId, updater);
+        if (!next) {
+            return item;
         }
+        updated = true;
+        return next;
+    });
+    return updated ? { ...menu, items } : null;
+};
+const insertRelative = (menu, anchorId, item, position) => {
+    const index = menu.items.findIndex(current => current.id === anchorId);
+    if (index >= 0) {
+        const insertionIndex = position === 'before' ? index : index + 1;
+        return {
+            ...menu,
+            items: [...menu.items.slice(0, insertionIndex), item, ...menu.items.slice(insertionIndex)]
+        };
     }
-    /**
-     * Insert provided menu item before the menu object identified by targetId.
-     *
-     * @param targetId Identifier of menu to insert to
-     * @param item Menu Item to insert
-     */
-    insertBefore(targetId, item) {
-        const menuLocation = this.indexOfMenuId(targetId);
-        if (!isNil(menuLocation.subIndex)) {
-            if (item.type === 'divider') {
-                return;
-            }
-            const parentElement = this.menuFromIndex(menuLocation.index);
-            if (!Array.isArray(parentElement) && this.isGroupElement(parentElement)) {
-                const group = parentElement.element;
-                const newItem = { ...item.element, nested: true };
-                group.items = [
-                    ...group.items.slice(0, menuLocation.subIndex),
-                    newItem,
-                    ...group.items.slice(menuLocation.subIndex)
-                ];
-            }
-            return;
+    let updated = false;
+    const items = menu.items.map(current => {
+        if (current.type !== 'menu') {
+            return current;
         }
-        // Root level insertion before target index
-        if (menuLocation.index < 0) {
-            menuLocation.index = 0;
+        const next = insertRelative(current, anchorId, item, position);
+        if (!next) {
+            return current;
         }
-        this.items = [...this.items.slice(0, menuLocation.index), item, ...this.items.slice(menuLocation.index)];
-    }
-    /**
-     * Insert provided menu item after the menu object identified by targetId.
-     *
-     * @param targetId Identifier of menu to insert to
-     * @param item Menu Item to insert
-     */
-    insertAfter(targetId, item) {
-        const menuLocation = this.indexOfMenuId(targetId);
-        if (!isNil(menuLocation.subIndex)) {
-            if (item.type === 'divider') {
-                return;
-            }
-            const parentElement = this.menuFromIndex(menuLocation.index);
-            if (!Array.isArray(parentElement) && this.isGroupElement(parentElement)) {
-                const group = parentElement.element;
-                const newItem = { ...item.element, nested: true };
-                group.items = [
-                    ...group.items.slice(0, menuLocation.subIndex + 1),
-                    newItem,
-                    ...group.items.slice(menuLocation.subIndex + 1)
-                ];
-            }
-            return;
+        updated = true;
+        return next;
+    });
+    return updated ? { ...menu, items } : null;
+};
+const removeItem = (menu, targetId) => ({
+    ...menu,
+    items: menu.items
+        .filter(item => item.id !== targetId)
+        .map(item => (item.type === 'menu' ? removeItem(item, targetId) : item))
+});
+export const applyMainMenuOperations = (root, operations) => {
+    return operations.reduce((menu, operation) => {
+        if (operation.type === 'remove') {
+            return removeItem(menu, operation.targetId);
         }
-        // Root level insertion after target index
-        if (menuLocation.index < 0) {
-            menuLocation.index = this.items.length;
+        if (hasId(menu, operation.item.id)) {
+            throw new Error(`Menu item with id '${operation.item.id}' already exists.`);
         }
-        this.items = [...this.items.slice(0, menuLocation.index + 1), item, ...this.items.slice(menuLocation.index + 1)];
-    }
-    /**
-     * Locates menu location in menu structure by menu id.
-     *
-     * @param id Menu Id to search for
-     * @return {index: number, subIndex: number} A dictionary containing indexes needed to access Menu Item
-     */
-    indexOfMenuId(id) {
-        if (id === 'root') {
-            // Root item so return entire menu
-            return { index: -1 };
-        }
-        else if (id in this.indexMap) {
-            // Item exists, check if it's a subitem
-            if ('parent' in this.indexMap[id]) {
-                return { index: this.indexMap[id].parent, subIndex: this.indexMap[id].index };
+        if (operation.type === 'append') {
+            const next = updateMenu(menu, operation.parentId, current => ({
+                ...current,
+                items: [...current.items, operation.item]
+            }));
+            if (next) {
+                return next;
             }
-            return { index: this.indexMap[id].index };
-        }
-        else {
-            throw new Error(`Menu element with id of '${id}' not found.`);
-        }
-    }
-    /**
-     *  Grabs a menu by indexes, helper function to account for an index of -1
-     *  to represent the root menu
-     *
-     * @param index First level index
-     * @param subIndex Second level index
-     * @return {} Menu item
-     */
-    menuFromIndex(index, subIndex) {
-        if (index === -1) {
-            return this.items;
-        }
-        if (isNil(subIndex)) {
-            return this.items[index];
-        }
-        const menuItem = this.items[index];
-        if (menuItem.type === 'group') {
-            return menuItem.element.items[subIndex];
+            throw new Error(`Menu '${operation.parentId}' does not exist or is not a menu.`);
         }
-        throw new Error(`Menu item at index ${index} is not a group and does not have sub-items.`);
-    }
-    /**
-     * Determine if provided element is a group element
-     *
-     * @param elem Element to check
-     * @private
-     */
-    isGroupElement(elem) {
-        return !!elem && typeof elem === 'object' && elem.type === 'group';
-    }
-    /**
-     * Determine if provided element is an item element
-     *
-     * @param elem Element to check
-     * @private
-     */
-    isItemElement(elem) {
-        return !!elem && typeof elem === 'object' && elem.type === 'item';
-    }
-    /**
-     * Creates a flat list of menu items and subitems by menu id
-     * for quick lookup.
-     *
-     * @private
-     */
-    updateMenuMap() {
-        const indexMap = {};
-        for (let index = 0; index < this.items.length; index++) {
-            const menuItem = this.items[index];
-            if (menuItem.type === 'divider') {
-                continue;
-            }
-            indexMap[menuItem.element.id] = { index };
-            if (menuItem.type === 'group') {
-                for (let subIndex = 0; subIndex < menuItem.element.items.length; subIndex++) {
-                    const subMenuItem = menuItem.element.items[subIndex];
-                    indexMap[subMenuItem.id] = { index: subIndex, parent: index };
-                }
-            }
+        const next = insertRelative(menu, operation.anchorId, operation.item, operation.position);
+        if (next) {
+            return next;
         }
-        this.indexMap = indexMap;
-    }
-}
-export default AppMenuBuilder;
+        throw new Error(`Menu item '${operation.anchorId}' does not exist.`);
+    }, root);
+};

package/utils/menuUtils.test.js

@@ -1,198 +1,62 @@
-import { beforeEach, describe, expect, it, vi } from 'vitest';
-import AppMenuBuilder from './menuUtils';
-// Avoid pulling in react-pluggable (and its transitive React deps) by mocking the store module.
-// vi.mock is hoisted by Vitest before any imports, so the mock is applied even though this call appears below the imports.
-vi.mock('plugins/store', () => ({
-    MainMenuInsertOperation: {
-        Insert: 'INSERT',
-        InsertAfter: 'AFTER',
-        InsertBefore: 'BEFORE'
-    }
-}));
+import { describe, expect, it } from 'vitest';
+import { applyMainMenuOperations } from './menuUtils';
 // ---------------------------------------------------------------------------
 // Helpers
 // ---------------------------------------------------------------------------
 const makeItem = (id, overrides = {}) => ({
-    type: 'item',
-    element: { id, i18nKey: `key.${id}`, route: `/${id}`, ...overrides }
+    id,
+    type: 'route',
+    i18nKey: `key.${id}`,
+    route: `/${id}`,
+    ...overrides
 });
 const makeGroup = (id, items = []) => ({
-    type: 'group',
-    element: { id, i18nKey: `key.${id}`, items }
+    id,
+    type: 'menu',
+    i18nKey: `key.${id}`,
+    items
 });
-const makeDivider = () => ({ type: 'divider', element: null });
 // ---------------------------------------------------------------------------
 // Tests
 // ---------------------------------------------------------------------------
-describe('AppMenuBuilder', () => {
-    let initial;
-    let builder;
-    beforeEach(() => {
-        initial = [makeItem('home'), makeItem('search'), makeGroup('tools', [{ id: 'view', route: '/view' }])];
-        builder = new AppMenuBuilder(initial);
+describe('applyMainMenuOperations', () => {
+    const root = () => makeGroup('root', [makeItem('home'), makeItem('search'), makeGroup('tools', [makeItem('view')])]);
+    it('appends an item to the explicit root menu without mutating it', () => {
+        const initial = root();
+        const result = applyMainMenuOperations(initial, [{ type: 'append', parentId: 'root', item: makeItem('new') }]);
+        expect(result.items.map(item => item.id)).toEqual(['home', 'search', 'tools', 'new']);
+        expect(initial.items.map(item => item.id)).toEqual(['home', 'search', 'tools']);
     });
-    // -------------------------------------------------------------------------
-    // menu getter
-    // -------------------------------------------------------------------------
-    describe('menu getter', () => {
-        it('returns the initial menu unchanged when no operations are applied', () => {
-            expect(builder.menu).toHaveLength(3);
-        });
+    it('appends an item to a nested menu', () => {
+        const result = applyMainMenuOperations(root(), [{ type: 'append', parentId: 'tools', item: makeItem('extra') }]);
+        const tools = result.items.find(item => item.id === 'tools');
+        expect(tools.items.map(item => item.id)).toEqual(['view', 'extra']);
     });
-    // -------------------------------------------------------------------------
-    // indexOfMenuId
-    // -------------------------------------------------------------------------
-    describe('indexOfMenuId', () => {
-        it('returns index -1 for the "root" pseudo-target', () => {
-            expect(builder.indexOfMenuId('root')).toEqual({ index: -1 });
-        });
-        it('returns the correct top-level index for a root item', () => {
-            expect(builder.indexOfMenuId('home')).toEqual({ index: 0 });
-        });
-        it('returns both index and subIndex for a nested item', () => {
-            expect(builder.indexOfMenuId('view')).toEqual({ index: 2, subIndex: 0 });
-        });
-        it('throws for an unknown id', () => {
-            expect(() => builder.indexOfMenuId('unknown-id')).toThrow();
-        });
+    it('inserts relative to an item at any depth', () => {
+        const result = applyMainMenuOperations(root(), [
+            { type: 'insertRelative', anchorId: 'view', position: 'before', item: makeItem('before-view') },
+            { type: 'insertRelative', anchorId: 'search', position: 'after', item: makeItem('after-search') }
+        ]);
+        const tools = result.items.find(item => item.id === 'tools');
+        expect(result.items.map(item => item.id)).toEqual(['home', 'search', 'after-search', 'tools']);
+        expect(tools.items.map(item => item.id)).toEqual(['before-view', 'view']);
     });
-    // -------------------------------------------------------------------------
-    // insert
-    // -------------------------------------------------------------------------
-    describe('insert', () => {
-        it('appends a new item to the root when targetId is "root"', () => {
-            builder.insert('root', makeItem('new'));
-            expect(builder.menu).toHaveLength(4);
-            expect(builder.menu[3].element.id).toBe('new');
-        });
-        it('appends a new item to an existing group', () => {
-            builder.insert('tools', makeItem('extra'));
-            const group = builder.menu.find(el => el.type === 'group');
-            expect(group.element.items).toHaveLength(2);
-            expect(group.element.items[1].id).toBe('extra');
-        });
-        it('converts a root-level item into a group when inserting into it', () => {
-            builder.insert('home', makeItem('sub-home'));
-            const converted = builder.menu.find(el => el.type === 'group');
-            // The first group found should be the newly converted one.
-            expect(converted).toBeDefined();
-            expect(converted.element.items.some((i) => i.id === 'sub-home')).toBe(true);
-        });
-        it('marks nested items added to a group as nested:true', () => {
-            builder.insert('tools', makeItem('nested-item'));
-            const group = builder.menu.find(el => el.type === 'group');
-            const last = group.element.items[group.element.items.length - 1];
-            expect(last.nested).toBe(true);
-        });
-        it('does not insert a divider into a group (logs warning and returns)', () => {
-            const warnSpy = vi.spyOn(console, 'warn').mockImplementation(() => { });
-            const before = builder.menu.find(el => el.type === 'group').element.items.length;
-            builder.insert('tools', makeDivider());
-            const after = builder.menu.find(el => el.type === 'group').element.items.length;
-            expect(after).toBe(before);
-            warnSpy.mockRestore();
-        });
+    it('removes items at any depth', () => {
+        const result = applyMainMenuOperations(root(), [
+            { type: 'remove', targetId: 'search' },
+            { type: 'remove', targetId: 'view' }
+        ]);
+        const tools = result.items.find(item => item.id === 'tools');
+        expect(result.items.map(item => item.id)).toEqual(['home', 'tools']);
+        expect(tools.items).toHaveLength(0);
     });
-    // -------------------------------------------------------------------------
-    // insertBefore
-    // -------------------------------------------------------------------------
-    describe('insertBefore', () => {
-        it('inserts a new root-level item before the target', () => {
-            builder.insertBefore('search', makeItem('before-search'));
-            // 'search' was at index 1; the new item should now be at index 1.
-            expect(builder.menu[1].element.id).toBe('before-search');
-            expect(builder.menu[2].element.id).toBe('search');
-        });
-        it('inserts before the first root item (index 0)', () => {
-            builder.insertBefore('home', makeItem('new-first'));
-            expect(builder.menu[0].element.id).toBe('new-first');
-        });
-        it('inserts a new nested item before a sub-item within its group', () => {
-            builder.insertBefore('view', makeItem('before-view'));
-            const group = builder.menu.find(el => el.type === 'group');
-            expect(group.element.items[0].id).toBe('before-view');
-            expect(group.element.items[1].id).toBe('view');
-        });
-        it('marks items inserted into a group as nested:true', () => {
-            builder.insertBefore('view', makeItem('nested-before'));
-            const group = builder.menu.find(el => el.type === 'group');
-            expect(group.element.items[0].nested).toBe(true);
-        });
-        it('does not insert a divider before a sub-item (logs warning)', () => {
-            const warnSpy = vi.spyOn(console, 'warn').mockImplementation(() => { });
-            const before = builder.menu.find(el => el.type === 'group').element.items.length;
-            builder.insertBefore('view', makeDivider());
-            const after = builder.menu.find(el => el.type === 'group').element.items.length;
-            expect(after).toBe(before);
-            warnSpy.mockRestore();
-        });
+    it('rejects appending to a route instead of converting it into a menu', () => {
+        expect(() => applyMainMenuOperations(root(), [{ type: 'append', parentId: 'home', item: makeItem('child') }])).toThrow("Menu 'home' does not exist or is not a menu.");
     });
-    // -------------------------------------------------------------------------
-    // insertAfter
-    // -------------------------------------------------------------------------
-    describe('insertAfter', () => {
-        it('inserts a new root-level item after the target', () => {
-            builder.insertAfter('home', makeItem('after-home'));
-            expect(builder.menu[1].element.id).toBe('after-home');
-            expect(builder.menu[2].element.id).toBe('search');
-        });
-        it('inserts after the last root item', () => {
-            builder.insertAfter('tools', makeItem('very-last'));
-            expect(builder.menu[builder.menu.length - 1].element.id).toBe('very-last');
-        });
-        it('inserts a new nested item after a sub-item within its group', () => {
-            builder.insertAfter('view', makeItem('after-view'));
-            const group = builder.menu.find(el => el.type === 'group');
-            expect(group.element.items[0].id).toBe('view');
-            expect(group.element.items[1].id).toBe('after-view');
-        });
-        it('marks items inserted into a group as nested:true', () => {
-            builder.insertAfter('view', makeItem('nested-after'));
-            const group = builder.menu.find(el => el.type === 'group');
-            expect(group.element.items[1].nested).toBe(true);
-        });
-        it('does not insert a divider after a sub-item (logs warning)', () => {
-            const warnSpy = vi.spyOn(console, 'warn').mockImplementation(() => { });
-            const before = builder.menu.find(el => el.type === 'group').element.items.length;
-            builder.insertAfter('view', makeDivider());
-            const after = builder.menu.find(el => el.type === 'group').element.items.length;
-            expect(after).toBe(before);
-            warnSpy.mockRestore();
-        });
-    });
-    // -------------------------------------------------------------------------
-    // applyOperations
-    // -------------------------------------------------------------------------
-    describe('applyOperations', () => {
-        it('applies an INSERT operation to the root', () => {
-            builder.applyOperations([{ operation: 'INSERT', targetId: 'root', item: makeItem('op-item') }]);
-            expect(builder.menu.some((el) => el.element?.id === 'op-item')).toBe(true);
-        });
-        it('applies a BEFORE operation', () => {
-            builder.applyOperations([{ operation: 'BEFORE', targetId: 'search', item: makeItem('before-op') }]);
-            const idx = builder.menu.findIndex((el) => el.element?.id === 'before-op');
-            const searchIdx = builder.menu.findIndex((el) => el.element?.id === 'search');
-            expect(idx).toBeLessThan(searchIdx);
-        });
-        it('applies an AFTER operation', () => {
-            builder.applyOperations([{ operation: 'AFTER', targetId: 'home', item: makeItem('after-op') }]);
-            const homeIdx = builder.menu.findIndex((el) => el.element?.id === 'home');
-            const afterIdx = builder.menu.findIndex((el) => el.element?.id === 'after-op');
-            expect(afterIdx).toBe(homeIdx + 1);
-        });
-        it('applies multiple operations in order', () => {
-            builder.applyOperations([
-                { operation: 'INSERT', targetId: 'root', item: makeItem('first') },
-                { operation: 'INSERT', targetId: 'root', item: makeItem('second') }
-            ]);
-            const ids = builder.menu.map((el) => el.element?.id).filter(Boolean);
-            expect(ids).toContain('first');
-            expect(ids).toContain('second');
-        });
-        it('ignores operations with unknown operation strings', () => {
-            const lenBefore = builder.menu.length;
-            builder.applyOperations([{ operation: 'UNKNOWN', targetId: 'root', item: makeItem('x') }]);
-            expect(builder.menu.length).toBe(lenBefore);
-        });
+    it('rejects duplicate item ids', () => {
+        const operations = [
+            { type: 'insertRelative', anchorId: 'home', position: 'after', item: makeItem('home') }
+        ];
+        expect(() => applyMainMenuOperations(root(), operations)).toThrow("Menu item with id 'home' already exists.");
     });
 });

package/utils/sessionStorage.js

@@ -8,7 +8,7 @@ const { _getStored: getStored, _removeStored: removeStored, _setStored: setStore
     let changes = {};
     const _getStored = (name) => {
         return {
-            ...JSON.parse(sessionStorage.getItem(buildName(name))),
+            ...JSON.parse(sessionStorage.getItem(buildName(name)) ?? '{}'),
             ...changes[buildName(name)]
         };
     };

package/utils/sessionStorage.test.js

@@ -1,4 +1,5 @@
 /// <reference types="vitest" />
+// @ts-nocheck
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
 import { StorageKey } from './constants';
 import { getAxiosCache, getStored, removeStored, setAxiosCache, setStored } from './sessionStorage';

package/utils/stringUtils.d.ts

@@ -6,4 +6,4 @@ export declare const sanitizeLuceneQuery: (query: string) => string;
 export declare const safeStringPropertyCompare: (propertyPath: string) => (a: unknown, b: unknown) => any;
 export declare const sanitizeMultilineLucene: (query: string) => string;
 export declare const validateRegex: (regex: string) => boolean;
-export declare const parsePixelSizeStringToInt: (size: string) => number;
+export declare const parsePixelSizeStringToInt: (size: string) => number | null;

package/utils/utils.d.ts

@@ -1,25 +1,46 @@
+import type { Theme } from '@mui/material';
+import type { PluginStore } from 'react-pluggable';
 export declare const bytesToSize: (bytes: number | null) => string;
 export declare const humanReadableNumber: (num: number | null) => string;
-export declare const getProvider: () => string;
+export declare const getProvider: () => string | null;
 export declare const searchResultsDisplay: (count: number, max?: number) => string;
 export declare const formatDate: (date: number | string | Date) => string;
 export declare const compareTimestamp: (a: string, b: string) => number;
 export declare const twitterShort: (date: string | Date | number) => string;
 export declare const hashCode: (s: string) => number;
 export declare const stringToColor: (string: string) => string;
+type GetColor<T> = {
+    <D = 'default'>(status: string | undefined, _default?: D): T | D;
+    (status: string | undefined, _default: string, theme: Theme): string;
+};
+export declare const getProviderColor: (name: string | null | undefined) => string;
+declare const STATUS_COLORS: {
+    readonly open: 'primary';
+    readonly 'in-progress': 'warning';
+    readonly resolved: 'success';
+};
+type StatusColor = (typeof STATUS_COLORS)[keyof typeof STATUS_COLORS] | 'default';
+export declare const getStatusColor: GetColor<StatusColor>;
+declare const ESCALATION_COLORS: {
+    alert: 'warning';
+    evidence: 'error';
+    hit: 'primary';
+};
+type EscalationColor = (typeof ESCALATION_COLORS)[keyof typeof ESCALATION_COLORS];
+export declare const getEscalationColor: GetColor<EscalationColor>;
 export declare const delay: (ms: number, rejectOnCancel?: boolean) => {
     cancel: () => void;
-    then<TResult1 = void, TResult2 = never>(onfulfilled?: (value: void) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>;
-    catch<TResult = never>(onrejected?: (reason: any) => TResult | PromiseLike<TResult>): Promise<void | TResult>;
+    then<TResult1 = void, TResult2 = never>(onfulfilled?: ((value: void) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined): Promise<TResult1 | TResult2>;
+    catch<TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | null | undefined): Promise<void | TResult>;
     readonly [Symbol.toStringTag]: string;
-    finally(onfinally?: () => void): Promise<void>;
+    finally(onfinally?: (() => void) | undefined | null): Promise<void>;
 };
 type Timestamp = {
     timestamp?: string;
 };
 export declare const sortByTimestamp: <T extends Timestamp>(arr: T[]) => T[];
 export declare const getTimeRange: (arr: string[]) => [string, string];
-export declare const removeEmpty: (obj: any, aggressive?: boolean) => any;
+export declare const removeEmpty: (obj: unknown, aggressive?: boolean) => unknown;
 export declare const searchObject: (o: any, query: string, returnFlat?: boolean) => any;
 export declare const convertDateToLucene: (date: string) => string;
 export declare const convertCustomDateRangeToLucene: (startDate: string, endDate: string) => string;
@@ -30,5 +51,8 @@ export declare const flattenDeep: (data: {
 }) => {
     [index: string]: any;
 };
-export declare const modifyDocumentation: (original: string, howlerPluginStore: any, pluginStore: any) => string;
+export declare const modifyDocumentation: (original: string, howlerPluginStore: {
+    plugins: string[];
+}, pluginStore: PluginStore) => string;
+export declare const notNil: <T>(val: T | null | undefined) => val is T;
 export {};