@cccsaurora/howler-ui 2.14.0-dev.228 → 2.14.0-dev.245

package/plugins/store.js

@@ -6,6 +6,12 @@ export class HitEvent extends Event {
         this.hit = hit;
     }
 }
+export var MainMenuInsertOperation;
+(function (MainMenuInsertOperation) {
+    MainMenuInsertOperation["Insert"] = "INSERT";
+    MainMenuInsertOperation["InsertAfter"] = "AFTER";
+    MainMenuInsertOperation["InsertBefore"] = "BEFORE";
+})(MainMenuInsertOperation || (MainMenuInsertOperation = {}));
 class HowlerPluginStore {
     _pluginStore = createPluginStore();
     plugins = [];
@@ -14,6 +20,9 @@ class HowlerPluginStore {
     _operations = [];
     _userMenuItems = [];
     _adminMenuItems = [];
+    _mainMenuOperations = [];
+    _routes = [];
+    _sitemaps = [];
     install(plugin) {
         console.log(`Installing plugin ${plugin.getPluginName()} by ${plugin.author}`);
         this.plugins.push(plugin.name);
@@ -33,6 +42,21 @@ class HowlerPluginStore {
         this._pivotFormats.push(format);
         return true;
     }
+    addUserMenuItem(menuItem) {
+        this._userMenuItems.push(menuItem);
+    }
+    addAdminMenuItem(menuItem) {
+        this._adminMenuItems.push(menuItem);
+    }
+    addMainMenuItem(menuOperation) {
+        this._mainMenuOperations.push(menuOperation);
+    }
+    addRoute(route) {
+        this._routes.push(route);
+    }
+    addSitemap(sitemap) {
+        this._sitemaps.push(sitemap);
+    }
     addOperation(format) {
         if (this._operations.includes(format)) {
             return false;
@@ -40,24 +64,6 @@ class HowlerPluginStore {
         this._operations.push(format);
         return true;
     }
-    /**
-     * Adds a single menu item to the User Menu group under the Avatar Menu,
-     * items are added before the 'Settings' and 'Logout' menu items.
-     *
-     * @param menuItem Menu Item {i18nKey, route, icon}
-     */
-    addUserMenuItem(menuItem) {
-        this._userMenuItems.push(menuItem);
-    }
-    /**
-     * Adds a single menu item to the Admin Menu group under the Avatar Menu,
-     * items are added to the end of the existing Admin menu items.
-     *
-     * @param menuItem Menu Item {i18nKey, route, icon}
-     */
-    addAdminMenuItem(menuItem) {
-        this._adminMenuItems.push(menuItem);
-    }
     get leadFormats() {
         return this._leadFormats;
     }
@@ -67,15 +73,24 @@ class HowlerPluginStore {
     get operations() {
         return this._operations;
     }
-    get pluginStore() {
-        return this._pluginStore;
-    }
     get userMenuItems() {
         return this._userMenuItems;
     }
     get adminMenuItems() {
         return this._adminMenuItems;
     }
+    get mainMenuOperations() {
+        return this._mainMenuOperations;
+    }
+    get routes() {
+        return this._routes;
+    }
+    get sitemaps() {
+        return this._sitemaps;
+    }
+    get pluginStore() {
+        return this._pluginStore;
+    }
 }
 const howlerPluginStore = new HowlerPluginStore();
 export default howlerPluginStore;

package/utils/menuUtils.d.ts

@@ -0,0 +1,89 @@
+import type { AppLeftNavElement, AppLeftNavItem } from '../commons/components/app/AppConfigs';
+declare class AppMenuBuilder {
+    private items;
+    private indexMap;
+    constructor(defaultMenu: AppLeftNavElement[]);
+    /**
+     * Applies a collection of Menu Operation objects created by the plugin system
+     *
+     * @param operations Operations created by the plugin system
+     */
+    applyOperations(operations: {
+        operation: string;
+        targetId: string;
+        item: AppLeftNavElement;
+    }[]): void;
+    /**
+     * Get the completed menu structure
+     */
+    get menu(): AppLeftNavElement[];
+    /**
+     * 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: string, item: AppLeftNavElement): void;
+    /**
+     * 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: string, item: AppLeftNavElement): void;
+    /**
+     * 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: string, item: AppLeftNavElement): void;
+    /**
+     * 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: string): {
+        index: number;
+        subIndex?: number;
+    };
+    /**
+     *  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: number, subIndex?: number): AppLeftNavElement[] | AppLeftNavElement | AppLeftNavItem;
+    /**
+     * Determine if provided element is a group element
+     *
+     * @param elem Element to check
+     * @private
+     */
+    private isGroupElement;
+    /**
+     * Determine if provided element is an item element
+     *
+     * @param elem Element to check
+     * @private
+     */
+    private isItemElement;
+    /**
+     * Creates a flat list of menu items and subitems by menu id
+     * for quick lookup.
+     *
+     * @private
+     */
+    private updateMenuMap;
+}
+export default AppMenuBuilder;

package/utils/menuUtils.js

@@ -0,0 +1,243 @@
+import { MainMenuInsertOperation } from '../plugins/store';
+import { isNil } from 'lodash-es';
+class AppMenuBuilder {
+    items;
+    indexMap;
+    constructor(defaultMenu) {
+        this.items = defaultMenu;
+        this.updateMenuMap();
+    }
+    /**
+     * 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();
+        }
+    }
+    /**
+     * 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') {
+                console.warn(`Skipping DIVIDER Operation: INSERT on Target: ${targetId}, Dividers cannot be inserted to sub-menus`);
+                return;
+            }
+            const group = target.element;
+            const newItem = { ...item.element, nested: true };
+            group.items = [...group.items, newItem];
+            return;
+        }
+        if (Array.isArray(target)) {
+            target.push(item);
+            return;
+        }
+        if (menuLocation.index !== -1 && isNil(menuLocation.subIndex)) {
+            if (item.type === 'divider') {
+                console.warn(`Skipping DIVIDER Operation: INSERT on Target: ${targetId}, Dividers cannot be inserted to sub-menus`);
+                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;
+        }
+    }
+    /**
+     * 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') {
+                console.warn(`Skipping DIVIDER Operation: INSERT on Target: ${targetId}, Dividers cannot be inserted to sub-menus`);
+                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;
+        }
+        // Root level insertion before target index
+        if (menuLocation.index < 0) {
+            menuLocation.index = 0;
+        }
+        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') {
+                console.warn(`Skipping DIVIDER Operation: INSERT on Target: ${targetId}, Dividers cannot be inserted to sub-menus`);
+                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;
+        }
+        // Root level insertion after target index
+        if (menuLocation.index < 0) {
+            menuLocation.index = this.items.length;
+        }
+        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 };
+            }
+            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 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 };
+                }
+            }
+        }
+        this.indexMap = indexMap;
+    }
+}
+export default AppMenuBuilder;