@sumaris-net/ngx-components 2.4.112 → 2.4.115

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

@@ -1,13 +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() {
+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._debug = !environment.production;
+        this.$items.next((rootItems || []).map(i => this.prepareItem(i)));
+    }
+    get rootItems() {
+        return this.$items.value;
     }
     get opened() {
         return this._$opened.asObservable();
@@ -43,13 +72,227 @@ export class MenuService {
     _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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

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

@@ -0,0 +1,106 @@
+import { Component, ViewChildren } from '@angular/core';
+import { AppTabEditor } from '../../form/entity/editor.class';
+import { MenuItems } from "../menu.model";
+import { MatTab } from "@angular/material/tabs";
+import { Subject } from "rxjs";
+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 MenuTestingPage extends AppTabEditor {
+    constructor(route, // Modal editor give 'null'
+    router, navController, alertCtrl, translate, menuService) {
+        super(route, router, navController, alertCtrl, translate, {
+            tabCount: 2
+        });
+        this.menuService = menuService;
+        this.logPrefix = '[menu-testing] ';
+        this.childPath = '';
+        this.title = '';
+        this.secondTabTitle = '';
+        this.parentPath = null;
+        this.thirdTabTitle = null;
+    }
+    ngOnInit() {
+        console.debug(`${this.logPrefix} Init page...`);
+        super.ngOnInit();
+        this.initSubMenu();
+    }
+    ngAfterViewInit() {
+        super.ngAfterViewInit();
+        //
+        // MenuTestingPage.tabsChanges.next(this.tabs.toArray());
+        // this.registerSubscription(
+        //     this.tabs.changes
+        //         .subscribe(_ => MenuTestingPage.tabsChanges.next(this.tabs.toArray()))
+        // );
+    }
+    ngOnDestroy() {
+        super.ngOnDestroy();
+        console.debug(`${this.logPrefix}Destroying...`);
+    }
+    load(id, options) {
+        return Promise.resolve(undefined);
+    }
+    get isNewData() {
+        return false;
+    }
+    reload() {
+        return Promise.resolve(undefined);
+    }
+    save(event, options) {
+        return Promise.resolve(false);
+    }
+    toggleThird() {
+        if (!this.thirdTabTitle) {
+            this.thirdTabTitle = 'Third';
+        }
+        else {
+            this.thirdTabTitle = null;
+        }
+    }
+    initSubMenu() {
+        const pathParam = MenuItems.parsePathWithQuery(this.router.url);
+        this.title = 'Menu';
+        this.secondTabTitle = 'Others';
+        this.parentPath = '/testing';
+        this.childPath = '/testing/shared/menu/other';
+        const path = '/testing/shared/menu';
+        console.debug(`${this.logPrefix} Setup with`, { path, parentPath: this.parentPath });
+        this.menuService.addSubMenuItems([
+            {
+                title: 'Menu',
+                path,
+                parentPath: this.parentPath,
+                action: null,
+                profile: 'GUEST',
+            },
+            {
+                title: this.secondTabTitle,
+                path,
+                pathParams: { tab: '1' },
+                parentPath: path,
+                action: null,
+                profile: 'GUEST',
+            }
+        ]);
+    }
+    getFirstInvalidTabIndex() {
+        return 0;
+    }
+}
+MenuTestingPage.tabsChanges = new Subject();
+MenuTestingPage.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: MenuTestingPage, deps: [{ token: i1.ActivatedRoute }, { token: i1.Router }, { token: i2.NavController }, { token: i2.AlertController }, { token: i3.TranslateService }, { token: i4.MenuService }], target: i0.ɵɵFactoryTarget.Component });
+MenuTestingPage.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "14.3.0", type: MenuTestingPage, selector: "app-testing-menu", viewQueries: [{ propertyName: "tabs", predicate: MatTab, descendants: true }], 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: MenuTestingPage, decorators: [{
+            type: Component,
+            args: [{ selector: 'app-testing-menu', 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 }]; }, propDecorators: { tabs: [{
+                type: ViewChildren,
+                args: [MatTab]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"menu.testing.js","sourceRoot":"","sources":["../../../../../../../src/app/core/menu/testing/menu.testing.ts","../../../../../../../src/app/core/menu/testing/menu.testing.html"],"names":[],"mappings":"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","sourcesContent":["import {AfterViewInit, Component, OnDestroy, OnInit, Optional, QueryList, ViewChildren} from '@angular/core';\nimport {MenuService} from '../menu.service';\nimport {AppTabEditor} from '../../form/entity/editor.class';\nimport {ActivatedRoute, Router} from '@angular/router';\nimport {AlertController, NavController} from '@ionic/angular';\nimport {TranslateService} from '@ngx-translate/core';\nimport {MenuItems} from \"../menu.model\";\nimport {MatTab} from \"@angular/material/tabs\";\nimport {Subject} from \"rxjs\";\n\n@Component({\n  selector: 'app-testing-menu',\n  templateUrl: './menu.testing.html',\n  styleUrls: ['./menu.testing.scss'],\n})\nexport class MenuTestingPage extends AppTabEditor\n  implements OnInit, OnDestroy, AfterViewInit {\n\n\n  static tabsChanges = new Subject<MatTab[]>();\n\n  protected logPrefix = '[menu-testing] ';\n  protected childPath = '';\n  protected title = '';\n  protected secondTabTitle = '';\n  protected parentPath: string = null;\n\n  protected thirdTabTitle = null;\n\n  @ViewChildren(MatTab) tabs!: QueryList<MatTab>;\n\n\n  constructor(\n    route: ActivatedRoute, // Modal editor give 'null'\n    router: Router,\n    navController: NavController,\n    alertCtrl: AlertController,\n    translate: TranslateService,\n    protected menuService: MenuService\n  ) {\n    super(route, router, navController, alertCtrl, translate, {\n      tabCount: 2\n    });\n  }\n\n  ngOnInit() {\n    console.debug(`${this.logPrefix} Init page...`);\n\n    super.ngOnInit();\n\n\n\n\n    this.initSubMenu();\n  }\n\n  ngAfterViewInit() {\n    super.ngAfterViewInit();\n    //\n    // MenuTestingPage.tabsChanges.next(this.tabs.toArray());\n    // this.registerSubscription(\n    //     this.tabs.changes\n    //         .subscribe(_ => MenuTestingPage.tabsChanges.next(this.tabs.toArray()))\n    // );\n  }\n\n  ngOnDestroy() {\n    super.ngOnDestroy();\n    console.debug(`${this.logPrefix}Destroying...`);\n  }\n\n  load(id?: number, options?: any): Promise<void> {\n    return Promise.resolve(undefined);\n  }\n\n  get isNewData(): boolean {\n    return false;\n  }\n\n  reload(): Promise<void> {\n    return Promise.resolve(undefined);\n  }\n\n  save(event: Event | undefined, options: any): Promise<boolean> {\n    return Promise.resolve(false);\n  }\n\n  protected toggleThird() {\n    if (!this.thirdTabTitle) {\n      this.thirdTabTitle = 'Third';\n    }\n    else {\n      this.thirdTabTitle = null;\n    }\n  }\n\n  protected initSubMenu() {\n    const pathParam = MenuItems.parsePathWithQuery(this.router.url);\n    this.title = 'Menu';\n    this.secondTabTitle = 'Others';\n    this.parentPath = '/testing';\n    this.childPath = '/testing/shared/menu/other';\n    const path = '/testing/shared/menu';\n    console.debug(`${this.logPrefix} Setup with`, {path, parentPath: this.parentPath});\n    this.menuService.addSubMenuItems(\n      [\n        {\n          title: 'Menu',\n          path,\n          parentPath: this.parentPath,\n          action: null,\n          profile: 'GUEST',\n        },\n        {\n          title: this.secondTabTitle,\n          path,\n          pathParams: {tab: '1'},\n          parentPath: path,\n          action: null,\n          profile: 'GUEST',\n        }\n      ]\n    );\n  }\n\n  protected getFirstInvalidTabIndex(): number {\n    return 0;\n  }\n}\n","<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"]}