@sumaris-net/ngx-components 2.4.114 → 2.4.115

package/esm2020/src/app/core/menu/menu.model.mjs

@@ -1,22 +1,29 @@
-import { equals } from '../../shared/functions';
+import { isNilOrBlank } from '../../shared/functions';
 export class MenuItems {
     /**
      * Compare, without checking the children
-     * @param a
-     * @param b
+     * @param mainItem
+     * @param otherItem
      */
-    static isSame(a, b) {
-        return a.path === b.path
-            && a.parentPath === b.parentPath
-            && a.title === b.title
-            && this.isSameParams(a.pathParams, b.pathParams);
+    static isSame(mainItem, otherItem) {
+        return mainItem.path === otherItem.path
+            && mainItem.parentPath === otherItem.parentPath
+            && mainItem.title === otherItem.title
+            && this.isSameParams(mainItem.pathParams, otherItem.pathParams);
     }
-    static isSameParams(a, b) {
-        return equals(a || {}, b || {});
+    /**
+     * All key/value of the mainParams should exist (and be equals) in the other params
+     * @param mainParams
+     * @param otherParams
+     */
+    static isSameParams(mainParams, otherParams) {
+        const result = Object.entries(mainParams).every(([key, value]) => value === otherParams[key]);
+        return result;
     }
     static isParent(child, parent) {
-        return child.parentPath && child.parentPath === parent?.path
-            && this.isSameParams(child.parentPathParams, parent.pathParams) || false;
+        const result = child.parentPath && child.parentPath === parent?.path
+            && this.isSameParams(child.parentPathParams, parent['pathParams'] || parent['params']) || false;
+        return result;
     }
     static checkIfVisible(item, accountService, config, opts) {
         opts = opts || {};
@@ -48,7 +55,25 @@ export class MenuItems {
         }
         return true;
     }
+    static parsePathWithQuery(pathWithQuery) {
+        const index = pathWithQuery.lastIndexOf('?');
+        if (index < 0)
+            return { path: pathWithQuery, params: {} };
+        const path = pathWithQuery.substring(0, index);
+        const queryString = pathWithQuery.substring(index);
+        const params = Object.fromEntries(new URLSearchParams(queryString));
+        return { path, params };
+    }
+    static getUrl(item) {
+        return this.getUrlFromPathAndParams(item?.path, item?.pathParams);
+    }
+    static getUrlFromPathAndParams(path, params) {
+        const queryString = Object.entries(params || {}).map(([key, value]) => `${key}=${value}`).join('&');
+        if (isNilOrBlank(queryString))
+            return path || '';
+        return `${path || ''}?${queryString}`;
+    }
 }
 export class MenuOptions {
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"menu.model.js","sourceRoot":"","sources":["../../../../../../src/app/core/menu/menu.model.ts"],"names":[],"mappings":"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","sourcesContent":["import {UserProfileLabel} from '../services/model/person.model';\nimport {Configuration} from '../services/model/config.model';\nimport {AccountService} from '../services/account.service';\nimport {IconRef} from '../../shared/types';\nimport {isNilOrBlank} from '../../shared/functions';\nimport {BehaviorSubject} from \"rxjs\";\nimport {MenuPathParam} from \"./menu.service\";\n\nexport interface MenuItem extends IconRef {\n  title: string;\n  path?: string;\n  action?: string | any;\n  profile?: UserProfileLabel;\n  exactProfile?: UserProfileLabel;\n  color?: string;\n  cssClass?: string;\n  // A config property, to enable the menu item\n  ifProperty?: string;\n  // A config property, to override the title\n  titleProperty?: string;\n  titleArgs?: {[key: string]: string};\n  pathParams?: {[key: string]: string};\n  parentPath?: string;\n  parentPathParams?: {[key: string]: string};\n\n  $children?: BehaviorSubject<MenuItem[]>;\n}\n\nexport class MenuItems {\n\n  /**\n   * Compare, without checking the children\n   * @param mainItem\n   * @param otherItem\n   */\n  static isSame(mainItem: MenuItem, otherItem: MenuItem) {\n    return mainItem.path === otherItem.path\n    && mainItem.parentPath === otherItem.parentPath\n    && mainItem.title === otherItem.title\n    && this.isSameParams(mainItem.pathParams, otherItem.pathParams);\n  }\n\n  /**\n   * All key/value of the mainParams should exist (and be equals) in the other params\n   * @param mainParams\n   * @param otherParams\n   */\n  static isSameParams(mainParams: {[key: string]: string}, otherParams: {[key: string]: string}) {\n    const result = Object.entries(mainParams).every(([key, value]) => value === otherParams[key]);\n    return result;\n  }\n\n  static isParent(child: MenuItem, parent: MenuItem | MenuPathParam) {\n    const result = child.parentPath && child.parentPath === parent?.path\n        && this.isSameParams(child.parentPathParams, parent['pathParams'] || parent['params']) || false;\n    return result;\n  }\n\n  static checkIfVisible(item: MenuItem,\n                        accountService: AccountService,\n                        config: Configuration,\n                        opts?: {\n                          isLogin?: boolean;\n                          debug?: boolean;\n                          logPrefix?: string;\n                        }): boolean {\n    opts = opts || {};\n    if (item.profile) {\n      const hasProfile = accountService.isLogin() && accountService.hasMinProfile(item.profile);\n      if (!hasProfile) {\n        if (opts.debug) console.debug(`${opts && opts.logPrefix || '[menu]'} Hide item '${item.title}': need the min profile '${item.profile}' to access path '${item.path}'`);\n        return false;\n      }\n    }\n\n    else if (item.exactProfile) {\n      const hasExactProfile =  accountService.hasExactProfile(item.exactProfile);\n      if (!hasExactProfile) {\n        if (opts.debug) console.debug(`${opts && opts.logPrefix || '[menu]'} Hide item '${item.title}': need exact profile '${item.exactProfile}' to access path '${item.path}'`);\n        return false;\n      }\n    }\n\n    // If enable by config\n    if (item.ifProperty) {\n      //console.debug(\"[menu] Checking if property enable ? \" + item.ifProperty, config && config.properties);\n      const isEnableByConfig = config && config.properties[item.ifProperty] === 'true';\n      if (!isEnableByConfig) {\n        if (opts.debug) console.debug('[menu] Config property \\'' + item.ifProperty + '\\' not \\'true\\' for ', item.path);\n        return false;\n      }\n    }\n\n    return true;\n  }\n\n  static parsePathWithQuery(pathWithQuery: string): MenuPathParam {\n    const index = pathWithQuery.lastIndexOf('?');\n    if (index < 0) return {path: pathWithQuery, params: {}};\n    const path = pathWithQuery.substring(0, index);\n    const queryString = pathWithQuery.substring(index);\n    const params = Object.fromEntries(new URLSearchParams(queryString));\n    return {path, params};\n  }\n\n  static getUrl(item: MenuItem) {\n    return this.getUrlFromPathAndParams(item?.path, item?.pathParams);\n  }\n  static getUrlFromPathAndParams(path: string, params?: any) {\n    const queryString = Object.entries(params || {}).map(([key, value]) => `${key}=${value}`).join('&');\n    if (isNilOrBlank(queryString)) return path || '';\n    return `${path ||''}?${queryString}`;\n  }\n}\n\nexport class MenuOptions {\n  // TODO add options, when need specific behavior on projects\n}\n"]}

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

@@ -1,18 +1,42 @@
-import { Injectable } from '@angular/core';
-import { BehaviorSubject, Subject } from 'rxjs';
+import { EventEmitter, Inject, Injectable, Optional } from '@angular/core';
+import { BehaviorSubject, merge, Subject } from 'rxjs';
+import { MenuItems } from './menu.model';
+import { APP_MENU_ITEMS } from './menu.component';
+import { NavigationEnd } from '@angular/router';
+import { StartableService } from '../../shared/services/startable-service.class';
+import { ENVIRONMENT } from '../../../environments/environment.class';
+import { DateUtils } from '../../shared/dates';
+import { debounceTime, filter, map, mapTo, mergeMap, tap } from 'rxjs/operators';
+import { CORE_CONFIG_OPTIONS } from '../services/config/core.config';
+import { isNotNilOrBlank } from '../../shared/functions';
 import * as i0 from "@angular/core";
+import * as i1 from "../services/platform.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 "../../../environments/environment.class";
 export const DEFAULT_MENU_SHOW_WHEN = 'lg';
-export class MenuService {
-    constructor() {
-        this.onMenuComponentReady = new BehaviorSubject(false);
+export class MenuService extends StartableService {
+    constructor(platformService, configService, accountService, router, environment, rootItems) {
+        super(platformService);
+        this.platformService = platformService;
+        this.configService = configService;
+        this.accountService = accountService;
+        this.router = router;
+        this.environment = environment;
+        this.onLoginChange = new Subject();
+        this.onUpdateMenu = new EventEmitter();
+        this.$items = new BehaviorSubject(undefined);
+        this._logPrefix = '[menu-service]';
         this._$toggled = new Subject();
         this._$opened = new Subject();
         this._$splitPaneWhen = new BehaviorSubject(DEFAULT_MENU_SHOW_WHEN);
         this._$enabled = new BehaviorSubject(true);
-        this._$subMenuItem = new Subject();
+        this._debug = !environment.production;
+        this.$items.next((rootItems || []).map(i => this.prepareItem(i)));
     }
-    get subMenuItem() {
-        return this._$subMenuItem;
+    get rootItems() {
+        return this.$items.value;
     }
     get opened() {
         return this._$opened.asObservable();
@@ -42,26 +66,233 @@ export class MenuService {
             this._$splitPaneWhen.next(DEFAULT_MENU_SHOW_WHEN);
         }
     }
-    clearSubMenuItems() {
-        // TODO
-        this._$subMenuItem.next(null);
-    }
-    addSubMenuItem(value) {
-        this._$subMenuItem.next(value);
-    }
     _markAsOpened() {
         this._$opened.next(true);
     }
     _markAsClosed() {
         this._$opened.next(false);
     }
+    async addSubMenuItems(newItems, opts) {
+        await this.ready();
+        newItems.forEach(i => this.addSubMenuItem(i), opts);
+    }
+    async ngOnStart() {
+        console.info(`${this._logPrefix} Starting...`);
+        // Update component when refresh is need (=login events or config changed)
+        this.registerSubscription(merge(merge(this.accountService.onLogin
+            .pipe(
+        // Filter on account changes
+        filter(account => !DateUtils.isSame(account?.updateDate, this.lastAccountUpdateDate))), this.configService.config
+            .pipe(
+        // Store the config
+        tap(config => this._config = config)))
+            .pipe(
+        // Add debounce to avoid to trigger twice, at startup
+        debounceTime(250), 
+        // Wait account service ready (can be restarted)
+        mergeMap(() => this.accountService.ready()), map(() => this.accountService.account)), 
+        // Logout
+        this.accountService.onLogout.pipe(mapTo(null)))
+            .subscribe(async (account) => {
+            if (account?.updateDate) {
+                this.lastAccountUpdateDate = account.updateDate;
+                this.onLoginChange.next(account);
+            }
+            else {
+                this.lastAccountUpdateDate = null;
+                this.onLoginChange.next(null);
+            }
+            this.refreshMenuItems();
+        }));
+        this.registerSubscription(this.router.events.pipe(filter(event => event instanceof NavigationEnd)).subscribe((event) => {
+            const pathParam = MenuItems.parsePathWithQuery(event.url);
+            const excludedItems = [];
+            const items = this.detachSubMenus(pathParam, this.$items.value, excludedItems);
+            console.debug(`${this._logPrefix} Detached sub menus: `, excludedItems);
+            // this.addSubMenuItems();
+            //this.$items.next(items);
+        }));
+        return this.$items.value;
+    }
+    refreshMenuItems() {
+        if (this._debug)
+            console.debug(`${this._logPrefix} Refreshing menu items...`);
+        // Insert menu items, from the config
+        const configValue = this._config && this._config.getProperty(CORE_CONFIG_OPTIONS.MENU_ITEMS);
+        if (isNotNilOrBlank(configValue)) {
+            try {
+                const configItems = JSON.parse(configValue);
+                this._data = (configItems || []).reduce((res, item) => {
+                    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));
+                        }
+                    }
+                    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);
+                }, this._data);
+            }
+            catch (err) {
+                console.error(`${this._logPrefix} Invalid value for option '${CORE_CONFIG_OPTIONS.MENU_ITEMS.key}'. Expected an array of menu item`, err);
+            }
+        }
+        // TODO : isLogin is not used in MenuItems.checkIfVisible
+        const opts = { debug: this._debug };
+        const filteredItems = this._data
+            .filter(item => MenuItems.checkIfVisible(item, this.accountService, this._config, opts))
+            .map(item => {
+            // Replace title using properties
+            if (isNotNilOrBlank(item.titleProperty) && this._config) {
+                const title = this._config.properties[item.titleProperty];
+                if (title)
+                    return { ...item, title }; // Create a copy, to keep the original item.title
+            }
+            return item;
+        });
+        this.$items.next(filteredItems);
+    }
+    async addSubMenuItem(newItem, opts) {
+        opts = {
+            skipIfExists: false,
+            ...opts,
+        };
+        // Make sure path (and pathParams) are filled in the same way
+        newItem = this.prepareItem(newItem);
+        // Find if item already exists
+        const existingItem = this.findExistingItem(newItem);
+        if (existingItem && opts.skipIfExists) {
+            // DEBUG
+            console.debug(`${this._logPrefix} Skipping sub item (already exist)`, newItem);
+            return; // Already add
+        }
+        const parent = this.findParent(newItem);
+        if (!parent) {
+            console.warn(`${this._logPrefix} Unable to add sub item: no parent found`);
+            const parentUrlTre = this.router.createUrlTree(newItem.parentPath.split('/'), {
+                queryParams: newItem.parentPathParams
+            });
+            const data = this.router.routerState.root.parent?.data;
+            console.log('TODO check parent data', data);
+            /*await this.router.navigateByUrl(newItem.parentPath, {
+              skipLocationChange: true
+            });*/
+        }
+        else {
+            this.addMenuToParent(parent, newItem);
+        }
+    }
+    ;
+    prepareItem(item) {
+        item = {
+            ...item,
+            $children: item.$children || new BehaviorSubject([])
+        };
+        // Clean
+        if (item.path) {
+            const { path, params } = MenuItems.parsePathWithQuery(item.path);
+            item.path = path;
+            item.pathParams = { ...item.pathParams, ...params };
+        }
+        if (item.parentPath) {
+            const { path, params } = MenuItems.parsePathWithQuery(item.parentPath);
+            item.parentPath = path;
+            item.parentPathParams = { ...item.parentPathParams, ...params };
+        }
+        return item;
+    }
+    findExistingItem(item, items) {
+        items = items || this.$items.value;
+        if (!items.length)
+            return undefined; // Not found
+        return items.find(i => MenuItems.isSame(i, item) || (i.$children && this.findExistingItem(item, i.$children.value)));
+    }
+    findParent(childItem, parentItems) {
+        if (!childItem?.path)
+            return undefined;
+        parentItems = parentItems || this.$items.value;
+        return parentItems.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?.value.length) {
+                return this.findParent(childItem, item.$children?.value);
+            }
+            return res;
+        }, undefined);
+    }
+    ;
+    addMenuToParent(parent, child) {
+        console.debug(`${this._logPrefix}Adding a sub-menu ${MenuItems.getUrl(child)} to parent menu ${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.value || [];
+        const existingIndex = children.findIndex(item => MenuItems.isSame(child, item));
+        if (existingIndex !== -1) {
+            children[existingIndex] = child;
+        }
+        else {
+            children.push(child);
+        }
+        parent.$children.next(children);
+        this.onUpdateMenu.emit();
+    }
+    detachSubMenus(currentPathParam, items, excludedItems) {
+        items = items || this.rootItems;
+        excludedItems = excludedItems || [];
+        items = items.filter(item => {
+            if (!item.parentPath)
+                return true; // Always keep root items
+            // Current route = param: keep it
+            // if (MenuItems.isParent(item, currentPathParam)) return true;
+            // Item parent path starts with the current path: keep it
+            // if (item.path?.startsWith(currentPathParam.path)) return true;
+            // Keep each menu items in the scope of the current url path
+            if (currentPathParam.path.startsWith(item.path))
+                return true;
+            // Else, exclude
+            excludedItems.push(item);
+            return false;
+        });
+        items.forEach(item => {
+            const children = this.detachSubMenus(currentPathParam, item.$children.value || [], excludedItems);
+            item.$children.next(children);
+        });
+        return items;
+    }
+    isVisibleForRoute(item, currentPathParam) {
+        return;
+    }
 }
-MenuService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: MenuService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+MenuService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: MenuService, deps: [{ token: i1.PlatformService }, { token: i2.ConfigService }, { token: i3.AccountService }, { token: i4.Router }, { token: ENVIRONMENT }, { token: APP_MENU_ITEMS, optional: true }], target: i0.ɵɵFactoryTarget.Injectable });
 MenuService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: MenuService, providedIn: 'root' });
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: MenuService, decorators: [{
             type: Injectable,
             args: [{
                     providedIn: 'root'
                 }]
-        }] });
-//# sourceMappingURL=data:application/json;base64,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
+        }], ctorParameters: function () { return [{ type: i1.PlatformService }, { type: i2.ConfigService }, { type: i3.AccountService }, { type: i4.Router }, { type: i5.Environment, decorators: [{
+                    type: Inject,
+                    args: [ENVIRONMENT]
+                }] }, { 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, Optional} from '@angular/core';\nimport {BehaviorSubject, merge, Observable, skipWhile, Subject, Subscription} from 'rxjs';\nimport {MenuItem, MenuItems} from './menu.model';\nimport {APP_MENU_ITEMS} from './menu.component';\nimport {NavigationEnd, Router} from '@angular/router';\nimport {StartableService} from '../../shared/services/startable-service.class';\nimport {Environment, ENVIRONMENT} from '../../../environments/environment.class';\nimport {PlatformService} from '../services/platform.service';\nimport {Moment} from 'moment';\nimport {DateUtils} from '../../shared/dates';\nimport {debounceTime, filter, map, mapTo, mergeMap, tap} from 'rxjs/operators';\nimport {AccountService} from '../services/account.service';\nimport {ConfigService} from '../services/config.service';\nimport {Configuration} from '../services/model/config.model';\nimport {CORE_CONFIG_OPTIONS} from '../services/config/core.config';\nimport {isNotNilOrBlank} from '../../shared/functions';\nimport {Account} from '../services/model/account.model';\n\nexport type SplitPaneShowWhen = boolean|'lg';\nexport const DEFAULT_MENU_SHOW_WHEN: SplitPaneShowWhen = 'lg';\n\nexport interface AddSubMenuItemsOption {\n  skipIfExists: boolean;\n}\n\nexport interface AddSubMenuItems {\n  items: MenuItem[];\n  opts?: AddSubMenuItemsOption;\n}\n\nexport interface MenuPathParam {\n  path: string;\n  params: {[key: string]: string};\n}\n\n@Injectable({\n  providedIn: 'root'\n})\nexport class MenuService extends StartableService<MenuItem[], any> {\n\n  public onLoginChange = new Subject<Account>();\n  public onUpdateMenu = new EventEmitter();\n  public readonly $items = new BehaviorSubject<MenuItem[]>(undefined);\n\n  protected lastAccountUpdateDate: Moment | string;\n  private _logPrefix = '[menu-service]';\n  private _config: Configuration;\n  private readonly _$toggled = new Subject<void>();\n  private readonly _$opened = new Subject<boolean>();\n  private readonly _$splitPaneWhen = new BehaviorSubject<SplitPaneShowWhen>(DEFAULT_MENU_SHOW_WHEN);\n  private readonly _$enabled = new BehaviorSubject<boolean>(true);\n\n  private get rootItems(): MenuItem[] {\n    return this.$items.value;\n  }\n\n  constructor(\n    protected platformService: PlatformService,\n    protected configService: ConfigService,\n    protected accountService: AccountService,\n    protected router: Router,\n    @Inject(ENVIRONMENT) protected environment: Environment,\n    @Optional() @Inject(APP_MENU_ITEMS) rootItems?: MenuItem[]\n  ) {\n    super(platformService);\n    this._debug = !environment.production;\n    this.$items.next((rootItems || []).map(i => this.prepareItem(i)));\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  toggle() {\n    this._$toggled.next();\n  }\n\n  enable(value: boolean) {\n    this._$enabled.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    }\n    else {\n      this._$splitPaneWhen.next(DEFAULT_MENU_SHOW_WHEN);\n    }\n  }\n\n  _markAsOpened() {\n    this._$opened.next(true);\n  }\n\n  _markAsClosed() {\n    this._$opened.next(false);\n  }\n\n  async addSubMenuItems(newItems: MenuItem[], opts?: AddSubMenuItemsOption) {\n    await this.ready();\n    newItems.forEach(i => this.addSubMenuItem(i), opts);\n  }\n\n  protected async ngOnStart(): Promise<MenuItem[]> {\n    console.info(`${this._logPrefix} Starting...`);\n\n    // Update component when refresh is need (=login events or config changed)\n    this.registerSubscription(\n      merge(\n        merge(\n          this.accountService.onLogin\n            .pipe(\n              // Filter on account changes\n              filter(account => !DateUtils.isSame(account?.updateDate, this.lastAccountUpdateDate))\n            )\n          ,\n          this.configService.config\n            .pipe(\n              // Store the config\n              tap(config => this._config = config)\n            )\n        )\n          .pipe(\n            // Add debounce to avoid to trigger twice, at startup\n            debounceTime(250),\n            // Wait account service ready (can be restarted)\n            mergeMap(() => this.accountService.ready()),\n            map(() => this.accountService.account)\n          ),\n        // Logout\n        this.accountService.onLogout.pipe(mapTo(null)),\n      )\n        .subscribe(async account => {\n          if (account?.updateDate) {\n            this.lastAccountUpdateDate = account.updateDate;\n            this.onLoginChange.next(account);\n          } else {\n            this.lastAccountUpdateDate = null;\n            this.onLoginChange.next(null);\n          }\n          this.refreshMenuItems();\n        }));\n\n    this.registerSubscription(\n      this.router.events.pipe(\n        filter(event => event instanceof NavigationEnd),\n        // filter(event => !!this.$items?.value),\n      ).subscribe((event: NavigationEnd) => {\n        const pathParam = MenuItems.parsePathWithQuery(event.url);\n        const excludedItems = [];\n        const items = this.detachSubMenus(pathParam, this.$items.value, excludedItems);\n        console.debug(`${this._logPrefix} Detached sub menus: `, excludedItems);\n        // this.addSubMenuItems();\n        //this.$items.next(items);\n      })\n    );\n\n    return this.$items.value;\n  }\n\n  protected refreshMenuItems() {\n    if (this._debug) console.debug(`${this._logPrefix} Refreshing menu items...`);\n\n    // Insert menu items, from the config\n    const configValue: string = this._config && this._config.getProperty(CORE_CONFIG_OPTIONS.MENU_ITEMS);\n    if (isNotNilOrBlank(configValue)) {\n      try {\n        const configItems = JSON.parse(configValue);\n        this._data = (configItems || []).reduce((res, item) => {\n          if (item.after) {\n            const index = res.findIndex(i => i.title === item.after);\n            if (index !== -1) {\n              return res.slice(0, index + 1)\n                .concat(item)\n                .concat(res.slice(index + 1));\n            }\n          }\n          if (item.before) {\n            const index = res.findIndex(i => i.title === item.before);\n            if (index !== -1) {\n              return res.slice(0, index)\n                .concat(item)\n                .concat(res.slice(index));\n            }\n          }\n          return res.concat(item);\n        }, this._data);\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    // TODO : isLogin is not used in MenuItems.checkIfVisible\n    const opts = {debug: this._debug};\n    const filteredItems = this._data\n      .filter(item => MenuItems.checkIfVisible(item, this.accountService, this._config, opts))\n      .map(item => {\n        // Replace title using properties\n        if (isNotNilOrBlank(item.titleProperty) && this._config) {\n          const title = this._config.properties[item.titleProperty];\n          if (title) return {...item, title}; // Create a copy, to keep the original item.title\n        }\n        return item;\n      });\n\n    this.$items.next(filteredItems);\n  }\n\n  protected async addSubMenuItem(newItem: MenuItem, opts?: AddSubMenuItemsOption) {\n    opts = {\n      skipIfExists: false,\n      ...opts,\n    };\n\n    // Make sure path (and pathParams) are filled in the same way\n    newItem = this.prepareItem(newItem);\n\n    // Find if item already exists\n    const existingItem = this.findExistingItem(newItem);\n    if (existingItem && opts.skipIfExists) {\n      // DEBUG\n      console.debug(`${this._logPrefix} Skipping sub item (already exist)`, newItem);\n      return; // Already add\n    }\n\n    const parent = this.findParent(newItem);\n    if (!parent) {\n      console.warn(`${this._logPrefix} Unable to add sub item: no parent found`);\n      const parentUrlTre = this.router.createUrlTree(newItem.parentPath.split('/'), {\n        queryParams: newItem.parentPathParams\n      });\n      const data = this.router.routerState.root.parent?.data;\n      console.log('TODO check parent data', data);\n\n      /*await this.router.navigateByUrl(newItem.parentPath, {\n        skipLocationChange: true\n      });*/\n    }\n    else {\n      this.addMenuToParent(parent, newItem);\n    }\n  };\n\n  protected prepareItem(item: MenuItem): MenuItem {\n\n    item = <MenuItem>{\n      ...item,\n      $children: item.$children || new BehaviorSubject<MenuItem[]>([])\n    };\n\n    // Clean\n    if (item.path) {\n      const {path, params} = MenuItems.parsePathWithQuery(item.path);\n      item.path = path;\n      item.pathParams = {...item.pathParams, ...params};\n    }\n    if (item.parentPath) {\n      const {path, params} = MenuItems.parsePathWithQuery(item.parentPath);\n      item.parentPath = path;\n      item.parentPathParams = {...item.parentPathParams, ...params};\n    }\n\n    return item;\n  }\n\n  protected findExistingItem(item: MenuItem, items?: MenuItem[]): MenuItem {\n    items = items || this.$items.value;\n    if (!items.length) return undefined; // Not found\n    return items.find(i => MenuItems.isSame(i, item) || (\n      i.$children && this.findExistingItem(item, i.$children.value)\n    ));\n  }\n\n  protected findParent(childItem: MenuItem, parentItems?: MenuItem[]): MenuItem {\n    if (!childItem?.path) return undefined;\n    parentItems = parentItems || this.$items.value;\n\n    return parentItems.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?.value.length) {\n        return this.findParent(childItem, item.$children?.value);\n      }\n\n      return res;\n    }, undefined);\n  };\n\n  protected addMenuToParent(parent: MenuItem, child: MenuItem) {\n\n    console.debug(`${this._logPrefix}Adding a sub-menu ${MenuItems.getUrl(child)} to parent menu ${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.value || [];\n    const existingIndex = children.findIndex(item => MenuItems.isSame(child, item));\n    if (existingIndex !== -1) {\n      children[existingIndex] = child;\n    }\n    else {\n      children.push(child);\n    }\n    parent.$children.next(children);\n\n\n    this.onUpdateMenu.emit();\n  }\n\n  protected detachSubMenus(currentPathParam: MenuPathParam, items?: MenuItem[], excludedItems?: MenuItem[]) {\n    items = items || this.rootItems;\n    excludedItems = excludedItems || [];\n    items = items.filter(item => {\n      if (!item.parentPath) return true; // Always keep root items\n\n      // Current route = param: keep it\n      // if (MenuItems.isParent(item, currentPathParam)) return true;\n\n      // Item parent path starts with the current path: keep it\n      // if (item.path?.startsWith(currentPathParam.path)) return true;\n\n      // Keep each menu items in the scope of the current url path\n      if (currentPathParam.path.startsWith(item.path)) return true;\n\n      // Else, exclude\n      excludedItems.push(item);\n      return false;\n    });\n    items.forEach(item => {\n      const children = this.detachSubMenus(currentPathParam, item.$children.value || [], excludedItems);\n      item.$children.next(children);\n    });\n    return items;\n  }\n\n  protected isVisibleForRoute(item: MenuItem, currentPathParam: MenuPathParam) {\n    return ;\n  }\n}\n"]}

package/esm2020/src/app/core/menu/testing/menu-other.testing.mjs

@@ -0,0 +1,52 @@
+import { Component, } from '@angular/core';
+import { MenuItems } from '../menu.model';
+import { MenuTestingPage } from './menu.testing';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/router";
+import * as i2 from "@ionic/angular";
+import * as i3 from "@ngx-translate/core";
+import * as i4 from "../menu.service";
+import * as i5 from "@angular/common";
+import * as i6 from "@angular/material/tabs";
+import * as i7 from "../../../shared/toolbar/toolbar";
+export class OtherMenuTestingPage extends MenuTestingPage {
+    constructor(route, // Modal editor give 'null'
+    router, navController, alertCtrl, translate, menuService) {
+        super(route, router, navController, alertCtrl, translate, menuService);
+        this.logPrefix = '[menu-testing-other] ';
+    }
+    initSubMenu() {
+        const pathParam = MenuItems.parsePathWithQuery(this.router.url);
+        this.title = 'Other';
+        this.secondTabTitle = 'Second';
+        this.parentPath = '/testing/shared/menu?tab=1';
+        this.childPath = '';
+        const path = '/testing/shared/menu/other';
+        const parentPath = '/testing/shared/menu?tab=1';
+        console.debug(`${this.logPrefix} Setup with`, { path, parentPath });
+        this.menuService.addSubMenuItems([
+            {
+                title: 'Other',
+                path,
+                parentPath,
+                action: null,
+                profile: 'GUEST',
+            },
+            {
+                title: this.secondTabTitle,
+                path,
+                pathParams: { tab: '1' },
+                parentPath: path,
+                action: null,
+                profile: 'GUEST',
+            }
+        ]);
+    }
+}
+OtherMenuTestingPage.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: OtherMenuTestingPage, deps: [{ token: i1.ActivatedRoute }, { token: i1.Router }, { token: i2.NavController }, { token: i2.AlertController }, { token: i3.TranslateService }, { token: i4.MenuService }], target: i0.ɵɵFactoryTarget.Component });
+OtherMenuTestingPage.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "14.3.0", type: OtherMenuTestingPage, selector: "app-testing-menu-other", usesInheritance: true, ngImport: i0, template: "<app-toolbar [defaultBackHref]=\"parentPath\">\n  <ion-title>{{ title }}</ion-title>\n</app-toolbar>\n\n<ion-content>\n\n  <mat-tab-group #tabGroup\n                 [(selectedIndex)]=\"selectedTabIndex\"\n                 (selectedTabChange)=\"onTabChange($event)\"\n                 dynamicHeight>\n\n    <!-- TAB: 1 -->\n    <mat-tab label=\"Details\" class=\"ion-padding\">\n      <ng-template mat-tab-label>\n        <ion-label>Details</ion-label>\n      </ng-template>\n\n      <div class=\"ion-padding\">\n        A first tab<br/>\n\n        <ion-button (click)=\"toggleThird()\">\n          Third tab ?\n        </ion-button>\n      </div>\n\n    </mat-tab>\n\n    <!-- TAB: 2 -->\n    <mat-tab [label]=\"secondTabTitle\" class=\"ion-padding\">\n      <ng-template mat-tab-label>\n        <ion-label>{{secondTabTitle}}</ion-label>\n      </ng-template>\n\n      <div class=\"ion-padding\">\n        A second tab<br/>\n\n        <ng-container *ngIf=\"secondTabTitle=== 'Others'\">\n          Navigate to : <a [routerLink]=\"childPath\" >\n            {{ childPath }}\n          </a>\n        </ng-container>\n      </div>\n\n    </mat-tab>\n\n    <!-- TAB: 3 -->\n    <mat-tab *ngIf=\"thirdTabTitle\"\n             [label]=\"thirdTabTitle\" class=\"ion-padding\">\n      <ng-template mat-tab-label>\n        <ion-label>{{thirdTabTitle}}</ion-label>\n      </ng-template>\n\n      <div class=\"ion-padding\">\n        A third tab\n      </div>\n\n    </mat-tab>\n  </mat-tab-group>\n</ion-content>\n", styles: [".menu-item{padding-left:0 px}\n"], dependencies: [{ kind: "directive", type: i5.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "directive", type: i1.RouterLinkWithHref, selector: "a[routerLink],area[routerLink]", inputs: ["target", "queryParams", "fragment", "queryParamsHandling", "state", "relativeTo", "preserveFragment", "skipLocationChange", "replaceUrl", "routerLink"] }, { kind: "component", type: i2.IonButton, selector: "ion-button", inputs: ["buttonType", "color", "disabled", "download", "expand", "fill", "form", "href", "mode", "rel", "routerAnimation", "routerDirection", "shape", "size", "strong", "target", "type"] }, { kind: "component", type: i2.IonContent, selector: "ion-content", inputs: ["color", "forceOverscroll", "fullscreen", "scrollEvents", "scrollX", "scrollY"] }, { kind: "component", type: i2.IonLabel, selector: "ion-label", inputs: ["color", "mode", "position"] }, { kind: "component", type: i2.IonTitle, selector: "ion-title", inputs: ["color", "size"] }, { kind: "directive", type: i2.RouterLinkWithHrefDelegate, selector: "a[routerLink],area[routerLink]", inputs: ["routerDirection", "routerAnimation"] }, { kind: "component", type: i6.MatTabGroup, selector: "mat-tab-group", inputs: ["color", "disableRipple"], exportAs: ["matTabGroup"] }, { kind: "directive", type: i6.MatTabLabel, selector: "[mat-tab-label], [matTabLabel]" }, { kind: "component", type: i6.MatTab, selector: "mat-tab", inputs: ["disabled", "label", "aria-label", "aria-labelledby", "labelClass", "bodyClass"], exportAs: ["matTab"] }, { kind: "component", type: i7.ToolbarComponent, selector: "app-toolbar", inputs: ["progressBarMode", "title", "color", "class", "backHref", "defaultBackHref", "hasValidate", "hasClose", "hasSearch", "canGoBack", "canShowMenu"], outputs: ["onValidate", "onClose", "onValidateAndClose", "onBackClick", "onSearch"] }] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: OtherMenuTestingPage, decorators: [{
+            type: Component,
+            args: [{ selector: 'app-testing-menu-other', template: "<app-toolbar [defaultBackHref]=\"parentPath\">\n  <ion-title>{{ title }}</ion-title>\n</app-toolbar>\n\n<ion-content>\n\n  <mat-tab-group #tabGroup\n                 [(selectedIndex)]=\"selectedTabIndex\"\n                 (selectedTabChange)=\"onTabChange($event)\"\n                 dynamicHeight>\n\n    <!-- TAB: 1 -->\n    <mat-tab label=\"Details\" class=\"ion-padding\">\n      <ng-template mat-tab-label>\n        <ion-label>Details</ion-label>\n      </ng-template>\n\n      <div class=\"ion-padding\">\n        A first tab<br/>\n\n        <ion-button (click)=\"toggleThird()\">\n          Third tab ?\n        </ion-button>\n      </div>\n\n    </mat-tab>\n\n    <!-- TAB: 2 -->\n    <mat-tab [label]=\"secondTabTitle\" class=\"ion-padding\">\n      <ng-template mat-tab-label>\n        <ion-label>{{secondTabTitle}}</ion-label>\n      </ng-template>\n\n      <div class=\"ion-padding\">\n        A second tab<br/>\n\n        <ng-container *ngIf=\"secondTabTitle=== 'Others'\">\n          Navigate to : <a [routerLink]=\"childPath\" >\n            {{ childPath }}\n          </a>\n        </ng-container>\n      </div>\n\n    </mat-tab>\n\n    <!-- TAB: 3 -->\n    <mat-tab *ngIf=\"thirdTabTitle\"\n             [label]=\"thirdTabTitle\" class=\"ion-padding\">\n      <ng-template mat-tab-label>\n        <ion-label>{{thirdTabTitle}}</ion-label>\n      </ng-template>\n\n      <div class=\"ion-padding\">\n        A third tab\n      </div>\n\n    </mat-tab>\n  </mat-tab-group>\n</ion-content>\n", styles: [".menu-item{padding-left:0 px}\n"] }]
+        }], ctorParameters: function () { return [{ type: i1.ActivatedRoute }, { type: i1.Router }, { type: i2.NavController }, { type: i2.AlertController }, { type: i3.TranslateService }, { type: i4.MenuService }]; } });
+//# sourceMappingURL=data:application/json;base64,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