@sumaris-net/ngx-components 18.12.0 → 18.12.2

package/esm2022/src/app/core/menu/menu.service.mjs

@@ -0,0 +1,666 @@
+import { EventEmitter, Inject, Injectable, InjectionToken, Optional } from '@angular/core';
+import { NavigationEnd } from '@angular/router';
+import { BehaviorSubject, combineLatest, from, merge, Subject } from 'rxjs';
+import { distinctUntilChanged, filter, map, switchMap, throttleTime } from 'rxjs/operators';
+import { ENVIRONMENT } from '../../../environments/environment.class';
+import { DateUtils } from '../../shared/dates';
+import { isEmptyArray, isNil, isNotEmptyArray, isNotNil, isNotNilOrBlank, toBoolean } from '../../shared/functions';
+import { firstNotNilPromise } from '../../shared/observables';
+import { StartableObservableService } from '../../shared/services/startable-observable-service.class';
+import { AboutModal } from '../about/about.modal';
+import { CORE_CONFIG_OPTIONS } from '../services/config/core.config';
+import { TreeItemEntityUtils } from '../services/model/tree-item-entity.model';
+import { MenuItem, MenuItems } from './menu.model';
+import * as i0 from "@angular/core";
+import * as i1 from "../services/local-settings.service";
+import * as i2 from "../services/config.service";
+import * as i3 from "../services/account.service";
+import * as i4 from "@angular/router";
+import * as i5 from "@ionic/angular";
+import * as i6 from "@ngx-translate/core";
+import * as i7 from "../../../environments/environment.class";
+import * as i8 from "./menu.model";
+export const DEFAULT_MENU_SHOW_WHEN = 'lg';
+export const APP_MENU_ITEMS = new InjectionToken('menuItems');
+export const APP_MENU_OPTIONS = new InjectionToken('menuOptions');
+export class MenuService extends StartableObservableService {
+    settings;
+    configService;
+    accountService;
+    router;
+    modalCtrl;
+    alertController;
+    navController;
+    translate;
+    environment;
+    accountChanges = new BehaviorSubject(undefined);
+    onPinned = new EventEmitter(true);
+    _staticItems;
+    _detachedSubItems = [];
+    _itemCounter = 0;
+    _options;
+    _logPrefix = '[menu-service] ';
+    _$opened = new Subject();
+    _$splitPaneWhen = new BehaviorSubject(DEFAULT_MENU_SHOW_WHEN);
+    _$enabled;
+    _$enableSubMenu;
+    constructor(settings, configService, accountService, router, modalCtrl, alertController, navController, translate, environment, options, staticItems) {
+        super(settings);
+        this.settings = settings;
+        this.configService = configService;
+        this.accountService = accountService;
+        this.router = router;
+        this.modalCtrl = modalCtrl;
+        this.alertController = alertController;
+        this.navController = navController;
+        this.translate = translate;
+        this.environment = environment;
+        this._options = {
+            ...options,
+            subMenu: {
+                disableIcon: false,
+                savePinned: true,
+                ...(options?.subMenu || {}),
+                // Force disable on mobile
+                enable: options?.subMenu?.enable !== false && !this.settings.mobile,
+            },
+        };
+        this._$enabled = new BehaviorSubject(this.environment?.enableMenu !== false);
+        this._$enableSubMenu = new BehaviorSubject(this._options.subMenu.enable);
+        this._detachedSubItems = [];
+        this._staticItems = (staticItems || []).map((source) => {
+            const target = this.fromObject({ static: true, ...source }, { computeId: true, fillParent: true, fillDefaultFromParent: true });
+            const detachedSubItems = TreeItemEntityUtils.deleteRecursively(target, (item) => item.static !== true);
+            if (detachedSubItems?.length) {
+                detachedSubItems.forEach((item) => this._detachToParent(item));
+                console.debug(this._logPrefix + 'Initial detached sub items', detachedSubItems);
+                this._detachedSubItems.push(...detachedSubItems);
+            }
+            return target;
+        });
+        // DEBUG
+        this._debug = !environment.production;
+    }
+    get opened() {
+        return this._$opened.asObservable();
+    }
+    get splitPaneWhen() {
+        return this._$splitPaneWhen.asObservable();
+    }
+    get enabled() {
+        return this._$enabled.asObservable();
+    }
+    get subMenuEnabled() {
+        return this._$enableSubMenu.value;
+    }
+    get subItems() {
+        return (this.data || []).reduce((res, rootElement) => res.concat(rootElement.children), []);
+    }
+    get _staticSubItems() {
+        return (this._staticItems || []).reduce((res, rootElement) => res.concat(rootElement.children), []);
+    }
+    enable(value) {
+        this._$enabled.next(value);
+    }
+    enableSubMenu(value) {
+        this._$enableSubMenu.next(value);
+    }
+    setSplitPaneShowWhen(value) {
+        if (this._$splitPaneWhen.value !== value) {
+            this._$splitPaneWhen.next(value);
+        }
+    }
+    toggleSplitPaneWhen() {
+        if (this._$splitPaneWhen.value !== false) {
+            this._$splitPaneWhen.next(false);
+        }
+        else {
+            this._$splitPaneWhen.next(DEFAULT_MENU_SHOW_WHEN);
+        }
+    }
+    fromObject(source, opts) {
+        const target = MenuItem.fromObject(source, { withChildren: false });
+        // Compute id if need
+        if (opts?.computeId && isNil(target.id))
+            target.id = this._computeNewId();
+        // Remove icon if disabled
+        if (this._options.subMenu.disableIcon) {
+            Object.assign(target, { icon: undefined, matIcon: undefined, matSvgIcon: undefined });
+        }
+        // Recursive
+        target.children = (source.children || []).map((json) => this.fromObject(json, { ...opts, fillParent: false }));
+        // Fill parent (once, when the full tree is ready)
+        if (opts?.fillParent) {
+            TreeItemEntityUtils.treeFillParent(target);
+            // Fill defaults from the parent (once filled)
+            if (opts?.fillDefaultFromParent) {
+                TreeItemEntityUtils.visit(target, (item) => {
+                    if (!item.parent)
+                        return; // Skip if no parent
+                    item.parentPath = item.parentPath || item.parent.path;
+                    item.parentPathParams = item.parentPathParams || item.parent.pathParams;
+                    item.static = toBoolean(item.static, item.parent.static);
+                    // Compute path, from parent path + action
+                    if (!item.path && !!item.action) {
+                        item.path = item.parent.path;
+                        item.pathParams = typeof item.action === 'string' ? { action: item.action } : { actionId: item.id.toString(), actionTitle: item.title };
+                    }
+                });
+            }
+        }
+        return target;
+    }
+    createSubMenu(source) {
+        if (!this.subMenuEnabled)
+            return null; // Skip if disabled
+        const target = this.fromObject(source);
+        // Check if exists
+        if (this.started) {
+            const existingItem = this._findExistingItem(target);
+            if (existingItem)
+                return existingItem;
+        }
+        // Create
+        if (isNil(target.id))
+            target.id = this._computeNewId();
+        return target;
+    }
+    async addSubMenuItems(sources, opts) {
+        if (!this.started)
+            await this.ready();
+        if (!this.subMenuEnabled)
+            return; // Skip
+        return sources.map((source) => this._addSubMenuItem(this.fromObject(source), opts));
+    }
+    async addSubMenuItem(item, opts) {
+        if (!this.started)
+            await this.ready();
+        if (!this.subMenuEnabled)
+            return; // Skip
+        return this._addSubMenuItem(this.fromObject(item), opts);
+    }
+    async removeSubMenuItems(items) {
+        if (!this.started)
+            await this.ready();
+        return (items || []).map((item) => this._removeSubMenuItem(this.fromObject(item)));
+    }
+    async removeSubMenuItem(item) {
+        if (!this.started)
+            await this.ready();
+        return this._removeSubMenuItem(this.fromObject(item));
+    }
+    togglePinned(source) {
+        const item = source instanceof MenuItem ? source : this._findExistingItem(this.fromObject(source));
+        // Skip if not found
+        if (!item) {
+            if (this._debug)
+                console.warn(this._logPrefix + `Sub menu {${source.path}} cannot be found - unable to toggle pinned!`);
+            return;
+        }
+        // Skip if static
+        if (item.static)
+            return;
+        // Unpinned
+        if (item.pinned) {
+            item.pinned = false;
+            if (!item.detached) {
+                this._detachedSubItems = [...this._detachedSubItems, ...this._detachSubMenuItems()];
+            }
+        }
+        // Pinned
+        else {
+            item.pinned = true;
+        }
+        this.onPinned.emit(item);
+    }
+    async executeAction(event, item) {
+        const action = item?.action;
+        if (!action)
+            return; // skip
+        if (typeof action === 'string') {
+            switch (action) {
+                case 'logout':
+                    await this.logout();
+                    break;
+                case 'about':
+                    await this.openAboutModal();
+                    break;
+                case 'expand':
+                    await this.toggleExpandableItem(item);
+                    if (item.path) {
+                        await this.navController.navigateRoot(item.path, {
+                            queryParams: item.pathParams,
+                        });
+                    }
+                    break;
+                default: {
+                    if (item.path) {
+                        await this.navController.navigateRoot(item.path, {
+                            queryParams: item.pathParams,
+                        });
+                    }
+                    else {
+                        throw new Error('Unknown action: ' + action);
+                    }
+                }
+            }
+        }
+        else if (typeof action === 'function') {
+            action(event);
+        }
+    }
+    async logout() {
+        const translations = await this.translate.instant([
+            'AUTH.LOGOUT.CONFIRM_TITLE',
+            'AUTH.LOGOUT.CONFIRM_MESSAGE',
+            'COMMON.BTN_CANCEL',
+            'AUTH.LOGOUT.BTN_CONFIRM',
+        ]);
+        const alert = await this.alertController.create({
+            header: translations['AUTH.LOGOUT.CONFIRM_TITLE'],
+            message: translations['AUTH.LOGOUT.CONFIRM_MESSAGE'],
+            buttons: [
+                {
+                    text: translations['COMMON.BTN_CANCEL'],
+                    role: 'cancel',
+                    cssClass: 'secondary',
+                },
+                {
+                    text: translations['AUTH.LOGOUT.BTN_CONFIRM'],
+                    cssClass: 'ion-color-primary',
+                    handler: async () => {
+                        // Back to home
+                        await this.navController.navigateRoot('/');
+                        // WARNING: logout should be done AFTER home redirection, because of cache clearing - see issue #5
+                        this.accountService.logout();
+                    },
+                },
+            ],
+        });
+        await alert.present();
+    }
+    async openAboutModal() {
+        const modal = await this.modalCtrl.create({ component: AboutModal });
+        return modal.present();
+    }
+    async toggleExpandableItem(item) {
+        if (!item.expanded) {
+            if (this._debug)
+                console.debug(this._logPrefix + 'Expand item', item);
+            item.matIcon = 'expand_less';
+            // Try to attach some item
+            this._detachedSubItems
+                .filter((childItem) => !!this._findParent(childItem, [item]))
+                .forEach((childItem) => this._attachMenuToParent(item, childItem));
+        }
+        else {
+            item.matIcon = 'expand_more';
+            this._detachedSubItems = [...this._detachedSubItems, ...this._detachSubMenuItems({ path: '/', params: {} }, item.children)];
+        }
+    }
+    _markAsOpened() {
+        this._$opened.next(true);
+    }
+    _markAsClosed() {
+        this._$opened.next(false);
+    }
+    async close() {
+        this._$opened.next(false);
+    }
+    async open() {
+        this._$opened.next(true);
+    }
+    async ngOnStart() {
+        console.info(`${this._logPrefix}Starting...`);
+        // Restore sub items from settings
+        await this.settings.ready();
+        const settingsSubItems = this.settings.getPageSettings('menu', 'sub-items');
+        if (isNotEmptyArray(settingsSubItems)) {
+            const detachedSubItems = settingsSubItems.map((source) => this.fromObject(source, { computeId: true, fillParent: true }));
+            console.debug(this._logPrefix + 'Restoring pinned sub items from settings', detachedSubItems);
+            // TODO check if previous sub menu (from menu token) are kept
+            //this._detachedSubItems.push(...detachedSubItems);
+            this._detachedSubItems = detachedSubItems;
+        }
+        const accountEvent$ = merge(from(this.accountService.ready()), this.accountService.onLogin, this.accountService.onLogout.pipe(map((_) => null))).pipe(map((account) => (isNotNil(account?.id) ? account : null)), distinctUntilChanged((a1, a2) => DateUtils.isSame(a1?.updateDate, a2?.updateDate)));
+        this.registerSubscription(
+        // Combine config and account events
+        combineLatest([this.configService.config, accountEvent$]).subscribe(([config, account]) => {
+            const isLogin = this.accountService.isLogin();
+            if (this._debug)
+                console.debug(`${this._logPrefix}Received config or account event. Refreshing items... isLogin? `, isLogin);
+            // Make sure to clear account, if not login
+            account = isLogin ? account : null;
+            // Load all items
+            const items = this._loadMenuItems(config, account);
+            // Emit new root items
+            this.dataSubject.next(items);
+            // Emit account changes event
+            this.accountChanges.next(account);
+        }));
+        this.registerSubscription(merge(
+        // Force refresh when login/logout
+        this.accountChanges.pipe(map(() => MenuItems.parsePathWithQuery(this.router.routerState.snapshot.url))), 
+        // Start listening route
+        this.startSubject.pipe(switchMap((_) => this.router.events), filter((event) => {
+            return event instanceof NavigationEnd;
+        }), map((event) => MenuItems.parsePathWithQuery(event.url))))
+            .pipe(throttleTime(250))
+            .subscribe((pathParam) => {
+            const detachedSubItems = this._detachSubMenuItems(pathParam);
+            if (detachedSubItems?.length) {
+                this._detachedSubItems = [...this._detachedSubItems, ...detachedSubItems];
+                if (this._debug)
+                    console.debug(`${this._logPrefix}Newly detached items: `, detachedSubItems);
+            }
+        }));
+        // Save pinned items
+        this.registerSubscription(this.onPinned.subscribe((item) => {
+            // Collect pinned elements, then serialize it (without id)
+            const pinnedSubItems = this.subItems.filter((i) => i.isPinned()).map((item) => item.asObject({ withChildren: true, keepLocalId: false }));
+            if (pinnedSubItems.length && this._debug)
+                console.debug(this._logPrefix + `Saving ${pinnedSubItems.length} pinned items, in local settings`, pinnedSubItems);
+            this.settings.savePageSetting('menu', pinnedSubItems, 'sub-items');
+        }));
+        return firstNotNilPromise(this.dataSubject);
+    }
+    _loadMenuItems(config, account) {
+        if (this._debug)
+            console.debug(`${this._logPrefix}Loading menu items...`);
+        // Save previous children of root items
+        const detachedSubItems = (this.subItems || []).concat(this._staticSubItems || []).reduce((res, rootItem) => {
+            const children = rootItem.children;
+            if (isEmptyArray(children))
+                return res;
+            // Detach all root children
+            rootItem.children = [];
+            children.forEach((child) => (child.parent = null));
+            // Return root children
+            return res.concat(children);
+        }, this._detachedSubItems || []);
+        // Reset base root items (clean items added by config)
+        let items = this._staticItems.slice();
+        // Concat config's items
+        const configValue = config?.getProperty(CORE_CONFIG_OPTIONS.MENU_ITEMS);
+        if (isNotNilOrBlank(configValue)) {
+            try {
+                const configItems = JSON.parse(configValue);
+                items = (configItems || []).reduce((res, source) => {
+                    // Normalize the item
+                    const item = this.fromObject({ static: true, ...source }, { computeId: true });
+                    // Skip is already loaded
+                    if (res.find((i) => MenuItems.isSame(i, item)))
+                        return res;
+                    // Reuse existing id, if possible
+                    const existingItem = this.data?.find((i) => MenuItems.isSame(i, item));
+                    if (existingItem) {
+                        item.id = existingItem.id;
+                    }
+                    if (item.after) {
+                        const index = res.findIndex((i) => i.title === item.after);
+                        if (index !== -1) {
+                            return res
+                                .slice(0, index + 1)
+                                .concat(item)
+                                .concat(res.slice(index + 1));
+                        }
+                    }
+                    else if (item.before) {
+                        const index = res.findIndex((i) => i.title === item.before);
+                        if (index !== -1) {
+                            return res.slice(0, index).concat(item).concat(res.slice(index));
+                        }
+                    }
+                    return res.concat(item);
+                }, items);
+            }
+            catch (err) {
+                console.error(`${this._logPrefix}Invalid value for option '${CORE_CONFIG_OPTIONS.MENU_ITEMS.key}'. Expected an array of menu item`, err);
+            }
+        }
+        // Filter item using account rights
+        const opts = { debug: this._debug };
+        items = items
+            .filter((item) => MenuItems.checkIfVisible(item, account, config, opts))
+            .map((item) => {
+            // Replace title using a config property
+            if (isNotNilOrBlank(item.titleProperty) && config) {
+                item.title = config.properties[item.titleProperty] || item.title;
+            }
+            return item;
+        });
+        if (this._debug)
+            console.debug(`${this._logPrefix}Found ${items.length} visible root items...`);
+        // Re-attach sub menu items
+        if (this.subMenuEnabled && detachedSubItems.length) {
+            if (account) {
+                this._addSubMenuItems(detachedSubItems, { skipIfExists: false, availableParents: detachedSubItems.concat(items) });
+            }
+            else {
+                this._detachedSubItems = detachedSubItems;
+            }
+        }
+        else {
+            this._detachedSubItems = [];
+        }
+        return items;
+    }
+    _addSubMenuItems(sources, opts) {
+        return sources.map((source) => this._addSubMenuItem(source, opts));
+    }
+    _addSubMenuItem(newItem, opts) {
+        opts = {
+            skipIfExists: true,
+            ...opts,
+        };
+        const pathParam = MenuItems.parsePathWithQuery(this.router.routerState.snapshot.url);
+        // Find if item already exists
+        const existingItem = this._findExistingItem(newItem, opts?.availableParents);
+        if (existingItem) {
+            // No changes
+            if (opts.skipIfExists && MenuItems.isSame(existingItem, newItem) && existingItem.visible) {
+                // DEBUG
+                if (this._debug)
+                    console.debug(`${this._logPrefix}Skipping sub item (same visible item already exist)`, newItem);
+                return existingItem;
+            }
+            if (this._debug)
+                console.debug(`${this._logPrefix}Updating existing sub item #`, existingItem.id);
+            // Replace existing item, but keep the existing id
+            if (newItem !== existingItem) {
+                newItem.id = existingItem.id;
+                newItem.$children = existingItem.$children;
+                newItem.pinned = existingItem.pinned;
+                newItem.static = existingItem.static;
+                if (newItem.pinned || newItem.static || existingItem.expanded) {
+                    // If loading, keep existing title if pinned (avoid to show skeleton)
+                    newItem.title = newItem.title || existingItem.title;
+                }
+                else {
+                    newItem.title = isNotNil(newItem.title) ? newItem.title : existingItem.title;
+                }
+                // Auto set icon, for expand action
+                if (existingItem.action === 'expand') {
+                    newItem.icon = null;
+                    newItem.matIcon = existingItem.expanded ? 'expand_less' : 'expand_more';
+                }
+            }
+        }
+        // Generate item's id (if need)
+        else if (isNil(newItem.id)) {
+            newItem.id = this._computeNewId();
+        }
+        // Default icon for expand action
+        if (newItem.action === 'expand' && !newItem.matIcon) {
+            newItem.matIcon = 'expand_more';
+        }
+        // If visible, get the parent where to attach the item
+        const parent = this._findParent(newItem, opts?.availableParents);
+        if (parent && parent.expanded) {
+            // Attach item to parent
+            this._attachMenuToParent(parent, newItem);
+            // Update detached items :
+            // - excluded new item
+            // - attach and exclude those than can be attached to the new item
+            // Search in detached items one have newItem as parent
+            if (newItem.expanded) {
+                const ancestor = newItem.ancestor;
+                this._detachedSubItems = this._detachedSubItems.concat(...newItem.children).reduce((res, item) => {
+                    // Excluded newly add item
+                    if (item.id === newItem.id)
+                        return res;
+                    // If some detached can be attached to the new item: do it
+                    if (MenuItems.checkIfSubMenuVisible(item, pathParam)) {
+                        const parent = this._findParent(item, [ancestor]);
+                        if (parent) {
+                            // Update item's children
+                            const detachedChildren = this._detachSubMenuItems(pathParam, item.children || []);
+                            // Attach item
+                            this._attachMenuToParent(parent, item);
+                            // Remember detached children
+                            return res.concat(...detachedChildren);
+                        }
+                    }
+                    // Detach (if need)
+                    this._detachToParent(item);
+                    // Add to detached items
+                    return res.concat(item);
+                }, []);
+            }
+            else {
+                // Remove from detached elements
+                this._detachedSubItems = this._detachedSubItems.filter((item) => item.id !== newItem.id);
+                // Detach children
+                newItem.children.forEach((item) => this._detachToParent(item));
+            }
+        }
+        else {
+            // Add or update detached item
+            const detachedIndex = isNotNil(newItem.id) ? this._detachedSubItems.findIndex((item) => item.id === newItem.id) : -1;
+            if (detachedIndex !== -1) {
+                this._detachedSubItems[detachedIndex] = newItem;
+            }
+            else {
+                this._detachedSubItems.push(newItem);
+            }
+        }
+        return newItem;
+    }
+    _computeNewId() {
+        return this._itemCounter++;
+    }
+    _removeSubMenuItem(item) {
+        const existingItem = this._findExistingItem(item);
+        if (existingItem) {
+            this._detachToParent(existingItem);
+            return existingItem;
+        }
+    }
+    _detachSubMenuItems(currentPathParam, subItems) {
+        currentPathParam = currentPathParam ? currentPathParam : MenuItems.parsePathWithQuery(this.router.routerState.snapshot.url.toString());
+        return (subItems || this.subItems).reduce((res, subItem) => {
+            // Not visible => should be detach
+            if (!MenuItems.checkIfSubMenuVisible(subItem, currentPathParam)) {
+                this._detachToParent(subItem);
+                return res.concat(subItem);
+            }
+            // Visible: check children
+            return res.concat(this._detachSubMenuItems(currentPathParam, subItem.children));
+        }, []);
+    }
+    _detachToParent(item) {
+        if (!item?.parent)
+            return; // Skip if already detached
+        let children = item.parent.children || [];
+        // Remove from parent children
+        const indexInParent = children.indexOf(item);
+        if (indexInParent !== -1) {
+            children = children.slice(); // Copy original array, because it can be used in a loop
+            children.splice(indexInParent, 1);
+            item.parent.children = children;
+        }
+        item.parent = null;
+    }
+    _findExistingItem(searchItem, items, recursive = true) {
+        items = items || [...this._detachedSubItems, ...this.data];
+        if (!items.length)
+            return undefined; // Not found
+        for (const item of items) {
+            if (MenuItems.isSameIdOrPathAndParams(searchItem, item))
+                return item;
+            if (recursive && item.children) {
+                const child = this._findExistingItem(searchItem, item.children);
+                if (child)
+                    return child;
+            }
+        }
+        return null;
+    }
+    _findParent(childItem, availableParents) {
+        if (!childItem?.path)
+            return undefined;
+        if (childItem.parent)
+            return childItem.parent;
+        availableParents = availableParents || [...this._detachedSubItems, ...this.data];
+        return availableParents.reduce((res, item) => {
+            if (!item?.path)
+                return res;
+            // A found item already match with the menuItem.parentPath : keep it as it
+            // There is a found candidate that already match the current candidate : keep it
+            if (MenuItems.isParent(childItem, res))
+                return res;
+            // If the menu item has explicit parentPath and its path and path param are the same as the candidate  : use it as parent
+            if (MenuItems.isParent(childItem, item))
+                return item;
+            if (!res && item.children?.length) {
+                return this._findParent(childItem, item.children);
+            }
+            return res;
+        }, undefined);
+    }
+    _attachMenuToParent(parent, child) {
+        if (this._debug)
+            console.debug(`${this._logPrefix}Attach sub-menu {${MenuItems.getUrl(child)}} to parent {${MenuItems.getUrl(parent)}}`);
+        // Avoid to keep identical menu item (we replace it with the new child menu item)
+        //if (!parent?.$children) parent.$children = new BehaviorSubject<MenuItem[]>([]);
+        const children = parent.children || [];
+        const existingIndex = children.findIndex((item) => MenuItems.isSameIdOrPathAndParams(item, child));
+        // Update existing element
+        if (existingIndex !== -1) {
+            if (children[existingIndex] !== child) {
+                children[existingIndex] = child;
+                parent.children = children;
+                child.parent = parent;
+            }
+        }
+        else {
+            children.push(child);
+            // Sort by tab (or id)
+            parent.children = children.sort(MenuItems.sortByTabOrId);
+            child.parent = parent;
+        }
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: MenuService, deps: [{ token: i1.LocalSettingsService }, { token: i2.ConfigService }, { token: i3.AccountService }, { token: i4.Router }, { token: i5.ModalController }, { token: i5.AlertController }, { token: i5.NavController }, { token: i6.TranslateService }, { token: ENVIRONMENT }, { token: APP_MENU_OPTIONS, optional: true }, { token: APP_MENU_ITEMS, optional: true }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: MenuService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: MenuService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                    deps: [ENVIRONMENT],
+                }]
+        }], ctorParameters: () => [{ type: i1.LocalSettingsService }, { type: i2.ConfigService }, { type: i3.AccountService }, { type: i4.Router }, { type: i5.ModalController }, { type: i5.AlertController }, { type: i5.NavController }, { type: i6.TranslateService }, { type: i7.Environment, decorators: [{
+                    type: Inject,
+                    args: [ENVIRONMENT]
+                }] }, { type: i8.MenuOptions, decorators: [{
+                    type: Optional
+                }, {
+                    type: Inject,
+                    args: [APP_MENU_OPTIONS]
+                }] }, { type: undefined, decorators: [{
+                    type: Optional
+                }, {
+                    type: Inject,
+                    args: [APP_MENU_ITEMS]
+                }] }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"menu.service.js","sourceRoot":"","sources":["../../../../../../src/app/core/menu/menu.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { EventEmitter, Inject, Injectable, InjectionToken, Optional } from '@angular/core';\nimport { NavigationEnd, Router } from '@angular/router';\nimport { AlertController, ModalController, NavController } from '@ionic/angular';\nimport { TranslateService } from '@ngx-translate/core';\nimport { BehaviorSubject, combineLatest, from, merge, Observable, Subject } from 'rxjs';\nimport { distinctUntilChanged, filter, map, switchMap, throttleTime } from 'rxjs/operators';\nimport { ENVIRONMENT, Environment } from '../../../environments/environment.class';\nimport { DateUtils } from '../../shared/dates';\nimport { isEmptyArray, isNil, isNotEmptyArray, isNotNil, isNotNilOrBlank, toBoolean } from '../../shared/functions';\nimport { firstNotNilPromise } from '../../shared/observables';\nimport { StartableObservableService } from '../../shared/services/startable-observable-service.class';\nimport { IconRef } from '../../shared/types';\nimport { AboutModal } from '../about/about.modal';\nimport { AccountService } from '../services/account.service';\nimport { ConfigService } from '../services/config.service';\nimport { CORE_CONFIG_OPTIONS } from '../services/config/core.config';\nimport { LocalSettingsService } from '../services/local-settings.service';\nimport { Account } from '../services/model/account.model';\nimport { Configuration } from '../services/model/config.model';\nimport { TreeItemEntityUtils } from '../services/model/tree-item-entity.model';\nimport { IMenuItem, MenuItem, MenuItems, MenuOptions } from './menu.model';\n\nexport type SplitPaneShowWhen = boolean | 'lg';\nexport const DEFAULT_MENU_SHOW_WHEN: SplitPaneShowWhen = 'lg';\nexport const APP_MENU_ITEMS = new InjectionToken<IMenuItem[]>('menuItems');\nexport const APP_MENU_OPTIONS = new InjectionToken<MenuOptions>('menuOptions');\n\nexport interface MenuPathParam {\n  path: string;\n  params: { [key: string]: string };\n}\n\n@Injectable({\n  providedIn: 'root',\n  deps: [ENVIRONMENT],\n})\nexport class MenuService extends StartableObservableService<MenuItem[]> {\n  readonly accountChanges = new BehaviorSubject<Account>(undefined);\n  readonly onPinned = new EventEmitter<MenuItem>(true);\n\n  private _staticItems: MenuItem[];\n  private _detachedSubItems: MenuItem[] = [];\n  private _itemCounter = 0;\n  private readonly _options: MenuOptions;\n  private readonly _logPrefix = '[menu-service] ';\n  private readonly _$opened = new Subject<boolean>();\n  private readonly _$splitPaneWhen = new BehaviorSubject<SplitPaneShowWhen>(DEFAULT_MENU_SHOW_WHEN);\n  private readonly _$enabled: BehaviorSubject<boolean>;\n  private readonly _$enableSubMenu: BehaviorSubject<boolean>;\n\n  constructor(\n    protected settings: LocalSettingsService,\n    protected configService: ConfigService,\n    protected accountService: AccountService,\n    protected router: Router,\n    protected modalCtrl: ModalController,\n    protected alertController: AlertController,\n    protected navController: NavController,\n    protected translate: TranslateService,\n    @Inject(ENVIRONMENT) protected environment: Environment,\n    @Optional() @Inject(APP_MENU_OPTIONS) options?: MenuOptions,\n    @Optional() @Inject(APP_MENU_ITEMS) staticItems?: IMenuItem[]\n  ) {\n    super(settings);\n    this._options = {\n      ...options,\n      subMenu: {\n        disableIcon: false,\n        savePinned: true,\n        ...(options?.subMenu || {}),\n        // Force disable on mobile\n        enable: options?.subMenu?.enable !== false && !this.settings.mobile,\n      },\n    };\n    this._$enabled = new BehaviorSubject<boolean>(this.environment?.enableMenu !== false);\n    this._$enableSubMenu = new BehaviorSubject<boolean>(this._options.subMenu.enable);\n    this._detachedSubItems = [];\n    this._staticItems = (staticItems || []).map((source) => {\n      const target = this.fromObject({ static: true, ...source }, { computeId: true, fillParent: true, fillDefaultFromParent: true });\n\n      const detachedSubItems = TreeItemEntityUtils.deleteRecursively(target, (item) => item.static !== true);\n      if (detachedSubItems?.length) {\n        detachedSubItems.forEach((item) => this._detachToParent(item));\n        console.debug(this._logPrefix + 'Initial detached sub items', detachedSubItems);\n        this._detachedSubItems.push(...detachedSubItems);\n      }\n      return target;\n    });\n\n    // DEBUG\n    this._debug = !environment.production;\n  }\n\n  get opened(): Observable<boolean> {\n    return this._$opened.asObservable();\n  }\n\n  get splitPaneWhen(): Observable<SplitPaneShowWhen> {\n    return this._$splitPaneWhen.asObservable();\n  }\n\n  get enabled(): Observable<boolean> {\n    return this._$enabled.asObservable();\n  }\n\n  get subMenuEnabled(): boolean {\n    return this._$enableSubMenu.value;\n  }\n\n  get subItems(): MenuItem[] {\n    return (this.data || []).reduce((res, rootElement) => res.concat(rootElement.children), []);\n  }\n\n  private get _staticSubItems(): MenuItem[] {\n    return (this._staticItems || []).reduce((res, rootElement) => res.concat(rootElement.children), []);\n  }\n\n  enable(value: boolean) {\n    this._$enabled.next(value);\n  }\n\n  enableSubMenu(value: boolean) {\n    this._$enableSubMenu.next(value);\n  }\n\n  setSplitPaneShowWhen(value: SplitPaneShowWhen) {\n    if (this._$splitPaneWhen.value !== value) {\n      this._$splitPaneWhen.next(value);\n    }\n  }\n\n  toggleSplitPaneWhen() {\n    if (this._$splitPaneWhen.value !== false) {\n      this._$splitPaneWhen.next(false);\n    } else {\n      this._$splitPaneWhen.next(DEFAULT_MENU_SHOW_WHEN);\n    }\n  }\n\n  fromObject(source: any, opts?: { withChildren?: boolean; computeId?: boolean; fillParent?: boolean; fillDefaultFromParent?: boolean }): MenuItem {\n    const target = MenuItem.fromObject(source, { withChildren: false });\n    // Compute id if need\n    if (opts?.computeId && isNil(target.id)) target.id = this._computeNewId();\n\n    // Remove icon if disabled\n    if (this._options.subMenu.disableIcon) {\n      Object.assign(target, <IconRef>{ icon: undefined, matIcon: undefined, matSvgIcon: undefined });\n    }\n\n    // Recursive\n    target.children = (source.children || []).map((json: any) => this.fromObject(json, { ...opts, fillParent: false }));\n\n    // Fill parent (once, when the full tree is ready)\n    if (opts?.fillParent) {\n      TreeItemEntityUtils.treeFillParent(target);\n\n      // Fill defaults from the parent (once filled)\n      if (opts?.fillDefaultFromParent) {\n        TreeItemEntityUtils.visit(target, (item) => {\n          if (!item.parent) return; // Skip if no parent\n          item.parentPath = item.parentPath || item.parent.path;\n          item.parentPathParams = item.parentPathParams || item.parent.pathParams;\n          item.static = toBoolean(item.static, item.parent.static);\n          // Compute path, from parent path + action\n          if (!item.path && !!item.action) {\n            item.path = item.parent.path;\n            item.pathParams = typeof item.action === 'string' ? { action: item.action } : { actionId: item.id.toString(), actionTitle: item.title };\n          }\n        });\n      }\n    }\n\n    return target;\n  }\n\n  createSubMenu(source: Partial<IMenuItem>): MenuItem {\n    if (!this.subMenuEnabled) return null; // Skip if disabled\n\n    const target = this.fromObject(source);\n\n    // Check if exists\n    if (this.started) {\n      const existingItem = this._findExistingItem(target);\n      if (existingItem) return existingItem;\n    }\n\n    // Create\n    if (isNil(target.id)) target.id = this._computeNewId();\n\n    return target;\n  }\n\n  async addSubMenuItems(sources: IMenuItem[], opts?: { skipIfExists?: boolean }) {\n    if (!this.started) await this.ready();\n    if (!this.subMenuEnabled) return; // Skip\n    return sources.map((source) => this._addSubMenuItem(this.fromObject(source), opts));\n  }\n\n  async addSubMenuItem(item: IMenuItem, opts?: { skipIfExists?: boolean }) {\n    if (!this.started) await this.ready();\n    if (!this.subMenuEnabled) return; // Skip\n    return this._addSubMenuItem(this.fromObject(item), opts);\n  }\n\n  async removeSubMenuItems(items: IMenuItem[]) {\n    if (!this.started) await this.ready();\n    return (items || []).map((item) => this._removeSubMenuItem(this.fromObject(item)));\n  }\n\n  async removeSubMenuItem(item: IMenuItem) {\n    if (!this.started) await this.ready();\n    return this._removeSubMenuItem(this.fromObject(item));\n  }\n\n  togglePinned(source: IMenuItem) {\n    const item = source instanceof MenuItem ? source : this._findExistingItem(this.fromObject(source));\n\n    // Skip if not found\n    if (!item) {\n      if (this._debug) console.warn(this._logPrefix + `Sub menu {${source.path}} cannot be found - unable to toggle pinned!`);\n      return;\n    }\n\n    // Skip if static\n    if (item.static) return;\n\n    // Unpinned\n    if (item.pinned) {\n      item.pinned = false;\n      if (!item.detached) {\n        this._detachedSubItems = [...this._detachedSubItems, ...this._detachSubMenuItems()];\n      }\n    }\n\n    // Pinned\n    else {\n      item.pinned = true;\n    }\n\n    this.onPinned.emit(item);\n  }\n\n  async executeAction(event: Event, item: MenuItem) {\n    const action = item?.action;\n    if (!action) return; // skip\n    if (typeof action === 'string') {\n      switch (action as string) {\n        case 'logout':\n          await this.logout();\n          break;\n        case 'about':\n          await this.openAboutModal();\n          break;\n        case 'expand':\n          await this.toggleExpandableItem(item);\n          if (item.path) {\n            await this.navController.navigateRoot(item.path, {\n              queryParams: item.pathParams,\n            });\n          }\n          break;\n        default: {\n          if (item.path) {\n            await this.navController.navigateRoot(item.path, {\n              queryParams: item.pathParams,\n            });\n          } else {\n            throw new Error('Unknown action: ' + action);\n          }\n        }\n      }\n    } else if (typeof action === 'function') {\n      (action as unknown as any)(event);\n    }\n  }\n\n  async logout() {\n    const translations = await this.translate.instant([\n      'AUTH.LOGOUT.CONFIRM_TITLE',\n      'AUTH.LOGOUT.CONFIRM_MESSAGE',\n      'COMMON.BTN_CANCEL',\n      'AUTH.LOGOUT.BTN_CONFIRM',\n    ]);\n    const alert = await this.alertController.create({\n      header: translations['AUTH.LOGOUT.CONFIRM_TITLE'],\n      message: translations['AUTH.LOGOUT.CONFIRM_MESSAGE'],\n      buttons: [\n        {\n          text: translations['COMMON.BTN_CANCEL'],\n          role: 'cancel',\n          cssClass: 'secondary',\n        },\n        {\n          text: translations['AUTH.LOGOUT.BTN_CONFIRM'],\n          cssClass: 'ion-color-primary',\n          handler: async () => {\n            // Back to home\n            await this.navController.navigateRoot('/');\n\n            // WARNING: logout should be done AFTER home redirection, because of cache clearing - see issue #5\n            this.accountService.logout();\n          },\n        },\n      ],\n    });\n\n    await alert.present();\n  }\n\n  async openAboutModal() {\n    const modal = await this.modalCtrl.create({ component: AboutModal });\n    return modal.present();\n  }\n\n  async toggleExpandableItem(item: MenuItem) {\n    if (!item.expanded) {\n      if (this._debug) console.debug(this._logPrefix + 'Expand item', item);\n\n      item.matIcon = 'expand_less';\n\n      // Try to attach some item\n      this._detachedSubItems\n        .filter((childItem) => !!this._findParent(childItem, [item]))\n        .forEach((childItem) => this._attachMenuToParent(item, childItem));\n    } else {\n      item.matIcon = 'expand_more';\n\n      this._detachedSubItems = [...this._detachedSubItems, ...this._detachSubMenuItems({ path: '/', params: {} }, item.children)];\n    }\n  }\n\n  _markAsOpened() {\n    this._$opened.next(true);\n  }\n\n  _markAsClosed() {\n    this._$opened.next(false);\n  }\n\n  async close() {\n    this._$opened.next(false);\n  }\n\n  async open() {\n    this._$opened.next(true);\n  }\n\n  protected async ngOnStart() {\n    console.info(`${this._logPrefix}Starting...`);\n\n    // Restore sub items from settings\n    await this.settings.ready();\n    const settingsSubItems: IMenuItem[] = this.settings.getPageSettings('menu', 'sub-items');\n    if (isNotEmptyArray(settingsSubItems)) {\n      const detachedSubItems = settingsSubItems.map((source) => this.fromObject(source, { computeId: true, fillParent: true }));\n      console.debug(this._logPrefix + 'Restoring pinned sub items from settings', detachedSubItems);\n\n      // TODO check if previous sub menu (from menu token) are kept\n      //this._detachedSubItems.push(...detachedSubItems);\n      this._detachedSubItems = detachedSubItems;\n    }\n\n    const accountEvent$ = merge(\n      from(this.accountService.ready()),\n      this.accountService.onLogin,\n      this.accountService.onLogout.pipe(map((_) => null))\n    ).pipe(\n      map((account) => (isNotNil(account?.id) ? account : null)),\n      distinctUntilChanged((a1, a2) => DateUtils.isSame(a1?.updateDate, a2?.updateDate))\n    );\n\n    this.registerSubscription(\n      // Combine config and account events\n      combineLatest([this.configService.config, accountEvent$]).subscribe(([config, account]) => {\n        const isLogin = this.accountService.isLogin();\n        if (this._debug) console.debug(`${this._logPrefix}Received config or account event. Refreshing items... isLogin? `, isLogin);\n\n        // Make sure to clear account, if not login\n        account = isLogin ? account : null;\n\n        // Load all items\n        const items = this._loadMenuItems(config, account);\n\n        // Emit new root items\n        this.dataSubject.next(items);\n\n        // Emit account changes event\n        this.accountChanges.next(account);\n      })\n    );\n\n    this.registerSubscription(\n      merge(\n        // Force refresh when login/logout\n        this.accountChanges.pipe(map(() => MenuItems.parsePathWithQuery(this.router.routerState.snapshot.url))),\n        // Start listening route\n        this.startSubject.pipe(\n          switchMap((_) => this.router.events),\n          filter((event) => {\n            return event instanceof NavigationEnd;\n          }),\n          map((event: NavigationEnd) => MenuItems.parsePathWithQuery(event.url))\n        )\n      )\n        .pipe(throttleTime(250))\n        .subscribe((pathParam) => {\n          const detachedSubItems = this._detachSubMenuItems(pathParam);\n          if (detachedSubItems?.length) {\n            this._detachedSubItems = [...this._detachedSubItems, ...detachedSubItems];\n            if (this._debug) console.debug(`${this._logPrefix}Newly detached items: `, detachedSubItems);\n          }\n        })\n    );\n\n    // Save pinned items\n    this.registerSubscription(\n      this.onPinned.subscribe((item) => {\n        // Collect pinned elements, then serialize it (without id)\n        const pinnedSubItems = this.subItems.filter((i) => i.isPinned()).map((item) => item.asObject({ withChildren: true, keepLocalId: false }));\n\n        if (pinnedSubItems.length && this._debug)\n          console.debug(this._logPrefix + `Saving ${pinnedSubItems.length} pinned items, in local settings`, pinnedSubItems);\n        this.settings.savePageSetting('menu', pinnedSubItems, 'sub-items');\n      })\n    );\n\n    return firstNotNilPromise(this.dataSubject);\n  }\n\n  private _loadMenuItems(config: Configuration | null, account: Account | null) {\n    if (this._debug) console.debug(`${this._logPrefix}Loading menu items...`);\n\n    // Save previous children of root items\n    const detachedSubItems = (this.subItems || []).concat(this._staticSubItems || []).reduce((res, rootItem) => {\n      const children = rootItem.children;\n      if (isEmptyArray(children)) return res;\n      // Detach all root children\n      rootItem.children = [];\n      children.forEach((child) => (child.parent = null));\n      // Return root children\n      return res.concat(children);\n    }, this._detachedSubItems || []);\n\n    // Reset base root items (clean items added by config)\n    let items: MenuItem[] = this._staticItems.slice();\n\n    // Concat config's items\n    const configValue: string = config?.getProperty(CORE_CONFIG_OPTIONS.MENU_ITEMS);\n    if (isNotNilOrBlank(configValue)) {\n      try {\n        const configItems = JSON.parse(configValue) as IMenuItem[];\n        items = (configItems || []).reduce((res: MenuItem[], source) => {\n          // Normalize the item\n          const item = this.fromObject({ static: true, ...source }, { computeId: true });\n\n          // Skip is already loaded\n          if (res.find((i) => MenuItems.isSame(i, item))) return res;\n\n          // Reuse existing id, if possible\n          const existingItem = this.data?.find((i) => MenuItems.isSame(i, item));\n          if (existingItem) {\n            item.id = existingItem.id;\n          }\n\n          if (item.after) {\n            const index = res.findIndex((i) => i.title === item.after);\n            if (index !== -1) {\n              return res\n                .slice(0, index + 1)\n                .concat(item)\n                .concat(res.slice(index + 1));\n            }\n          } else if (item.before) {\n            const index = res.findIndex((i) => i.title === item.before);\n            if (index !== -1) {\n              return res.slice(0, index).concat(item).concat(res.slice(index));\n            }\n          }\n          return res.concat(item);\n        }, items);\n      } catch (err) {\n        console.error(`${this._logPrefix}Invalid value for option '${CORE_CONFIG_OPTIONS.MENU_ITEMS.key}'. Expected an array of menu item`, err);\n      }\n    }\n\n    // Filter item using account rights\n    const opts = { debug: this._debug };\n    items = items\n      .filter((item) => MenuItems.checkIfVisible(item, account, config, opts))\n      .map((item) => {\n        // Replace title using a config property\n        if (isNotNilOrBlank(item.titleProperty) && config) {\n          item.title = config.properties[item.titleProperty] || item.title;\n        }\n\n        return item;\n      });\n\n    if (this._debug) console.debug(`${this._logPrefix}Found ${items.length} visible root items...`);\n\n    // Re-attach sub menu items\n    if (this.subMenuEnabled && detachedSubItems.length) {\n      if (account) {\n        this._addSubMenuItems(detachedSubItems, { skipIfExists: false, availableParents: detachedSubItems.concat(items) });\n      } else {\n        this._detachedSubItems = detachedSubItems;\n      }\n    } else {\n      this._detachedSubItems = [];\n    }\n\n    return items;\n  }\n\n  private _addSubMenuItems(sources: MenuItem[], opts?: { skipIfExists?: boolean; availableParents?: MenuItem[] }) {\n    return sources.map((source) => this._addSubMenuItem(source, opts));\n  }\n\n  private _addSubMenuItem(newItem: MenuItem, opts?: { skipIfExists?: boolean; availableParents?: MenuItem[] }) {\n    opts = {\n      skipIfExists: true,\n      ...opts,\n    };\n\n    const pathParam = MenuItems.parsePathWithQuery(this.router.routerState.snapshot.url);\n\n    // Find if item already exists\n    const existingItem = this._findExistingItem(newItem, opts?.availableParents);\n    if (existingItem) {\n      // No changes\n      if (opts.skipIfExists && MenuItems.isSame(existingItem, newItem) && existingItem.visible) {\n        // DEBUG\n        if (this._debug) console.debug(`${this._logPrefix}Skipping sub item (same visible item already exist)`, newItem);\n        return existingItem;\n      }\n\n      if (this._debug) console.debug(`${this._logPrefix}Updating existing sub item #`, existingItem.id);\n\n      // Replace existing item, but keep the existing id\n      if (newItem !== existingItem) {\n        newItem.id = existingItem.id;\n        newItem.$children = existingItem.$children;\n        newItem.pinned = existingItem.pinned;\n        newItem.static = existingItem.static;\n        if (newItem.pinned || newItem.static || existingItem.expanded) {\n          // If loading, keep existing title if pinned (avoid to show skeleton)\n          newItem.title = newItem.title || existingItem.title;\n        } else {\n          newItem.title = isNotNil(newItem.title) ? newItem.title : existingItem.title;\n        }\n        // Auto set icon, for expand action\n        if (existingItem.action === 'expand') {\n          newItem.icon = null;\n          newItem.matIcon = existingItem.expanded ? 'expand_less' : 'expand_more';\n        }\n      }\n    }\n\n    // Generate item's id (if need)\n    else if (isNil(newItem.id)) {\n      newItem.id = this._computeNewId();\n    }\n\n    // Default icon for expand action\n    if (newItem.action === 'expand' && !newItem.matIcon) {\n      newItem.matIcon = 'expand_more';\n    }\n\n    // If visible, get the parent where to attach the item\n    const parent = this._findParent(newItem, opts?.availableParents);\n    if (parent && parent.expanded) {\n      // Attach item to parent\n      this._attachMenuToParent(parent, newItem);\n\n      // Update detached items :\n      // - excluded new item\n      // - attach and exclude those than can be attached to the new item\n      // Search in detached items one have newItem as parent\n      if (newItem.expanded) {\n        const ancestor = newItem.ancestor;\n        this._detachedSubItems = this._detachedSubItems.concat(...newItem.children).reduce((res, item) => {\n          // Excluded newly add item\n          if (item.id === newItem.id) return res;\n\n          // If some detached can be attached to the new item: do it\n          if (MenuItems.checkIfSubMenuVisible(item, pathParam)) {\n            const parent = this._findParent(item, [ancestor]);\n            if (parent) {\n              // Update item's children\n              const detachedChildren = this._detachSubMenuItems(pathParam, item.children || []);\n\n              // Attach item\n              this._attachMenuToParent(parent, item);\n\n              // Remember detached children\n              return res.concat(...detachedChildren);\n            }\n          }\n\n          // Detach (if need)\n          this._detachToParent(item);\n\n          // Add to detached items\n          return res.concat(item);\n        }, []);\n      } else {\n        // Remove from detached elements\n        this._detachedSubItems = this._detachedSubItems.filter((item) => item.id !== newItem.id);\n\n        // Detach children\n        newItem.children.forEach((item) => this._detachToParent(item));\n      }\n    } else {\n      // Add or update detached item\n      const detachedIndex = isNotNil(newItem.id) ? this._detachedSubItems.findIndex((item) => item.id === newItem.id) : -1;\n      if (detachedIndex !== -1) {\n        this._detachedSubItems[detachedIndex] = newItem;\n      } else {\n        this._detachedSubItems.push(newItem);\n      }\n    }\n\n    return newItem;\n  }\n\n  private _computeNewId() {\n    return this._itemCounter++;\n  }\n\n  private _removeSubMenuItem(item: MenuItem) {\n    const existingItem = this._findExistingItem(item);\n    if (existingItem) {\n      this._detachToParent(existingItem);\n      return existingItem;\n    }\n  }\n\n  private _detachSubMenuItems(currentPathParam?: MenuPathParam, subItems?: MenuItem[]) {\n    currentPathParam = currentPathParam ? currentPathParam : MenuItems.parsePathWithQuery(this.router.routerState.snapshot.url.toString());\n    return (subItems || this.subItems).reduce((res, subItem) => {\n      // Not visible => should be detach\n      if (!MenuItems.checkIfSubMenuVisible(subItem, currentPathParam)) {\n        this._detachToParent(subItem);\n\n        return res.concat(subItem);\n      }\n      // Visible: check children\n      return res.concat(this._detachSubMenuItems(currentPathParam, subItem.children));\n    }, []);\n  }\n\n  private _detachToParent(item: MenuItem) {\n    if (!item?.parent) return; // Skip if already detached\n    let children = item.parent.children || [];\n\n    // Remove from parent children\n    const indexInParent = children.indexOf(item);\n    if (indexInParent !== -1) {\n      children = children.slice(); // Copy original array, because it can be used in a loop\n      children.splice(indexInParent, 1);\n      item.parent.children = children;\n    }\n\n    item.parent = null;\n  }\n\n  private _findExistingItem(searchItem: IMenuItem, items?: MenuItem[], recursive = true): MenuItem {\n    items = items || [...this._detachedSubItems, ...this.data];\n    if (!items.length) return undefined; // Not found\n    for (const item of items) {\n      if (MenuItems.isSameIdOrPathAndParams(searchItem, item)) return item;\n      if (recursive && item.children) {\n        const child = this._findExistingItem(searchItem, item.children);\n        if (child) return child;\n      }\n    }\n    return null;\n  }\n\n  private _findParent(childItem: MenuItem, availableParents?: MenuItem[]): MenuItem {\n    if (!childItem?.path) return undefined;\n    if (childItem.parent) return childItem.parent;\n\n    availableParents = availableParents || [...this._detachedSubItems, ...this.data];\n\n    return availableParents.reduce((res, item) => {\n      if (!item?.path) return res;\n\n      // A found item already match with the menuItem.parentPath : keep it as it\n      // There is a found candidate that already match the current candidate : keep it\n      if (MenuItems.isParent(childItem, res)) return res;\n\n      // If the menu item has explicit parentPath and its path and path param are the same as the candidate  : use it as parent\n      if (MenuItems.isParent(childItem, item)) return item;\n\n      if (!res && item.children?.length) {\n        return this._findParent(childItem, item.children);\n      }\n\n      return res;\n    }, undefined);\n  }\n\n  private _attachMenuToParent(parent: MenuItem, child: MenuItem) {\n    if (this._debug) console.debug(`${this._logPrefix}Attach sub-menu {${MenuItems.getUrl(child)}} to parent {${MenuItems.getUrl(parent)}}`);\n\n    // Avoid to keep identical menu item (we replace it with the new child menu item)\n    //if (!parent?.$children) parent.$children = new BehaviorSubject<MenuItem[]>([]);\n    const children = parent.children || [];\n    const existingIndex = children.findIndex((item) => MenuItems.isSameIdOrPathAndParams(item, child));\n\n    // Update existing element\n    if (existingIndex !== -1) {\n      if (children[existingIndex] !== child) {\n        children[existingIndex] = child;\n        parent.children = children;\n        child.parent = parent;\n      }\n    } else {\n      children.push(child);\n\n      // Sort by tab (or id)\n      parent.children = children.sort(MenuItems.sortByTabOrId);\n      child.parent = parent;\n    }\n  }\n}\n"]}