@bizdoc/core 1.14.9 → 1.14.10

package/esm2020/lib/core/slots/slots.component.mjs

@@ -0,0 +1,1141 @@
+import { Component, EventEmitter, Inject, Output, ViewChild, ViewContainerRef, HostListener } from '@angular/core';
+import { isObservable, Subject } from 'rxjs';
+import { takeUntil, tap } from 'rxjs/operators';
+import { isArray, isBoolean, isDate, isPromise, isString } from '../functions';
+import { PANES_DATA, PaneRef, QueryParamNavigation, ParamNavigation, NavigationStart, NavigationClose, NavigationEnd, NavigationFocus, PATH_CHAR, QUERY_CHAR, ARG_CHAR, PANE_CHAR, CollapseNavigation, BackNavigation, NavigationExpand, NavigationResize, } from './pane-ref';
+import { CdkScrollable } from '@angular/cdk/overlay';
+import { panesAnimation, paneAnimation, panesTitleAnimation, paramAnimation, queryAnimation, tabAnimation, tabsAnimation } from '../animations';
+import { DEFAULT_POLICY, OpenPolicy } from '../configuration';
+import { debounceTime } from 'rxjs';
+import * as i0 from "@angular/core";
+import * as i1 from "../session.service";
+import * as i2 from "./router.service";
+import * as i3 from "../window-title.service";
+import * as i4 from "../guide/guide.service";
+import * as i5 from "@angular/material/button";
+import * as i6 from "@angular/material/icon";
+import * as i7 from "../../home/tools.component";
+import * as i8 from "@angular/material/tabs";
+import * as i9 from "@angular/common";
+import * as i10 from "@angular/material/core";
+import * as i11 from "../popup/tooltip.directive";
+import * as i12 from "@angular/cdk/scrolling";
+import * as i13 from "../NgComponentOutlet";
+import * as i14 from "@angular/material/badge";
+import * as i15 from "../pipes/translate.pipe";
+const DEFAULT_ROUTE = ['dashboard'];
+export class SlotsComponent {
+    constructor(data, _session, _cd, _router, _title, _guide, _injector) {
+        this._session = _session;
+        this._cd = _cd;
+        this._router = _router;
+        this._title = _title;
+        this._guide = _guide;
+        this._injector = _injector;
+        this.dialogChange = new EventEmitter();
+        this.titleAnimation = 0;
+        this.panes = [];
+        this.tabs = [];
+        this._selectedTabIndex = -1;
+        this.dialog = false;
+        this.selectedIndex = -1;
+        this.dragging = false;
+        this.ripple = {
+            color: this._session.getAccent(),
+            centered: true,
+            radius: 25
+        };
+        this.accent = this._session.getAccent();
+        this._pending = [];
+        this._rtl = this._session.inverse;
+        this._resizing = new Subject();
+        this._destroy = new Subject();
+        _session.themeChange.pipe(takeUntil(this._destroy)).
+            subscribe(() => this.accent = _session.getAccent());
+        _router._comm$.
+            subscribe(e => {
+            switch (e) {
+                case 'collapse':
+                    this.collapse();
+                    break;
+                default:
+            }
+        });
+        this._repository = prepareRoutes(data);
+    }
+    get selectedTabIndex() {
+        return this._selectedTabIndex;
+    }
+    set selectedTabIndex(value) {
+        this._selectedTabIndex = value;
+        if (this._selectedTabIndex > -1 && this.tabs.at(this._selectedTabIndex).dialog) {
+            this.dialog = true;
+            this.dialogChange.emit(true);
+        }
+        else {
+            this.dialog = false;
+        }
+        this._setTabAnimation();
+    }
+    _setTabAnimation() {
+        this.tabsAnimation = {
+            value: this.selectedTabIndex,
+            params: {
+                startWidth: this._tabsElement ? this._tabsElement.nativeElement.clientWidth : 0
+            }
+        };
+    }
+    ngOnInit() {
+        this._router._navigate$.
+            subscribe(async (n) => {
+            const { commands, component, pathMode, relativeTo } = n;
+            let { icon, title, group, help, policy, queryParams, state } = n;
+            let queryString, params, parent, path, route;
+            if (commands && commands.length) {
+                path = n.commands.join('/');
+                if (path.indexOf(QUERY_CHAR) > -1) {
+                    const segs = path.split(QUERY_CHAR);
+                    queryString = segs[1];
+                    queryParams = this._parseQueryParams(queryString || '');
+                    path = segs[0];
+                }
+                else {
+                    queryParams = n.queryParams || {};
+                    queryString = this._queryString(queryParams);
+                }
+                if (pathMode === 'relative' || path.startsWith('../')) {
+                    parent = relativeTo || this.panes[this.selectedIndex];
+                    let parentpath = parent.path;
+                    while (path.startsWith('../')) {
+                        parentpath = parentpath.substr(0, parentpath.lastIndexOf('/'));
+                        path = path.substr(3);
+                    }
+                    path = parentpath + '/' + path;
+                }
+                route = this._match(path);
+                if (!route)
+                    throw `no match ${path}`;
+                params = this._params(route, path);
+                if (!policy)
+                    policy = route.policy || DEFAULT_POLICY;
+                else if (route.policy)
+                    policy |= route.policy;
+                if (!icon)
+                    icon = route.icon;
+                if (!help)
+                    help = route.help;
+            }
+            else {
+                if (!policy)
+                    policy = DEFAULT_POLICY;
+                if (!queryParams)
+                    queryParams = {};
+            }
+            if ((policy & OpenPolicy.Clear) == OpenPolicy.Clear) {
+                this._clearPending();
+                await this._clearTabs();
+                if (!(policy & OpenPolicy.Tab))
+                    await this._clearPanes();
+            }
+            if (commands) {
+                let i = 0;
+                if ((policy & OpenPolicy.Tab) == OpenPolicy.Tab)
+                    while (i < this.tabs.length) {
+                        let tab = this.tabs[i];
+                        if (path === tab.path) {
+                            if (queryString === tab.queryString) {
+                                if ((policy & OpenPolicy.Toggle) == OpenPolicy.Toggle) {
+                                    this.tabs.splice(i, 1);
+                                    this.selectedTabIndex = this.tabs.length - 1;
+                                }
+                                else {
+                                    state && tab._data$.next(state);
+                                    this.group = tab.group;
+                                    this.selectedTabIndex = i;
+                                    this._cd.detectChanges();
+                                }
+                                return;
+                            }
+                            else {
+                                this._navQueryParams(tab, queryParams, state);
+                                this.group = tab.group;
+                                this.selectedTabIndex = i;
+                                this._cd.detectChanges();
+                                this._syncBrowserHistory();
+                                return;
+                            }
+                        }
+                        else if (tab.route === route) {
+                            await this._navParams(path, tab, params, queryParams, state);
+                            this.group = tab.group;
+                            this.selectedTabIndex = i;
+                            this._syncBrowserHistory();
+                            return;
+                        }
+                        i++;
+                    }
+                else
+                    while (i < this.panes.length) {
+                        let pane = this.panes[i];
+                        if (path === pane.path) {
+                            if (queryString === pane.queryString) {
+                                if ((policy & OpenPolicy.Toggle) == OpenPolicy.Toggle)
+                                    await this.removeAt(i);
+                                else {
+                                    state && pane._data$.next(state);
+                                    this._cd.detectChanges();
+                                    this.scrollTo(i);
+                                }
+                                return;
+                            }
+                            else {
+                                this._navQueryParams(pane, queryParams, state);
+                                this.scrollTo(i);
+                                this._syncBrowserHistory();
+                                return;
+                            }
+                        }
+                        else if (pane.route === route) {
+                            await this._navParams(path, pane, params, queryParams, state);
+                            this._syncBrowserHistory();
+                            return;
+                        }
+                        i++;
+                    }
+                if (commands.length) {
+                    if (!state)
+                        state = {};
+                    await this._state(route, path, params, state);
+                    if ((policy & OpenPolicy.Tab) == OpenPolicy.Tab)
+                        this._insertTab(component || route.component, {
+                            queryString,
+                            path,
+                            route,
+                            icon,
+                            title,
+                            group,
+                            help,
+                            data: state,
+                            parent,
+                            params,
+                            queryParams,
+                            policy
+                        });
+                    else
+                        this._insertPane(component || route.component, {
+                            queryString,
+                            path,
+                            route,
+                            icon,
+                            title,
+                            help,
+                            data: state,
+                            parent,
+                            params,
+                            queryParams,
+                            policy
+                        });
+                    route &&
+                        this._syncBrowserHistory();
+                }
+                else {
+                    const pane = (policy & OpenPolicy.Tab) == OpenPolicy.Tab ?
+                        this.tabs[this.selectedTabIndex] : this.panes[this.selectedIndex];
+                    this._navQueryParams(pane, queryParams, state);
+                    this._syncBrowserHistory();
+                    if ((policy & OpenPolicy.Tab) != OpenPolicy.Tab)
+                        this.select(this.selectedIndex);
+                }
+            }
+            else {
+                if ((policy & OpenPolicy.Tab) == OpenPolicy.Tab)
+                    this._insertTab(component, {
+                        data: state,
+                        icon, title, help,
+                        parent,
+                        queryString,
+                        path,
+                        route,
+                        group,
+                        params,
+                        queryParams,
+                        policy
+                    });
+                else
+                    this._insertPane(component, {
+                        data: state,
+                        icon, title, help,
+                        parent,
+                        queryString,
+                        path,
+                        route,
+                        params,
+                        policy, queryParams
+                    });
+            }
+        });
+        window.removeAllListeners('popstate');
+        window.addEventListener('popstate', e => {
+            if (this._navigationInProcess) {
+                this._navigationInProcess = false;
+                return;
+            }
+            if (e.state && e.state.bizdoc) {
+                const evt = new BackNavigation();
+                if (evt._preventDefault)
+                    return;
+                this._router._events$.next(evt);
+                const state = e.state;
+                this._deserialize(location.pathname.substring(1), state);
+                this.swap = state.swap;
+                this.swapTab = state.swapTab;
+                this.prevGroup = state.prevGroup;
+                this.group = state.group;
+                this.selectedTabIndex = state.selectedTabIndex;
+            }
+            else
+                this._deserialize(location.pathname.substring(1));
+        });
+        if (location.pathname.length > 1)
+            this._deserialize(location.pathname.substring(1), history.state && history.state.bizdoc ? history.state : undefined);
+        else
+            this._router._navigate$.next({
+                commands: DEFAULT_ROUTE,
+            });
+        this._resizing.pipe(debounceTime(150)).subscribe(this._resize.bind(this));
+    }
+    async _deserialize(url, state) {
+        const sections = decodeURIComponent(url).split(PANE_CHAR), panes = deserialize(sections[0]), tabs = sections.length > 1 ? deserialize(sections[1]) : [];
+        function deserialize(path) {
+            return path.
+                split(PATH_CHAR).map(s => {
+                const [path, queryString] = s.split(QUERY_CHAR);
+                return { path, queryString };
+            });
+        }
+        for (let i = 0; i < panes.length; i++) {
+            let pane = panes[i];
+            await this._navigatePane(i, pane.path, pane.queryString, state ? state.panes[i] : null);
+        }
+        if (this.panes.length > panes.length) {
+            let i = 0;
+            while (i < this.panes.length) {
+                let pane = this.panes[i];
+                if (panes.length - 1 < i || pane.path !== panes[i].path) {
+                    if (this.selectedIndex === i)
+                        this.selectedIndex = i - 1;
+                    this.panes.splice(i, 1);
+                    this._destroyPane(pane);
+                }
+                else
+                    i++;
+            }
+        }
+        if (this.selectedIndex < 0)
+            this.select(0);
+        for (let i = 0; i < tabs.length; i++) {
+            let tab = tabs[i];
+            await this._navigateTab(i, tab.path, tab.queryString, state ? state.tabs[i] : null);
+        }
+        if (this.tabs.length > tabs.length) {
+            let i = 0;
+            while (i < this.tabs.length) {
+                let tab = this.tabs[i];
+                if (tabs.length - 1 < i || tab.path !== tabs[i].path) {
+                    if (this.selectedTabIndex === i) {
+                        this.selectedTabIndex = i - 1;
+                    }
+                    this.tabs.splice(i, 1);
+                    this._destroyPane(tab);
+                }
+                else
+                    i++;
+            }
+        }
+        if (this.tabs.length && this.selectedTabIndex < 0) {
+            this.selectedTabIndex = 0;
+        }
+        const n = this.panes.length;
+        for (let i = 0; i < n; i++) {
+            let pane = this.panes[i];
+            if (pane.expanded !== (n === 1)) {
+                const evt = new NavigationExpand(pane._expanded = n === 1, pane);
+                pane._events$.next(evt);
+            }
+        }
+    }
+    /**
+     *
+     * @param index
+     * @param path
+     * @param queryString
+     * @param state
+     */
+    async _navigatePane(index, path, queryString, state) {
+        const route = this._match(path);
+        if (!route)
+            throw `no match ${path}`;
+        if (!state)
+            state = {};
+        while (index < this.panes.length) {
+            let pane = this.panes[index];
+            if (path === pane.path) {
+                if (queryString === pane.queryString) {
+                    return;
+                }
+                else {
+                    const queryParams = this._parseQueryParams(queryString);
+                    this._navQueryParams(pane, queryParams, state);
+                    return;
+                }
+            }
+            else if (pane.route === route) {
+                const queryParams = this._parseQueryParams(queryString);
+                const params = this._params(pane.route, path);
+                await this._navParams(path, pane, params, queryParams, state);
+                return;
+            }
+            index++;
+        }
+        const params = this._params(route, path);
+        const queryParams = this._parseQueryParams(queryString);
+        const parent = this._findAncestor(route, path);
+        await this._state(route, path, params, state);
+        this._insertPane(route.component, {
+            path, parent, route, data: state, params, queryParams,
+            icon: route.icon,
+            help: route.help,
+            policy: route.policy,
+            focus: false
+        });
+    }
+    async _navigateTab(index, path, queryString, state) {
+        const route = this._match(path);
+        if (!route)
+            throw `no match ${path}`;
+        if (!state)
+            state = {};
+        while (index < this.tabs.length) {
+            let tab = this.tabs[index];
+            if (path === tab.path) {
+                if (queryString === tab.queryString) {
+                    return;
+                }
+                else {
+                    const queryParams = this._parseQueryParams(queryString);
+                    this._navQueryParams(tab, queryParams, state);
+                    return;
+                }
+            }
+            else if (tab.route === route) {
+                const queryParams = this._parseQueryParams(queryString);
+                const params = this._params(tab.route, path);
+                await this._navParams(path, tab, params, queryParams, state);
+                return;
+            }
+            index++;
+        }
+        const params = this._params(route, path);
+        const queryParams = this._parseQueryParams(queryString);
+        const parent = this._findAncestor(route, path);
+        await this._state(route, path, params, state);
+        this._insertTab(route.component, {
+            icon: route.icon,
+            help: route.help,
+            policy: route.policy | OpenPolicy.Tab,
+            path, parent, route,
+            data: state,
+            params, queryParams,
+            focus: false,
+            swap: false
+        });
+    }
+    _findAncestor(route, path) {
+        if (route.parent)
+            return this.panes.find(p => p.route ===
+                route.parent &&
+                path.startsWith(p.path));
+    }
+    /**
+     *
+     * @param pane
+     * @param queryParams
+     */
+    _navQueryParams(pane, queryParams, state) {
+        pane._queryString = this._queryString(queryParams);
+        state && pane._data$.next(state);
+        pane._queryParams$.next(queryParams);
+        const evt = new QueryParamNavigation(queryParams, pane);
+        pane._events$.next(evt);
+        this._router._events$.next(evt);
+    }
+    /**
+     *
+     * @param path
+     * @param pane
+     * @param params
+     * @param queryParams
+     * @param state
+     */
+    async _navParams(path, pane, params, queryParams, state) {
+        if (pane.route.canDismiss)
+            await this._dismiss(pane);
+        if (!state)
+            state = {};
+        await this._state(pane.route, path, params, state);
+        pane._data$.next(state);
+        pane._path = path;
+        pane._params$.next(params);
+        if (queryParams) {
+            pane._queryString = this._queryString(queryParams);
+            pane._queryParams$.next(queryParams);
+        }
+        else {
+            pane._queryString = '';
+            pane._queryParams$.next({});
+        }
+        const evt = new ParamNavigation(params, pane);
+        pane._events$.next(evt);
+        this._router._events$.next(evt);
+        this.panes.concat(this.tabs).forEach(child => {
+            if (child.route && child.route.parent === pane.route) {
+                child._data$.next(Object.assign(child.data, state));
+                child._params$.next(params);
+                child._path = pane.path + '/' + child.route.path;
+                if (this.selectedTabIndex > -1 && child === this.tabs[this.selectedTabIndex]) {
+                    this.selectedTabIndex = this.selectedTabIndex;
+                    this.group = child.group;
+                }
+            }
+        });
+        if (pane.mode === 'pane')
+            this.titleAnimation++;
+        this._cd.detectChanges();
+    }
+    /** */
+    _syncBrowserHistory() {
+        let path = this.panes.filter(p => p.route).map(s => s.fullPath).join(PATH_CHAR);
+        if (this.tabs.length) {
+            const tabs = this.tabs.filter(p => p.route);
+            if (tabs.length)
+                path += PANE_CHAR + tabs.map(s => s.fullPath).join(PATH_CHAR);
+        }
+        const state = this._constructHistoryState();
+        this._navigationInProcess = true;
+        history.pushState(state, '', '/' + path);
+        setTimeout(() => this._navigationInProcess = false, 200);
+    }
+    _constructHistoryState() {
+        return {
+            bizdoc: true,
+            step: history.state && history.state.bizdoc ? history.state.step + 1 : 1,
+            selectedTabIndex: this.selectedTabIndex,
+            panes: this.panes.map(p => p.data),
+            tabs: this.tabs.map(t => t.data),
+            swap: this.swap,
+            group: this.group,
+            swapTab: this.swapTab,
+            prevGroup: this.prevGroup
+        };
+    }
+    drop(evt) {
+        const pane = this.panes[evt.previousIndex];
+        this.panes.splice(evt.previousIndex, 1);
+        this.panes.splice(evt.currentIndex, 0, pane);
+        this._syncBrowserHistory();
+    }
+    togglePinned(pane) {
+        pane.pinned = !pane.pinned;
+        this.panes.forEach(s => {
+            if (s.decendentOf(pane))
+                s.pinned = pane.pinned;
+        });
+    }
+    _queryString(queryParams) {
+        const names = Object.keys(queryParams);
+        let queryString;
+        for (var i = 0; i < names.length; i++) {
+            let val = queryParams[names[i]];
+            if (val !== null && val !== undefined) {
+                if (!queryString)
+                    queryString = '';
+                else
+                    queryString = queryString + ARG_CHAR;
+                if (isString(val))
+                    queryString += `${names[i]}=${encodeURIComponent(val)}`;
+                else if (isArray(val))
+                    queryString += val.map(v => `${names[i]}=${v}`).join(ARG_CHAR);
+                else if (isDate(val))
+                    queryString += `${names[i]}=${val.toJSON()}`;
+                else
+                    queryString += `${names[i]}=${val}`;
+            }
+        }
+        return queryString;
+    }
+    _parseQueryParams(queryString) {
+        const queryParams = {};
+        queryString && queryString.
+            split(ARG_CHAR).forEach(p => {
+            const [name, value] = p.split('=');
+            if (!queryParams[name])
+                queryParams[name] = value;
+            else {
+                const vals = queryParams[name];
+                queryParams[name] = isArray(vals) ? [...vals, value] : [vals, value];
+            }
+        });
+        return queryParams;
+    }
+    /**
+     *
+     * @param route
+     * @param path
+     */
+    _params(route, path) {
+        const ex = route.regEx.exec(path), params = ex.groups;
+        return params || {};
+    }
+    /**
+     *
+     * @param url
+     */
+    _match(url) {
+        let route = this._repository.find(r => r.regEx.test(url));
+        if (route)
+            while (route.children) {
+                let child = route.children.find(r => r.regEx.test(url));
+                if (child)
+                    route = child;
+                else
+                    break;
+            }
+        return route;
+    }
+    /**
+     *
+     * @param route
+     * @param path
+     * @param params
+     * @param data
+     */
+    async _state(route, path, params, data) {
+        if (this._pending.indexOf(path) > -1) {
+            //this._ps.toast('Working');
+            throw 'already processing';
+        }
+        this._pending.push(path);
+        const { parent, resolve } = route;
+        if (parent)
+            await this._parentstate(parent, path, params, data);
+        if (resolve) {
+            await this._resolve(resolve, params, data);
+        }
+        this._pending.remove(path);
+    }
+    /**
+     *
+     * @param route
+     * @param path
+     * @param params
+     * @param data
+     */
+    async _parentstate(route, path, params, data) {
+        const { parent, resolve } = route;
+        if (parent)
+            await this._parentstate(parent, path, params, data);
+        const pane = this.panes.find(s => s.route && s.route === route
+            && path.startsWith(s.path));
+        pane && Object.assign(data, pane.data);
+        if (resolve)
+            await this._resolve(resolve, params, data);
+    }
+    async _resolve(resolve, params, data) {
+        const keys = Object.keys(resolve);
+        for (let i = 0; i < keys.length; i++) {
+            let key = keys[i];
+            if (!data[key]) {
+                const instance = this._injector.get(resolve[key]);
+                const value = instance.onResolve(params);
+                if (isPromise(value))
+                    await value.then(r => data[key] = r);
+                else if (isObservable(value))
+                    await value.pipe(tap(r => data[key] = r)).toPromise();
+                else
+                    data[key] = value;
+            }
+        }
+    }
+    add(component, options) {
+        return this.insert(this.panes.length, component, options);
+    }
+    insert(position, component, options) {
+        const pane = this._insertPane(component, options || {}, position);
+        return pane;
+    }
+    _insertPane(component, options, position) {
+        const stretchable = (options.policy & OpenPolicy.Stretch) == OpenPolicy.Stretch;
+        const pane = this._constract(component, {
+            mode: 'pane',
+            expanded: !this.panes.length,
+            stretchable,
+            ...options
+        });
+        if (position === undefined)
+            position = this.panes.length;
+        this.panes.push(pane);
+        this.titleAnimation++;
+        this._cd.detectChanges();
+        const evt = new NavigationStart(pane);
+        this._router._events$.next(evt);
+        if (options.focus !== false) {
+            this.selectedIndex = position;
+            this._title.set(pane.title);
+            if (this.panes.length > 1)
+                this.scrollTo(position);
+        }
+        this.enableNavigationArrows();
+        return pane;
+    }
+    /**
+     *
+     * @param component
+     * @param options
+     */
+    _constract(component, options) {
+        const pane = new PaneRef(component, this._injector, options);
+        pane._comm$.subscribe(e => this._paneCommand(e, pane));
+        return pane;
+    }
+    /**
+     *
+     * @param component
+     * @param options
+     */
+    _insertTab(component, options) {
+        const { policy } = options, dialog = (policy & OpenPolicy.Dialog) == OpenPolicy.Dialog, expandable = (policy & OpenPolicy.Expandable) == OpenPolicy.Expandable, dismissable = (policy & OpenPolicy.Dismissable) == OpenPolicy.Dismissable;
+        const tab = this._constract(component, {
+            mode: 'tab',
+            expanded: false,
+            ...options,
+            dialog,
+            dismissable,
+            expandable
+        });
+        this.tabs.push(tab);
+        this._cd.detectChanges();
+        this._router._events$.next(new NavigationStart(tab));
+        if (tab.group && this.group !== tab.group && options.swap !== false) {
+            let i = 0, swap = false;
+            do {
+                if (this.tabs[i].group !== tab.group) {
+                    this._destroyPane(this.tabs[i]);
+                    this.tabs.splice(i, 1);
+                    swap = true;
+                }
+                else
+                    i++;
+            } while (i < this.tabs.length);
+            if (swap) {
+                this.swapTab = this._getHistoryStep();
+                this.prevGroup = this.group;
+            }
+            this.group = tab.group;
+        }
+        else
+            this.swapTab = null;
+        if (options.focus !== false) {
+            this.selectedTabIndex = this.tabs.length - 1;
+        }
+        this._cd.detectChanges();
+        return tab;
+    }
+    guide(name) {
+        this._guide.start(name);
+    }
+    back() {
+        this._navBack(this.swap);
+        this.swap = null;
+    }
+    /**
+     *
+     * @param steps
+     */
+    async _navBack(steps) {
+        history.go(steps - history.state.step);
+    }
+    tabBack() {
+        this._navBack(this.swapTab);
+        this.swapTab = null;
+    }
+    /**
+     *
+     * @param command
+     * @param pane
+     */
+    async _paneCommand(command, pane) {
+        switch (command) {
+            case 'focus':
+                {
+                    if (pane.mode === 'tab') {
+                        this.selectedTabIndex = this.tabs.indexOf(pane);
+                    }
+                    else {
+                        const index = this.panes.indexOf(pane);
+                        this.focus(index);
+                    }
+                    break;
+                }
+            case 'close':
+                if (pane.mode === 'tab') {
+                    const index = this.tabs.indexOf(pane);
+                    this.closeTab(index);
+                }
+                else {
+                    const index = this.panes.indexOf(pane);
+                    await this.removeAt(index);
+                    this._clearPending();
+                    await this._clearTabs();
+                    if (this.panes.length)
+                        this._syncBrowserHistory();
+                    else
+                        this._router.navigate(DEFAULT_ROUTE);
+                }
+                break;
+            case 'expand':
+                if (pane.mode === 'tab')
+                    this.expandTab();
+                else
+                    this.expandPane();
+                break;
+            case 'recycle': {
+                const state = this._constructHistoryState();
+                history.replaceState(state, '');
+                break;
+            }
+        }
+    }
+    /**
+     * escape
+     * @param event
+     */
+    async collapse() {
+        if (!this.tabs.length)
+            return;
+        const evt = new CollapseNavigation();
+        this._router._events$.next(evt);
+        if (evt._preventDefault)
+            return;
+        this._clearPending();
+        await this._clearTabs();
+        this._syncBrowserHistory();
+    }
+    onResize() {
+        this._resizing.next();
+    }
+    /** */
+    _resize() {
+        if (this.panes.length > 1 && !this.panes[this.panes.length - 1].stretchable) {
+            const el = this._panesContainerRef.element.nativeElement, child = el.lastElementChild;
+            child.style.minWidth =
+                (el.parentElement.parentElement.clientWidth - el.parentElement.offsetLeft - child.offsetLeft - 2) + 'px';
+        }
+        this.tabs.concat(this.panes).forEach(p => p._events$.next(new NavigationResize({}, p)));
+    }
+    closeTab(position) {
+        const tab = this.tabs[position];
+        if (!this._closing(tab))
+            return;
+        this.tabs.splice(position, 1);
+        this._destroyPane(tab);
+        this.selectedTabIndex = this.tabs.length ? position > 0 ? position - 1 : 0 : -1;
+        this._syncBrowserHistory();
+    }
+    /**
+     *
+     * @param pane
+     */
+    _closing(pane) {
+        let evt = new NavigationClose(pane);
+        pane._events$.next(evt);
+        return !evt._preventDefault;
+    }
+    expandPane() {
+        const pane = this.panes[this.selectedIndex];
+        const evt = new NavigationExpand(pane._expanded = true, pane);
+        pane._events$.next(evt);
+        this._router._events$.next(evt);
+        if (evt._preventDefault)
+            return;
+        this.swap = this._getHistoryStep();
+        let i = 0;
+        do {
+            if (this.panes[i] !== pane) {
+                this._destroyPane(this.panes[i]);
+                this.panes.splice(i, 1);
+            }
+            else
+                i++;
+        } while (i < this.panes.length);
+        this.selectedIndex = 0;
+        this._syncBrowserHistory();
+    }
+    _getHistoryStep() {
+        return history.state && history.state.bizdoc ? history.state.step : 0;
+    }
+    expandTab() {
+        const tab = this.tabs[this.selectedTabIndex];
+        const evt = new NavigationExpand(tab._expanded = true, tab);
+        tab._events$.next(evt);
+        this._router._events$.next(evt);
+        if (evt._preventDefault)
+            return;
+        this.swap = this._getHistoryStep();
+        this.swapTab = null;
+        this.panes.forEach(p => this._destroyPane(p));
+        this.tabs.splice(this.selectedTabIndex, 1);
+        this.panes.splice(0, this.panes.length, tab);
+        tab._mode = 'pane';
+        this.selectedTabIndex = this.tabs.length ? 0 : -1;
+        this._syncBrowserHistory();
+    }
+    select(position) {
+        if (this.selectedIndex === position)
+            return;
+        if (position === -1) {
+            if (this.panes.length)
+                position = this.panes.length - 1;
+            else
+                return;
+        }
+        this.selectedIndex = position;
+        const pane = this.panes[position];
+        const evt = new NavigationFocus(pane);
+        pane._events$.next(evt);
+        this._router._events$.next(evt);
+        this._title.set(pane.title);
+    }
+    async removeAt(position) {
+        const pane = this.panes[position];
+        if (!this._closing(pane))
+            return;
+        await this._dismiss(pane);
+        this._discardPane(pane);
+        if (position >= this.selectedIndex)
+            this.select(-1);
+        this._syncBrowserHistory();
+    }
+    /**
+     *
+     * @param pane
+     */
+    async _dismiss(pane) {
+        const panes = this.panes.concat(this.tabs).
+            filter(s => s.decendentOf(pane) && s.route && s.route.canDismiss).
+            reverse();
+        pane.route && pane.route.canDismiss &&
+            panes.push(pane);
+        for (let i = 0; i < panes.length; i++) {
+            let ok = await this._dismissable(panes[i]);
+            if (!ok)
+                throw '';
+        }
+    }
+    /**
+     *
+     * @param pane
+     */
+    _discardPane(pane) {
+        this.panes.concat(this.tabs).
+            filter(s => s.decendentOf(pane)).
+            reverse().
+            forEach(s => this._discardPane(s));
+        this._destroyPane(pane);
+        const index = this.panes.indexOf(pane);
+        this.panes.splice(index, 1);
+    }
+    _clearPending() {
+        this._pending.splice(0, this._pending.length);
+    }
+    /** */
+    async _clearPanes() {
+        await this._dismissAll(this.panes);
+        this.panes.forEach(p => this._destroyPane(p));
+        this.panes.splice(0, this.panes.length);
+        this.selectedIndex = -1;
+        this.swap = null;
+    }
+    async _clearTabs() {
+        if (!this.tabs.length)
+            return;
+        await this._dismissAll(this.tabs);
+        this.tabs.forEach(t => this._destroyPane(t));
+        this.tabs.splice(0, this.tabs.length);
+        this.selectedTabIndex = -1;
+        this.swapTab = null;
+    }
+    /**
+     *
+     * @param panes
+     */
+    async _dismissAll(panes) {
+        for (let pane of panes.
+            filter(s => s.route && s.route.canDismiss)) {
+            let ok = await this._dismissable(pane);
+            if (!ok)
+                throw '';
+        }
+    }
+    /**
+     *
+     * @param pane
+     */
+    _dismissable(pane) {
+        const { instance, route: { canDismiss } } = pane;
+        const dismissable = this._injector.get(canDismiss);
+        const ok = dismissable.onDismiss(instance);
+        if (isBoolean(ok))
+            return Promise.resolve(ok);
+        else if (isPromise(ok))
+            return ok;
+        else
+            return ok.toPromise();
+    }
+    scrollTo(index) {
+        const item = this._children.item(index);
+        item && item.scrollIntoView({ behavior: 'smooth', inline: 'end', block: 'end' });
+    }
+    get _children() {
+        return this._panesContainerRef.element.nativeElement.querySelectorAll('.pane-content');
+    }
+    done() {
+        this.enableNavigationArrows();
+        this._resize();
+    }
+    enableNavigationArrows(_) {
+        const container = this._panesContainerRef.element.nativeElement, scrollLeft = Math.round(container.scrollLeft);
+        this.next = this._rtl ? container.clientWidth - scrollLeft < container.scrollWidth :
+            scrollLeft + container.clientWidth < container.scrollWidth;
+        this.prev = this._rtl ? scrollLeft < 0 : scrollLeft > 0;
+    }
+    scrollBy(n) {
+        const left = n * (this._rtl ? -1 : 1);
+        this._panesContainerRef.element.nativeElement.scrollBy({ behavior: 'smooth', left });
+    }
+    focus(index) {
+        const el = this._children.item(index);
+        el.focus();
+    }
+    onPaneResize(pane, event) {
+        const el = event.srcElement.previousElementSibling;
+        const // remember mouse down info
+        width = el.clientWidth, d = this._rtl ? -1 : 1;
+        event.srcElement.classList.add('resizing');
+        this.dragging = true;
+        document.onmousemove = onMouseMove;
+        document.onmouseup = () => {
+            event.srcElement.classList.remove('resizing');
+            document.onmousemove = document.onmouseup = null;
+            this.dragging = false;
+        };
+        function onMouseMove(e) {
+            const delta = (e.clientX - event.clientX) * d;
+            el.style.width = el.style.minWidth
+                = Math.max(width + delta, 350) + 'px';
+            pane._events$.next(new NavigationResize({}, pane));
+        }
+    }
+    onTabResize(event) {
+        const el = event.srcElement.nextElementSibling;
+        const me = this, 
+        // remember mouse down info
+        width = el.clientWidth, d = this._rtl ? 1 : -1;
+        event.srcElement.classList.add('resizing');
+        this.dragging = true;
+        document.onmousemove = onMouseMove;
+        document.onmouseup = () => {
+            event.srcElement.classList.remove('resizing');
+            document.onmousemove = document.onmouseup = null;
+            this.dragging = false;
+            me.enableNavigationArrows();
+            this._resize();
+        };
+        function onMouseMove(e) {
+            // prevent negative-sized elements
+            const delta = Math.max((e.clientX - event.clientX) * d, -width);
+            el.style.width = el.style.minWidth = (width + delta) + 'px';
+            localStorage.setItem('tabs', el.style.width);
+        }
+    }
+    _destroyPane(pane) {
+        pane._destroy();
+        const evt = new NavigationEnd(pane);
+        pane._events$.next(evt);
+        this._router._events$.next(evt);
+    }
+    ngOnDestroy() {
+        this._destroy.next();
+        this._destroy.complete();
+    }
+}
+SlotsComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.1", ngImport: i0, type: SlotsComponent, deps: [{ token: PANES_DATA }, { token: i1.SessionService }, { token: i0.ChangeDetectorRef }, { token: i2.PanesRouter }, { token: i3.WindowTitleService }, { token: i4.GuideService }, { token: i0.Injector }], target: i0.ɵɵFactoryTarget.Component });
+SlotsComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.3.1", type: SlotsComponent, selector: "bizdoc-panes-outlet", outputs: { dialogChange: "dialogChange" }, host: { listeners: { "document:keydown.escape": "collapse()", "window:resize": "onResize()" } }, viewQueries: [{ propertyName: "_panesContainerRef", first: true, predicate: ["panning"], descendants: true, read: ViewContainerRef, static: true }, { propertyName: "_tabsElement", first: true, predicate: ["tabing"], descendants: true }, { propertyName: "_scrollable", first: true, predicate: CdkScrollable, descendants: true, static: true }], ngImport: i0, template: "<div class=\"panes\">\r\n  <div class=\"scroll-arrow\" (click)=\"scrollBy(-400)\" matRipple [matRippleUnbounded]=\"true\" [matRippleCentered]=\"true\" [matRippleColor]=\"accent\"\r\n       *ngIf=\"prev\">\r\n    <i class=\"material-icons mat-icon-rtl-mirror\">\r\n      arrow_back_ios\r\n    </i>\r\n  </div>\r\n  <div class=\"panes-title\" [@title]=\"titleAnimation\">\r\n    <h1>\r\n      <button mat-icon-button (click)=\"back()\" *ngIf=\"swap\" [bizdocTooltip]=\"'Back'|translate\"><mat-icon class=\"mat-icon-rtl-mirror\">arrow_circle_left</mat-icon></button>\r\n      <ng-container *ngFor=\"let p of panes; let first = first\">\r\n        <span class=\"breadcrumbs\" *ngIf=\"!first\">\\</span>\r\n        {{p.title}}\r\n      </ng-container>\r\n      <button mat-icon-button (click)=\"guide(panes[0].guide)\" *ngIf=\"panes[0]?.guide\" [bizdocTooltip]=\"'Help'|translate\"><mat-icon>help</mat-icon></button>\r\n    </h1>\r\n    <span class=\"divider\">\r\n    </span>\r\n    <bizdoc-quicktools></bizdoc-quicktools>\r\n  </div>\r\n  <div #panning class=\"panes-container\"\r\n       cdkScrollable\r\n       @panes\r\n       (scroll)=\"enableNavigationArrows($event)\">\r\n    <ng-container *ngFor=\"let p of panes; let i = index\">\r\n      <div (mouseenter)=\"selectedIndex !== i && !dragging && select(i)\"\r\n           (click)=\"select(i)\"\r\n           [class.active]=\"selectedIndex === i\" class=\"pane-content\" @pane>\r\n        <ngx-component-outlet [type]=\"p.component\" [injector]=\"p.injector\" (create)=\"p._instance = $event\"></ngx-component-outlet>\r\n      </div>\r\n      <div class=\"pane-separator\" *ngIf=\"i < panes.length - 1\" (mousedown)=\"onPaneResize(p, $event)\">&nbsp;</div>\r\n    </ng-container>\r\n  </div>\r\n  <div class=\"backdrop\" *ngIf=\"dialog\" (click)=\"closeTab(selectedTabIndex)\"></div>\r\n  <div class=\"scroll-arrow forward\"\r\n       *ngIf=\"next\">\r\n    <i class=\"material-icons mat-icon-rtl-mirror\" matRipple [matRippleUnbounded]=\"true\" [matRippleCentered]=\"true\" [matRippleRadius]=\"30\" [matRippleColor]=\"accent\"\r\n       (click)=\"scrollBy(400)\">\r\n      arrow_forward_ios\r\n    </i>\r\n  </div>\r\n</div>\r\n<ng-container *ngIf=\"tabs.length\">\r\n  <div class=\"tabs-separator\" (mousedown)=\"onTabResize($event)\">&nbsp;</div>\r\n  <div class=\"mat-elevation-z18 tabs\" [@tabs]=\"tabsAnimation\" (@tabs.done)=\"done()\" #tabing>\r\n    <div class=\"row tabs-title\">\r\n      <button mat-icon-button (click)=\"tabBack()\" *ngIf=\"swapTab\" [bizdocTooltip]=\"prevGroup || ('Back'|translate)\"><mat-icon class=\"mat-icon-rtl-mirror\">arrow_back</mat-icon></button>\r\n      <h2>{{group}}</h2>\r\n      <button mat-icon-button (click)=\"expandTab()\" [bizdocTooltip]=\"'Expand'| translate\"><mat-icon inline=\"true\" class=\"mat-icon-rtl-mirror\">open_in_full</mat-icon></button>\r\n      <!--*ngIf=\"selectedTabIndex <=< -1 && tabs[selectedTabIndex].expandable\"-->\r\n      <span class=\"divider\"></span>\r\n      <button mat-icon-button (click)=\"collapse()\" bizdocTooltip=\"Esc\"><mat-icon>close</mat-icon></button>\r\n    </div>\r\n    <nav mat-tab-nav-bar color=\"accent\" [disablePagination]=\"true\">\r\n      <a mat-tab-link *ngFor=\"let t of tabs; let i = index\" class=\"mat-tab-link\"\r\n         (click)=\"selectedTabIndex = i\"\r\n         [active]=\"selectedTabIndex === i\">\r\n        <mat-icon [matBadge]=\"t.badge\" [matBadgeHidden]=\"!t.badge\" matBadgeSize=\"small\" matBadgeColor=\"accent\">{{t.icon}}</mat-icon>&nbsp;\r\n        {{t.title}}\r\n        <mat-icon *ngIf=\"t.dismissable\" (click)=\"closeTab(i)\" class=\"tool\">close</mat-icon>\r\n        <!--inline=\"true\"-->\r\n      </a>\r\n    </nav>\r\n    <div *ngFor=\"let t of tabs; let i = index\" [style.display]=\"selectedTabIndex === i ? '': 'none'\" class=\"tab\" [@tab]=\"selectedTabIndex\">\r\n      <ngx-component-outlet [type]=\"t.component\" [injector]=\"t.injector\" (create)=\"t._instance = $event\"></ngx-component-outlet>\r\n    </div>\r\n  </div>\r\n</ng-container>\r\n", styles: [":host{display:flex;flex-direction:row;flex-grow:1;overflow-x:hidden}.panes{flex-grow:1;position:relative;overflow-x:hidden;display:inline-flex;flex-direction:column;flex-basis:100%}.panes .panes-title{display:flex;flex-direction:row;align-items:center;min-width:max-content}.panes .panes-title h1{font-size:xx-large;margin:12px;font-weight:100}.panes .panes-title h1 button{vertical-align:middle}.panes .panes-title h1 .breadcrumbs{font-size:smaller}.panes .scroll-arrow{position:absolute;cursor:pointer;top:50%;z-index:1000}.panes .scroll-arrow i{font-size:50px;opacity:.2}.panes .scroll-arrow i:hover{opacity:.9}.panes .scroll-arrow:last-child{right:0}.panes .panes-container{overflow-x:auto;height:100%;display:flex;flex-direction:row}.panes .panes-container .pane-content{display:block;border-right:1px solid #00000014;height:inherit;border-left-width:1px;border-left-style:double;border-left-color:transparent;flex-grow:1;min-width:420px;overflow-y:auto}.panes .panes-container .pane-content .pane{flex-grow:1}.panes .panes-container .pane-separator{width:8px}.pane-separator,.tabs-separator{cursor:ew-resize;background-repeat:no-repeat;background-position:center;display:table;height:100%;-webkit-user-select:none;user-select:none}.tabs-separator{width:12px}::ng-deep [dir=rtl] .scroll-arrow:last-child{right:unset;left:0}.tabs{display:flex;flex-direction:column;z-index:1;-webkit-flex-grow:0;flex-shrink:1;flex-basis:0}.tabs .tabs-title{align-items:center}.tabs .tabs-title h2{font-size:x-large;margin:9px;font-weight:100}.tabs .tabs-title:hover{opacity:1}.tabs .mat-tab-link .tool{opacity:0}.tabs .mat-tab-link:hover .tool{opacity:1}.tabs .tab{flex-grow:1;overflow-y:auto;overflow-x:hidden;display:flex}\n"], components: [{ type: i5.MatButton, selector: "button[mat-button], button[mat-raised-button], button[mat-icon-button],             button[mat-fab], button[mat-mini-fab], button[mat-stroked-button],             button[mat-flat-button]", inputs: ["disabled", "disableRipple", "color"], exportAs: ["matButton"] }, { type: i6.MatIcon, selector: "mat-icon", inputs: ["color", "inline", "svgIcon", "fontSet", "fontIcon"], exportAs: ["matIcon"] }, { type: i7.QuickToolsComponent, selector: "bizdoc-quicktools" }, { type: i8.MatTabNav, selector: "[mat-tab-nav-bar]", inputs: ["color"], exportAs: ["matTabNavBar", "matTabNav"] }], directives: [{ type: i9.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { type: i10.MatRipple, selector: "[mat-ripple], [matRipple]", inputs: ["matRippleColor", "matRippleUnbounded", "matRippleCentered", "matRippleRadius", "matRippleAnimation", "matRippleDisabled", "matRippleTrigger"], exportAs: ["matRipple"] }, { type: i11.TooltipDirective, selector: "[bizdocTooltip]", inputs: ["bizdocTooltip", "bizdocTooltipTemplate", "bizdocTooltipContext", "bizdocTooltipPosition", "bizdocTooltipDuration", "bizdocTooltipDisabled"] }, { type: i9.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }, { type: i12.CdkScrollable, selector: "[cdk-scrollable], [cdkScrollable]" }, { type: i13.NgxComponentOutlet, selector: "ngx-component-outlet", inputs: ["type", "injector", "ngxComponentOutletContent"], outputs: ["create"] }, { type: i8.MatTabLink, selector: "[mat-tab-link], [matTabLink]", inputs: ["disabled", "disableRipple", "tabIndex"], exportAs: ["matTabLink"] }, { type: i14.MatBadge, selector: "[matBadge]", inputs: ["matBadgeDisabled", "matBadgeColor", "matBadgeOverlap", "matBadgePosition", "matBadge", "matBadgeDescription", "matBadgeSize", "matBadgeHidden"] }], pipes: { "translate": i15.TranslatePipe }, animations: [panesAnimation,
+        panesTitleAnimation,
+        paneAnimation,
+        paramAnimation,
+        queryAnimation,
+        tabsAnimation,
+        tabAnimation
+    ] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.1", ngImport: i0, type: SlotsComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'bizdoc-panes-outlet', animations: [panesAnimation,
+                        panesTitleAnimation,
+                        paneAnimation,
+                        paramAnimation,
+                        queryAnimation,
+                        tabsAnimation,
+                        tabAnimation
+                    ], template: "<div class=\"panes\">\r\n  <div class=\"scroll-arrow\" (click)=\"scrollBy(-400)\" matRipple [matRippleUnbounded]=\"true\" [matRippleCentered]=\"true\" [matRippleColor]=\"accent\"\r\n       *ngIf=\"prev\">\r\n    <i class=\"material-icons mat-icon-rtl-mirror\">\r\n      arrow_back_ios\r\n    </i>\r\n  </div>\r\n  <div class=\"panes-title\" [@title]=\"titleAnimation\">\r\n    <h1>\r\n      <button mat-icon-button (click)=\"back()\" *ngIf=\"swap\" [bizdocTooltip]=\"'Back'|translate\"><mat-icon class=\"mat-icon-rtl-mirror\">arrow_circle_left</mat-icon></button>\r\n      <ng-container *ngFor=\"let p of panes; let first = first\">\r\n        <span class=\"breadcrumbs\" *ngIf=\"!first\">\\</span>\r\n        {{p.title}}\r\n      </ng-container>\r\n      <button mat-icon-button (click)=\"guide(panes[0].guide)\" *ngIf=\"panes[0]?.guide\" [bizdocTooltip]=\"'Help'|translate\"><mat-icon>help</mat-icon></button>\r\n    </h1>\r\n    <span class=\"divider\">\r\n    </span>\r\n    <bizdoc-quicktools></bizdoc-quicktools>\r\n  </div>\r\n  <div #panning class=\"panes-container\"\r\n       cdkScrollable\r\n       @panes\r\n       (scroll)=\"enableNavigationArrows($event)\">\r\n    <ng-container *ngFor=\"let p of panes; let i = index\">\r\n      <div (mouseenter)=\"selectedIndex !== i && !dragging && select(i)\"\r\n           (click)=\"select(i)\"\r\n           [class.active]=\"selectedIndex === i\" class=\"pane-content\" @pane>\r\n        <ngx-component-outlet [type]=\"p.component\" [injector]=\"p.injector\" (create)=\"p._instance = $event\"></ngx-component-outlet>\r\n      </div>\r\n      <div class=\"pane-separator\" *ngIf=\"i < panes.length - 1\" (mousedown)=\"onPaneResize(p, $event)\">&nbsp;</div>\r\n    </ng-container>\r\n  </div>\r\n  <div class=\"backdrop\" *ngIf=\"dialog\" (click)=\"closeTab(selectedTabIndex)\"></div>\r\n  <div class=\"scroll-arrow forward\"\r\n       *ngIf=\"next\">\r\n    <i class=\"material-icons mat-icon-rtl-mirror\" matRipple [matRippleUnbounded]=\"true\" [matRippleCentered]=\"true\" [matRippleRadius]=\"30\" [matRippleColor]=\"accent\"\r\n       (click)=\"scrollBy(400)\">\r\n      arrow_forward_ios\r\n    </i>\r\n  </div>\r\n</div>\r\n<ng-container *ngIf=\"tabs.length\">\r\n  <div class=\"tabs-separator\" (mousedown)=\"onTabResize($event)\">&nbsp;</div>\r\n  <div class=\"mat-elevation-z18 tabs\" [@tabs]=\"tabsAnimation\" (@tabs.done)=\"done()\" #tabing>\r\n    <div class=\"row tabs-title\">\r\n      <button mat-icon-button (click)=\"tabBack()\" *ngIf=\"swapTab\" [bizdocTooltip]=\"prevGroup || ('Back'|translate)\"><mat-icon class=\"mat-icon-rtl-mirror\">arrow_back</mat-icon></button>\r\n      <h2>{{group}}</h2>\r\n      <button mat-icon-button (click)=\"expandTab()\" [bizdocTooltip]=\"'Expand'| translate\"><mat-icon inline=\"true\" class=\"mat-icon-rtl-mirror\">open_in_full</mat-icon></button>\r\n      <!--*ngIf=\"selectedTabIndex <=< -1 && tabs[selectedTabIndex].expandable\"-->\r\n      <span class=\"divider\"></span>\r\n      <button mat-icon-button (click)=\"collapse()\" bizdocTooltip=\"Esc\"><mat-icon>close</mat-icon></button>\r\n    </div>\r\n    <nav mat-tab-nav-bar color=\"accent\" [disablePagination]=\"true\">\r\n      <a mat-tab-link *ngFor=\"let t of tabs; let i = index\" class=\"mat-tab-link\"\r\n         (click)=\"selectedTabIndex = i\"\r\n         [active]=\"selectedTabIndex === i\">\r\n        <mat-icon [matBadge]=\"t.badge\" [matBadgeHidden]=\"!t.badge\" matBadgeSize=\"small\" matBadgeColor=\"accent\">{{t.icon}}</mat-icon>&nbsp;\r\n        {{t.title}}\r\n        <mat-icon *ngIf=\"t.dismissable\" (click)=\"closeTab(i)\" class=\"tool\">close</mat-icon>\r\n        <!--inline=\"true\"-->\r\n      </a>\r\n    </nav>\r\n    <div *ngFor=\"let t of tabs; let i = index\" [style.display]=\"selectedTabIndex === i ? '': 'none'\" class=\"tab\" [@tab]=\"selectedTabIndex\">\r\n      <ngx-component-outlet [type]=\"t.component\" [injector]=\"t.injector\" (create)=\"t._instance = $event\"></ngx-component-outlet>\r\n    </div>\r\n  </div>\r\n</ng-container>\r\n", styles: [":host{display:flex;flex-direction:row;flex-grow:1;overflow-x:hidden}.panes{flex-grow:1;position:relative;overflow-x:hidden;display:inline-flex;flex-direction:column;flex-basis:100%}.panes .panes-title{display:flex;flex-direction:row;align-items:center;min-width:max-content}.panes .panes-title h1{font-size:xx-large;margin:12px;font-weight:100}.panes .panes-title h1 button{vertical-align:middle}.panes .panes-title h1 .breadcrumbs{font-size:smaller}.panes .scroll-arrow{position:absolute;cursor:pointer;top:50%;z-index:1000}.panes .scroll-arrow i{font-size:50px;opacity:.2}.panes .scroll-arrow i:hover{opacity:.9}.panes .scroll-arrow:last-child{right:0}.panes .panes-container{overflow-x:auto;height:100%;display:flex;flex-direction:row}.panes .panes-container .pane-content{display:block;border-right:1px solid #00000014;height:inherit;border-left-width:1px;border-left-style:double;border-left-color:transparent;flex-grow:1;min-width:420px;overflow-y:auto}.panes .panes-container .pane-content .pane{flex-grow:1}.panes .panes-container .pane-separator{width:8px}.pane-separator,.tabs-separator{cursor:ew-resize;background-repeat:no-repeat;background-position:center;display:table;height:100%;-webkit-user-select:none;user-select:none}.tabs-separator{width:12px}::ng-deep [dir=rtl] .scroll-arrow:last-child{right:unset;left:0}.tabs{display:flex;flex-direction:column;z-index:1;-webkit-flex-grow:0;flex-shrink:1;flex-basis:0}.tabs .tabs-title{align-items:center}.tabs .tabs-title h2{font-size:x-large;margin:9px;font-weight:100}.tabs .tabs-title:hover{opacity:1}.tabs .mat-tab-link .tool{opacity:0}.tabs .mat-tab-link:hover .tool{opacity:1}.tabs .tab{flex-grow:1;overflow-y:auto;overflow-x:hidden;display:flex}\n"] }]
+        }], ctorParameters: function () { return [{ type: undefined, decorators: [{
+                    type: Inject,
+                    args: [PANES_DATA]
+                }] }, { type: i1.SessionService }, { type: i0.ChangeDetectorRef }, { type: i2.PanesRouter }, { type: i3.WindowTitleService }, { type: i4.GuideService }, { type: i0.Injector }]; }, propDecorators: { dialogChange: [{
+                type: Output
+            }], _panesContainerRef: [{
+                type: ViewChild,
+                args: ['panning', { read: ViewContainerRef, static: true }]
+            }], _tabsElement: [{
+                type: ViewChild,
+                args: ['tabing']
+            }], _scrollable: [{
+                type: ViewChild,
+                args: [CdkScrollable, { static: true }]
+            }], collapse: [{
+                type: HostListener,
+                args: ['document:keydown.escape']
+            }], onResize: [{
+                type: HostListener,
+                args: ['window:resize']
+            }] } });
+const PANE_PARAMS_REGEX = /(:[\w\-]+)/g;
+function prepareRoutes(routes, treePath) {
+    for (let i = 0; i < routes.length; i++) {
+        let route = routes[i], fullPath = (treePath ? (treePath + '/') : '') + route.path;
+        Object.assign(route, {
+            fullPath,
+            regEx: new RegExp('^' + fullPath.
+                replace('/', '\\/').
+                replace(PANE_PARAMS_REGEX, e => `(?<${e.substr(1)}>[\\w@\\-]*)`))
+        });
+        if (route.children) {
+            let children = prepareRoutes(route.children, fullPath);
+            for (var j = 0; j < children.length; j++)
+                Object.assign(children[j], {
+                    parent: route
+                });
+        }
+    }
+    return routes;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"slots.component.js","sourceRoot":"","sources":["../../../../../../libraries/core/src/lib/core/slots/slots.component.ts","../../../../../../libraries/core/src/lib/core/slots/slots.component.html"],"names":[],"mappings":"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","sourcesContent":["import { ChangeDetectorRef, Component, EventEmitter, Inject, Injector, OnDestroy, OnInit, Output, ViewChild, ViewContainerRef, HostListener, ElementRef } from '@angular/core';\r\nimport { RippleConfig } from '@angular/material/core/ripple';\r\nimport { CdkDragDrop } from '@angular/cdk/drag-drop';\r\nimport { isObservable, Subject } from 'rxjs';\r\nimport { takeUntil, tap } from 'rxjs/operators';\r\nimport { isArray, isBoolean, isDate, isPromise, isString } from '../functions';\r\nimport { PANES_DATA, PaneRef, PaneOptions, PaneCommand, QueryParamNavigation, ParamNavigation, NavigationMode, NavigationStart, NavigationClose, NavigationEnd, NavigationFocus, PATH_CHAR, QUERY_CHAR, ARG_CHAR, PANE_CHAR, CollapseNavigation, BackNavigation, NavigationExpand, PaneMode, NavigationResize, } from './pane-ref';\r\nimport { PanesRouter } from './router.service';\r\nimport { SessionService } from '../session.service';\r\nimport { CdkScrollable, ComponentType } from '@angular/cdk/overlay';\r\nimport { WindowTitleService } from '../window-title.service';\r\nimport { panesAnimation, paneAnimation, panesTitleAnimation, paramAnimation, queryAnimation, tabAnimation, tabsAnimation } from '../animations';\r\nimport { PaneResolve, PaneRoute, ParamMap, CanDismiss, DEFAULT_POLICY, OpenPolicy } from '../configuration';\r\nimport { GuideService } from '../guide/guide.service';\r\nimport { debounceTime } from 'rxjs';\r\ndeclare global {\r\n  interface Window {\r\n    removeAllListeners(name?: string);\r\n  }\r\n}\r\n\r\nconst DEFAULT_ROUTE = ['dashboard'];\r\n@Component({\r\n  selector: 'bizdoc-panes-outlet',\r\n  templateUrl: './slots.component.html',\r\n  styleUrls: ['./slots.component.scss'],\r\n  animations: [panesAnimation,\r\n    panesTitleAnimation,\r\n    paneAnimation,\r\n    paramAnimation,\r\n    queryAnimation,\r\n    tabsAnimation,\r\n    tabAnimation\r\n  ]\r\n})\r\nexport class SlotsComponent implements OnInit, OnDestroy {\r\n  @Output() readonly dialogChange = new EventEmitter<boolean>();\r\n  @ViewChild('panning', { read: ViewContainerRef, static: true }) _panesContainerRef: ViewContainerRef;\r\n  @ViewChild('tabing') _tabsElement: ElementRef;\r\n  @ViewChild(CdkScrollable, { static: true }) _scrollable: CdkScrollable;\r\n  titleAnimation = 0;\r\n  group: string;\r\n  swap?: number;\r\n  swapTab?: number;\r\n  prevGroup?: string;\r\n\r\n  readonly panes: PaneRef<any>[] = [];\r\n  readonly tabs: PaneRef<any>[] = [];\r\n  private _selectedTabIndex = -1;\r\n  dialog = false;\r\n  public get selectedTabIndex() {\r\n    return this._selectedTabIndex;\r\n  }\r\n  public set selectedTabIndex(value) {\r\n    this._selectedTabIndex = value;\r\n    if (this._selectedTabIndex > -1 && this.tabs.at(this._selectedTabIndex).dialog) {\r\n      this.dialog = true;\r\n      this.dialogChange.emit(true);\r\n    }\r\n    else {\r\n      this.dialog = false;\r\n    }\r\n    this._setTabAnimation();\r\n  }\r\n  private _setTabAnimation() {\r\n    this.tabsAnimation = {\r\n      value: this.selectedTabIndex,\r\n      params: {\r\n        startWidth: this._tabsElement ? this._tabsElement.nativeElement.clientWidth : 0\r\n      }\r\n    };\r\n  }\r\n  selectedIndex = -1;\r\n  next: boolean;\r\n  prev: boolean;\r\n  dragging: boolean = false;\r\n  tabsAnimation: {\r\n    value: number,\r\n    params: {\r\n      startWidth: number\r\n    }\r\n  };\r\n  readonly ripple: RippleConfig = {\r\n    color: this._session.getAccent(),\r\n    centered: true,\r\n    radius: 25\r\n  }\r\n  accent: string = this._session.getAccent();\r\n  private _navigationInProcess: boolean;\r\n  private _repository: ExtendedRoute[];\r\n  private readonly _pending = [] as string[];\r\n  private readonly _rtl = this._session.inverse;\r\n  private readonly _resizing = new Subject<void>();\r\n  private readonly _destroy = new Subject<void>();\r\n  constructor(\r\n    @Inject(PANES_DATA) data: ExtendedRoute[],\r\n    private _session: SessionService,\r\n    private _cd: ChangeDetectorRef,\r\n    private _router: PanesRouter,\r\n    private _title: WindowTitleService,\r\n    private _guide: GuideService,\r\n    private _injector: Injector) {\r\n    _session.themeChange.pipe(takeUntil(this._destroy)).\r\n      subscribe(() => this.accent = _session.getAccent());\r\n    _router._comm$.\r\n      subscribe(e => {\r\n        switch (e) {\r\n          case 'collapse':\r\n            this.collapse();\r\n            break;\r\n          default:\r\n        }\r\n      });\r\n    this._repository = prepareRoutes(data);\r\n  }\r\n\r\n  ngOnInit(): void {\r\n    this._router._navigate$.\r\n      subscribe(async n => {\r\n        const { commands, component, pathMode, relativeTo } = n;\r\n        let {\r\n          icon,\r\n          title,\r\n          group,\r\n          help,\r\n          policy,\r\n          queryParams,\r\n          state\r\n        } = n;\r\n        let\r\n          queryString: string,\r\n          params: ParamMap,\r\n          parent: PaneRef,\r\n          path: string,\r\n          route: ExtendedRoute;\r\n\r\n        if (commands && commands.length) {\r\n          path = n.commands.join('/');\r\n          if (path.indexOf(QUERY_CHAR) > -1) {\r\n            const segs = path.split(QUERY_CHAR);\r\n            queryString = segs[1];\r\n            queryParams = this._parseQueryParams(queryString || '');\r\n            path = segs[0];\r\n          }\r\n          else {\r\n            queryParams = n.queryParams || {};\r\n            queryString = this._queryString(queryParams);\r\n          }\r\n          if (pathMode === 'relative' || path.startsWith('../')) {\r\n            parent = relativeTo || this.panes[this.selectedIndex];\r\n            let parentpath = parent.path;\r\n            while (path.startsWith('../')) {\r\n              parentpath = parentpath.substr(0, parentpath.lastIndexOf('/'));\r\n              path = path.substr(3);\r\n            }\r\n            path = parentpath + '/' + path;\r\n          }\r\n          route = this._match(path);\r\n\r\n          if (!route)\r\n            throw `no match ${path}`;\r\n          params = this._params(route, path);\r\n          if (!policy) policy = route.policy || DEFAULT_POLICY;\r\n          else if (route.policy) policy |= route.policy;\r\n          if (!icon) icon = route.icon;\r\n          if (!help) help = route.help;\r\n        }\r\n        else {\r\n          if (!policy) policy = DEFAULT_POLICY;\r\n          if (!queryParams) queryParams = {};\r\n        }\r\n\r\n        if ((policy & OpenPolicy.Clear) == OpenPolicy.Clear) {\r\n          this._clearPending();\r\n          await this._clearTabs();\r\n          if (!(policy & OpenPolicy.Tab))\r\n            await this._clearPanes();\r\n        }\r\n        if (commands) {\r\n          let i = 0;\r\n          if ((policy & OpenPolicy.Tab) == OpenPolicy.Tab)\r\n            while (i < this.tabs.length) {\r\n              let tab = this.tabs[i];\r\n              if (path === tab.path) {\r\n                if (queryString === tab.queryString) {\r\n                  if ((policy & OpenPolicy.Toggle) == OpenPolicy.Toggle) {\r\n                    this.tabs.splice(i, 1);\r\n                    this.selectedTabIndex = this.tabs.length - 1;\r\n                  }\r\n                  else {\r\n                    state && tab._data$.next(state);\r\n                    this.group = tab.group;\r\n                    this.selectedTabIndex = i;\r\n                    this._cd.detectChanges();\r\n                  }\r\n                  return;\r\n                }\r\n                else {\r\n                  this._navQueryParams(tab, queryParams, state);\r\n                  this.group = tab.group;\r\n                  this.selectedTabIndex = i;\r\n                  this._cd.detectChanges();\r\n                  this._syncBrowserHistory();\r\n                  return;\r\n                }\r\n              }\r\n              else if (tab.route === route) {\r\n                await this._navParams(path, tab, params, queryParams, state);\r\n                this.group = tab.group;\r\n                this.selectedTabIndex = i;\r\n                this._syncBrowserHistory();\r\n                return;\r\n              }\r\n              i++;\r\n            }\r\n          else\r\n            while (i < this.panes.length) {\r\n              let pane = this.panes[i];\r\n              if (path === pane.path) {\r\n                if (queryString === pane.queryString) {\r\n                  if ((policy & OpenPolicy.Toggle) == OpenPolicy.Toggle)\r\n                    await this.removeAt(i);\r\n                  else {\r\n                    state && pane._data$.next(state);\r\n                    this._cd.detectChanges();\r\n                    this.scrollTo(i);\r\n                  }\r\n                  return;\r\n                }\r\n                else {\r\n                  this._navQueryParams(pane, queryParams, state);\r\n                  this.scrollTo(i);\r\n                  this._syncBrowserHistory();\r\n                  return;\r\n                }\r\n              }\r\n              else if (pane.route === route) {\r\n                await this._navParams(path, pane, params, queryParams, state);\r\n                this._syncBrowserHistory();\r\n                return;\r\n              }\r\n              i++;\r\n            }\r\n          if (commands.length) {\r\n            if (!state) state = {};\r\n            await this._state(route, path, params, state);\r\n            if ((policy & OpenPolicy.Tab) == OpenPolicy.Tab)\r\n              this._insertTab(component || route.component,\r\n                {\r\n                  queryString,\r\n                  path,\r\n                  route,\r\n                  icon,\r\n                  title,\r\n                  group,\r\n                  help,\r\n                  data: state,\r\n                  parent,\r\n                  params,\r\n                  queryParams,\r\n                  policy\r\n                });\r\n            else\r\n              this._insertPane(component || route.component,\r\n                {\r\n                  queryString,\r\n                  path,\r\n                  route,\r\n                  icon,\r\n                  title,\r\n                  help,\r\n                  data: state,\r\n                  parent,\r\n                  params,\r\n                  queryParams,\r\n                  policy\r\n                });\r\n            route &&\r\n              this._syncBrowserHistory();\r\n          }\r\n          else {\r\n            const pane = (policy & OpenPolicy.Tab) == OpenPolicy.Tab ?\r\n              this.tabs[this.selectedTabIndex] : this.panes[this.selectedIndex];\r\n            this._navQueryParams(pane, queryParams, state);\r\n            this._syncBrowserHistory();\r\n            if ((policy & OpenPolicy.Tab) != OpenPolicy.Tab) this.select(this.selectedIndex);\r\n          }\r\n        }\r\n        else {\r\n          if ((policy & OpenPolicy.Tab) == OpenPolicy.Tab)\r\n            this._insertTab(component,\r\n              {\r\n                data: state,\r\n                icon, title, help,\r\n                parent,\r\n                queryString,\r\n                path,\r\n                route,\r\n                group,\r\n                params,\r\n                queryParams,\r\n                policy\r\n              });\r\n          else this._insertPane(component,\r\n            {\r\n              data: state,\r\n              icon, title, help,\r\n              parent,\r\n              queryString,\r\n              path,\r\n              route,\r\n              params,\r\n              policy, queryParams\r\n            });\r\n        }\r\n      });\r\n    window.removeAllListeners('popstate');\r\n    window.addEventListener('popstate', e => {\r\n      if (this._navigationInProcess) {\r\n        this._navigationInProcess = false;\r\n        return;\r\n      }\r\n      if (e.state && e.state.bizdoc) {\r\n        const evt = new BackNavigation();\r\n        if (evt._preventDefault) return;\r\n        this._router._events$.next(evt);\r\n        const state = e.state as HistoryState;\r\n        this._deserialize(location.pathname.substring(1), state);\r\n        this.swap = state.swap;\r\n        this.swapTab = state.swapTab;\r\n        this.prevGroup = state.prevGroup;\r\n        this.group = state.group;\r\n        this.selectedTabIndex = state.selectedTabIndex;\r\n      }\r\n      else\r\n        this._deserialize(location.pathname.substring(1));\r\n    });\r\n    if (location.pathname.length > 1)\r\n      this._deserialize(location.pathname.substring(1),\r\n        history.state && history.state.bizdoc ? history.state : undefined);\r\n    else\r\n      this._router._navigate$.next({\r\n        commands: DEFAULT_ROUTE,\r\n      });\r\n    this._resizing.pipe(debounceTime(150)).subscribe(this._resize.bind(this));\r\n  }\r\n  private async _deserialize(url: string, state?: HistoryState) {\r\n\r\n    const sections = decodeURIComponent(url).split(PANE_CHAR),\r\n      panes = deserialize(sections[0]),\r\n      tabs = sections.length > 1 ? deserialize(sections[1]) : [];\r\n\r\n    function deserialize(path: string) {\r\n      return path.\r\n        split(PATH_CHAR).map(s => {\r\n          const [path, queryString] = s.split(QUERY_CHAR);\r\n          return { path, queryString };\r\n        });\r\n    }\r\n\r\n    for (let i = 0; i < panes.length; i++) {\r\n      let pane = panes[i];\r\n      await this._navigatePane(i, pane.path, pane.queryString, state ? state.panes[i] : null);\r\n    }\r\n    if (this.panes.length > panes.length) {\r\n      let i = 0;\r\n      while (i < this.panes.length) {\r\n        let pane = this.panes[i];\r\n        if (panes.length - 1 < i || pane.path !== panes[i].path) {\r\n          if (this.selectedIndex === i)\r\n            this.selectedIndex = i - 1;\r\n          this.panes.splice(i, 1);\r\n          this._destroyPane(pane);\r\n        }\r\n        else\r\n          i++;\r\n      }\r\n    }\r\n    if (this.selectedIndex < 0)\r\n      this.select(0);\r\n    for (let i = 0; i < tabs.length; i++) {\r\n      let tab = tabs[i];\r\n      await this._navigateTab(i, tab.path, tab.queryString, state ? state.tabs[i] : null);\r\n    }\r\n    if (this.tabs.length > tabs.length) {\r\n      let i = 0;\r\n      while (i < this.tabs.length) {\r\n        let tab = this.tabs[i];\r\n        if (tabs.length - 1 < i || tab.path !== tabs[i].path) {\r\n          if (this.selectedTabIndex === i) {\r\n            this.selectedTabIndex = i - 1;\r\n          }\r\n          this.tabs.splice(i, 1);\r\n          this._destroyPane(tab);\r\n        }\r\n        else\r\n          i++;\r\n      }\r\n    }\r\n    if (this.tabs.length && this.selectedTabIndex < 0) {\r\n      this.selectedTabIndex = 0;\r\n    }\r\n    const n = this.panes.length;\r\n    for (let i = 0; i < n; i++) {\r\n      let pane = this.panes[i];\r\n      if (pane.expanded !== (n === 1)) {\r\n        const evt = new NavigationExpand(pane._expanded = n === 1, pane);\r\n        pane._events$.next(evt);\r\n      }\r\n    }\r\n  }\r\n  /**\r\n   * \r\n   * @param index\r\n   * @param path\r\n   * @param queryString\r\n   * @param state\r\n   */\r\n  private async _navigatePane(index: number, path: string, queryString: string, state?: any) {\r\n    const route = this._match(path);\r\n\r\n    if (!route) throw `no match ${path}`;\r\n\r\n    if (!state) state = {};\r\n\r\n    while (index < this.panes.length) {\r\n      let pane = this.panes[index];\r\n      if (path === pane.path) {\r\n        if (queryString === pane.queryString) {\r\n          return;\r\n        }\r\n        else {\r\n          const queryParams = this._parseQueryParams(queryString);\r\n          this._navQueryParams(pane, queryParams, state);\r\n          return;\r\n        }\r\n      }\r\n      else if (pane.route === route) {\r\n        const queryParams = this._parseQueryParams(queryString);\r\n        const params = this._params(pane.route as ExtendedRoute, path);\r\n        await this._navParams(path, pane, params, queryParams, state);\r\n        return;\r\n      }\r\n      index++;\r\n    }\r\n\r\n    const params = this._params(route, path);\r\n    const queryParams = this._parseQueryParams(queryString);\r\n    const parent = this._findAncestor(route, path);\r\n    await this._state(route, path, params, state);\r\n    this._insertPane(route.component, {\r\n      path, parent, route, data: state, params, queryParams,\r\n      icon: route.icon,\r\n      help: route.help,\r\n      policy: route.policy,\r\n      focus: false\r\n    });\r\n  }\r\n  private async _navigateTab(index: number, path: string, queryString: string, state?: any) {\r\n    const route = this._match(path);\r\n\r\n    if (!route) throw `no match ${path}`;\r\n\r\n    if (!state) state = {};\r\n\r\n    while (index < this.tabs.length) {\r\n      let tab = this.tabs[index];\r\n      if (path === tab.path) {\r\n        if (queryString === tab.queryString) {\r\n          return;\r\n        }\r\n        else {\r\n          const queryParams = this._parseQueryParams(queryString);\r\n          this._navQueryParams(tab, queryParams, state);\r\n          return;\r\n        }\r\n      }\r\n      else if (tab.route === route) {\r\n        const queryParams = this._parseQueryParams(queryString);\r\n        const params = this._params(tab.route as ExtendedRoute, path);\r\n        await this._navParams(path, tab, params, queryParams, state);\r\n        return;\r\n      }\r\n      index++;\r\n    }\r\n\r\n    const params = this._params(route, path);\r\n    const queryParams = this._parseQueryParams(queryString);\r\n\r\n    const parent = this._findAncestor(route, path);\r\n\r\n    await this._state(route, path, params, state);\r\n    this._insertTab(route.component, {\r\n      icon: route.icon,\r\n      help: route.help,\r\n      policy: route.policy | OpenPolicy.Tab,\r\n      path, parent, route,\r\n      data: state,\r\n      params, queryParams,\r\n      focus: false,\r\n      swap: false\r\n    });\r\n  }\r\n  private _findAncestor(route: ExtendedRoute, path: string) {\r\n    if ((route as ExtendedRoute).parent)\r\n      return this.panes.find(p => (p.route as ExtendedRoute) ===\r\n        (route as ExtendedRoute).parent &&\r\n        path.startsWith(p.path));\r\n  }\r\n  /**\r\n   * \r\n   * @param pane\r\n   * @param queryParams\r\n   */\r\n  private _navQueryParams(pane: PaneRef<any>, queryParams: ParamMap, state: ParamMap) {\r\n    pane._queryString = this._queryString(queryParams);\r\n    state && pane._data$.next(state);\r\n    pane._queryParams$.next(queryParams);\r\n    const evt = new QueryParamNavigation(queryParams, pane);\r\n    pane._events$.next(evt);\r\n    this._router._events$.next(evt);\r\n  }\r\n  /**\r\n   * \r\n   * @param path\r\n   * @param pane\r\n   * @param params\r\n   * @param queryParams\r\n   * @param state\r\n   */\r\n  private async _navParams(path: string, pane: PaneRef<any>, params: ParamMap, queryParams: ParamMap, state: ParamMap) {\r\n    if (pane.route.canDismiss)\r\n      await this._dismiss(pane);\r\n\r\n    if (!state) state = {};\r\n    await this._state(pane.route as ExtendedRoute, path, params, state);\r\n    pane._data$.next(state);\r\n    pane._path = path;\r\n    pane._params$.next(params);\r\n    if (queryParams) {\r\n      pane._queryString = this._queryString(queryParams);\r\n      pane._queryParams$.next(queryParams);\r\n    }\r\n    else {\r\n      pane._queryString = '';\r\n      pane._queryParams$.next({});\r\n    }\r\n    const evt = new ParamNavigation(params, pane);\r\n    pane._events$.next(evt);\r\n    this._router._events$.next(evt);\r\n\r\n    this.panes.concat(this.tabs).forEach(child => {\r\n      if (child.route && (child.route as ExtendedRoute).parent === pane.route) {\r\n        child._data$.next(Object.assign(child.data, state));\r\n        child._params$.next(params);\r\n        child._path = pane.path + '/' + child.route.path;\r\n        if (this.selectedTabIndex > -1 && child === this.tabs[this.selectedTabIndex]) {\r\n          this.selectedTabIndex = this.selectedTabIndex;\r\n          this.group = child.group;\r\n        }\r\n      }\r\n    });\r\n    if (pane.mode === 'pane') this.titleAnimation++;\r\n    this._cd.detectChanges();\r\n  }\r\n  /** */\r\n  private _syncBrowserHistory() {\r\n    let path = this.panes.filter(p => p.route).map(s => s.fullPath).join(PATH_CHAR);\r\n    if (this.tabs.length) {\r\n      const tabs = this.tabs.filter(p => p.route);\r\n      if (tabs.length)\r\n        path += PANE_CHAR + tabs.map(s => s.fullPath).join(PATH_CHAR);\r\n    }\r\n    const state = this._constructHistoryState();\r\n    this._navigationInProcess = true;\r\n    history.pushState(state, '', '/' + path);\r\n    setTimeout(() => this._navigationInProcess = false, 200);\r\n  }\r\n\r\n  private _constructHistoryState() {\r\n    return {\r\n      bizdoc: true,\r\n      step: history.state && history.state.bizdoc ? (history.state as HistoryState).step + 1 : 1,\r\n      selectedTabIndex: this.selectedTabIndex,\r\n      panes: this.panes.map(p => p.data),\r\n      tabs: this.tabs.map(t => t.data),\r\n      swap: this.swap,\r\n      group: this.group,\r\n      swapTab: this.swapTab,\r\n      prevGroup: this.prevGroup\r\n    } as HistoryState;\r\n  }\r\n\r\n  drop(evt: CdkDragDrop<string, string>) {\r\n    const pane = this.panes[evt.previousIndex];\r\n    this.panes.splice(evt.previousIndex, 1);\r\n    this.panes.splice(evt.currentIndex, 0, pane);\r\n    this._syncBrowserHistory();\r\n  }\r\n\r\n  togglePinned(pane: PaneRef<any>) {\r\n    pane.pinned = !pane.pinned;\r\n    this.panes.forEach(s => {\r\n      if (s.decendentOf(pane)) s.pinned = pane.pinned;\r\n    });\r\n  }\r\n\r\n  private _queryString(queryParams: ParamMap) {\r\n    const names = Object.keys(queryParams);\r\n    let queryString: string;\r\n    for (var i = 0; i < names.length; i++) {\r\n      let val = queryParams[names[i]];\r\n\r\n      if (val !== null && val !== undefined) {\r\n        if (!queryString) queryString = '';\r\n        else queryString = queryString + ARG_CHAR;\r\n\r\n        if (isString(val))\r\n          queryString += `${names[i]}=${encodeURIComponent(val)}`;\r\n        else if (isArray(val))\r\n          queryString += val.map(v => `${names[i]}=${v}`).join(ARG_CHAR);\r\n        else if (isDate(val))\r\n          queryString += `${names[i]}=${val.toJSON()}`;\r\n        else\r\n          queryString += `${names[i]}=${val}`;\r\n      }\r\n    }\r\n    return queryString;\r\n  }\r\n  private _parseQueryParams(queryString: string): ParamMap {\r\n    const queryParams = {};\r\n    queryString && queryString.\r\n      split(ARG_CHAR).forEach(p => {\r\n        const [name, value] = p.split('=');\r\n        if (!queryParams[name])\r\n          queryParams[name] = value;\r\n        else {\r\n          const vals = queryParams[name];\r\n          queryParams[name] = isArray(vals) ? [...vals, value] : [vals, value];\r\n        }\r\n      });\r\n    return queryParams;\r\n  }\r\n  /**\r\n   * \r\n   * @param route\r\n   * @param path\r\n   */\r\n  private _params(route: ExtendedRoute, path: string) {\r\n    const ex = route.regEx.exec(path),\r\n      params = ex.groups;\r\n\r\n    return params || {};\r\n  }\r\n  /**\r\n   * \r\n   * @param url\r\n   */\r\n  private _match(url: string) {\r\n    let route = this._repository.find(r => r.regEx.test(url));\r\n    if (route)\r\n      while (route.children) {\r\n        let child = route.children.find(r => r.regEx.test(url));\r\n        if (child)\r\n          route = child;\r\n        else break;\r\n      }\r\n    return route;\r\n  }\r\n  /**\r\n   * \r\n   * @param route\r\n   * @param path\r\n   * @param params\r\n   * @param data\r\n   */\r\n  private async _state(route: ExtendedRoute, path: string, params: ParamMap, data: ParamMap) {\r\n    if (this._pending.indexOf(path) > -1) {\r\n      //this._ps.toast('Working');\r\n      throw 'already processing';\r\n    }\r\n    this._pending.push(path);\r\n\r\n    const { parent, resolve } = route;\r\n    if (parent)\r\n      await this._parentstate(parent, path, params, data);\r\n    if (resolve) {\r\n      await this._resolve(resolve, params, data);\r\n    }\r\n    this._pending.remove(path);\r\n  }\r\n  /**\r\n   * \r\n   * @param route\r\n   * @param path\r\n   * @param params\r\n   * @param data\r\n   */\r\n  private async _parentstate(route: ExtendedRoute, path: string, params: ParamMap, data: ParamMap) {\r\n    const { parent, resolve } = route;\r\n\r\n    if (parent)\r\n      await this._parentstate(parent, path, params, data);\r\n\r\n    const pane = this.panes.find(s => s.route && s.route === route\r\n      && path.startsWith(s.path));\r\n\r\n    pane && Object.assign(data, pane.data);\r\n\r\n    if (resolve)\r\n      await this._resolve(resolve, params, data);\r\n  }\r\n\r\n  private async _resolve(resolve: { [key: string]: ComponentType<PaneResolve<any>> }, params: ParamMap, data: ParamMap) {\r\n    const keys = Object.keys(resolve);\r\n    for (let i = 0; i < keys.length; i++) {\r\n      let key = keys[i];\r\n      if (!data[key]) {\r\n        const instance = this._injector.get(resolve[key]) as PaneResolve<any>;\r\n        const value = instance.onResolve(params);\r\n        if (isPromise(value))\r\n          await value.then(r => data[key] = r);\r\n        else if (isObservable(value))\r\n          await value.pipe(tap(r => data[key] = r)).toPromise();\r\n        else\r\n          data[key] = value;\r\n      }\r\n    }\r\n  }\r\n\r\n  add<T>(component: ComponentType<T>, options?: PaneOptions) {\r\n    return this.insert(this.panes.length, component, options);\r\n  }\r\n  insert<T>(position: number, component: ComponentType<T>, options?: PaneOptions) {\r\n    const pane = this._insertPane<T>(component, options || {}, position);\r\n    return pane;\r\n  }\r\n  private _insertPane<T = any>(component: ComponentType<T>, options: {\r\n    path?: string;\r\n    route?: PaneRoute;\r\n    icon?: string;\r\n    title?: string;\r\n    inputs?: { [name: string]: any },\r\n    data?: ParamMap;\r\n    params?: ParamMap;\r\n    queryParams?: ParamMap;\r\n    help?: string;\r\n    parent?: PaneRef<any>;\r\n    queryString?: string;\r\n    policy?: OpenPolicy;\r\n    focus?: boolean\r\n  }, position?: number) {\r\n\r\n    const stretchable = (options.policy & OpenPolicy.Stretch) == OpenPolicy.Stretch;\r\n\r\n    const pane = this._constract<T>(component, {\r\n      mode: 'pane',\r\n      expanded: !this.panes.length,\r\n      stretchable,\r\n      ...options\r\n    });\r\n    if (position === undefined)\r\n      position = this.panes.length;\r\n    this.panes.push(pane);\r\n    this.titleAnimation++;\r\n    this._cd.detectChanges();\r\n    const evt = new NavigationStart(pane);\r\n    this._router._events$.next(evt);\r\n    if (options.focus !== false) {\r\n      this.selectedIndex = position;\r\n      this._title.set(pane.title);\r\n      if (this.panes.length > 1) this.scrollTo(position);\r\n    }\r\n    this.enableNavigationArrows();\r\n    return pane;\r\n  }\r\n  /**\r\n   * \r\n   * @param component\r\n   * @param options\r\n   */\r\n  private _constract<T = any>(component: ComponentType<T>,\r\n    options: {\r\n      mode: PaneMode,\r\n      expanded?: boolean;\r\n      dialog?: boolean;\r\n      stretchable?: boolean;\r\n      path?: string;\r\n      route?: PaneRoute;\r\n      icon?: string;\r\n      title?: string;\r\n      group?: string;\r\n      data?: ParamMap;\r\n      params?: ParamMap;\r\n      queryParams?: ParamMap;\r\n      help?: string;\r\n      parent?: PaneRef<any>;\r\n      queryString?: string;\r\n      dismissable?: boolean;\r\n      expandable?: boolean\r\n    }) {\r\n    const pane = new PaneRef<T>(component, this._injector, options);\r\n    pane._comm$.subscribe(e => this._paneCommand<T>(e, pane));\r\n    return pane;\r\n  }\r\n  /**\r\n   * \r\n   * @param component\r\n   * @param options\r\n   */\r\n  private _insertTab<T = any>(component: ComponentType<T>, options: {\r\n    icon?: string;\r\n    title?: string;\r\n    group?: string;\r\n    help?: string;\r\n    path?: string;\r\n    queryString?: string;\r\n    route?: PaneRoute;\r\n    data?: ParamMap;\r\n    params?: ParamMap;\r\n    queryParams?: ParamMap;\r\n    parent?: PaneRef<any>;\r\n    policy?: OpenPolicy;\r\n    swap?: boolean;\r\n    focus?: boolean;\r\n  }) {\r\n    const { policy } = options,\r\n      dialog = (policy & OpenPolicy.Dialog) == OpenPolicy.Dialog,\r\n      expandable = (policy & OpenPolicy.Expandable) == OpenPolicy.Expandable,\r\n      dismissable = (policy & OpenPolicy.Dismissable) == OpenPolicy.Dismissable;\r\n\r\n    const tab = this._constract<T>(component,\r\n      {\r\n        mode: 'tab',\r\n        expanded: false,\r\n        ...options,\r\n        dialog,\r\n        dismissable,\r\n        expandable\r\n      });\r\n    this.tabs.push(tab);\r\n    this._cd.detectChanges();\r\n    this._router._events$.next(new NavigationStart(tab));\r\n    if (tab.group && this.group !== tab.group && options.swap !== false) {\r\n      let i = 0, swap = false;\r\n      do {\r\n        if (this.tabs[i].group !== tab.group) {\r\n          this._destroyPane(this.tabs[i]);\r\n          this.tabs.splice(i, 1);\r\n          swap = true;\r\n        }\r\n        else\r\n          i++\r\n      } while (i < this.tabs.length);\r\n      if (swap) {\r\n        this.swapTab = this._getHistoryStep();\r\n        this.prevGroup = this.group;\r\n      }\r\n      this.group = tab.group;\r\n    }\r\n    else\r\n      this.swapTab = null;\r\n    if (options.focus !== false) {\r\n      this.selectedTabIndex = this.tabs.length - 1;\r\n    }\r\n    this._cd.detectChanges();\r\n    return tab;\r\n  }\r\n\r\n  guide(name: string) {\r\n    this._guide.start(name);\r\n  }\r\n  back() {\r\n    this._navBack(this.swap);\r\n    this.swap = null;\r\n  }\r\n  /**\r\n   * \r\n   * @param steps\r\n   */\r\n  private async _navBack(steps: number) {\r\n    history.go(steps - (history.state as HistoryState).step);\r\n  }\r\n  tabBack() {\r\n    this._navBack(this.swapTab);\r\n    this.swapTab = null;\r\n  }\r\n  /**\r\n   * \r\n   * @param command\r\n   * @param pane\r\n   */\r\n  private async _paneCommand<T = any>(command: PaneCommand, pane: PaneRef<T>) {\r\n    switch (command) {\r\n      case 'focus':\r\n        {\r\n          if (pane.mode === 'tab') {\r\n            this.selectedTabIndex = this.tabs.indexOf(pane);\r\n          }\r\n          else {\r\n            const index = this.panes.indexOf(pane);\r\n            this.focus(index);\r\n          }\r\n          break;\r\n        }\r\n      case 'close':\r\n        if (pane.mode === 'tab') {\r\n          const index = this.tabs.indexOf(pane);\r\n          this.closeTab(index);\r\n        }\r\n        else {\r\n          const index = this.panes.indexOf(pane);\r\n          await this.removeAt(index);\r\n          this._clearPending();\r\n          await this._clearTabs();\r\n          if (this.panes.length)\r\n            this._syncBrowserHistory();\r\n          else\r\n            this._router.navigate(DEFAULT_ROUTE);\r\n        }\r\n        break;\r\n      case 'expand':\r\n        if (pane.mode === 'tab')\r\n          this.expandTab();\r\n        else\r\n          this.expandPane();\r\n        break;\r\n      case 'recycle': {\r\n        const state = this._constructHistoryState();\r\n        history.replaceState(state, '');\r\n        break;\r\n      }\r\n    }\r\n  }\r\n  /**\r\n   * escape\r\n   * @param event\r\n   */\r\n  @HostListener('document:keydown.escape')\r\n  async collapse() {\r\n    if (!this.tabs.length) return;\r\n    const evt = new CollapseNavigation();\r\n    this._router._events$.next(evt);\r\n    if (evt._preventDefault) return;\r\n    this._clearPending();\r\n    await this._clearTabs();\r\n    this._syncBrowserHistory();\r\n  }\r\n  @HostListener('window:resize')\r\n  onResize() {\r\n    this._resizing.next();\r\n  }\r\n  /** */\r\n  private _resize() {\r\n    if (this.panes.length > 1 && !this.panes[this.panes.length - 1].stretchable) {\r\n      const el = this._panesContainerRef.element.nativeElement as HTMLDivElement,\r\n        child = el.lastElementChild as HTMLDivElement;\r\n      child.style.minWidth =\r\n        (el.parentElement.parentElement.clientWidth - el.parentElement.offsetLeft - child.offsetLeft - 2) + 'px';\r\n    }\r\n    this.tabs.concat(this.panes).forEach(p => p._events$.next(new NavigationResize({\r\n    } as any, p)));\r\n  }\r\n  closeTab(position: number) {\r\n    const tab = this.tabs[position];\r\n    if (!this._closing(tab)) return;\r\n    this.tabs.splice(position, 1);\r\n    this._destroyPane(tab);\r\n    this.selectedTabIndex = this.tabs.length ? position > 0 ? position - 1 : 0 : -1;\r\n    this._syncBrowserHistory();\r\n  }\r\n  /**\r\n   * \r\n   * @param pane\r\n   */\r\n  private _closing(pane: PaneRef<any>) {\r\n    let evt = new NavigationClose(pane);\r\n    pane._events$.next(evt);\r\n    return !evt._preventDefault;\r\n  }\r\n\r\n  expandPane() {\r\n    const pane = this.panes[this.selectedIndex];\r\n    const evt = new NavigationExpand(pane._expanded = true, pane);\r\n    pane._events$.next(evt);\r\n    this._router._events$.next(evt);\r\n    if (evt._preventDefault) return;\r\n    this.swap = this._getHistoryStep();\r\n    let i = 0;\r\n    do {\r\n      if (this.panes[i] !== pane) {\r\n        this._destroyPane(this.panes[i]);\r\n        this.panes.splice(i, 1);\r\n      }\r\n      else\r\n        i++;\r\n    }\r\n    while (i < this.panes.length);\r\n    this.selectedIndex = 0;\r\n    this._syncBrowserHistory();\r\n  }\r\n  private _getHistoryStep(): number {\r\n    return history.state && history.state.bizdoc ? (history.state as HistoryState).step : 0;\r\n  }\r\n\r\n  expandTab() {\r\n    const tab = this.tabs[this.selectedTabIndex];\r\n    const evt = new NavigationExpand(tab._expanded = true, tab)\r\n    tab._events$.next(evt);\r\n    this._router._events$.next(evt);\r\n    if (evt._preventDefault) return;\r\n    this.swap = this._getHistoryStep();\r\n    this.swapTab = null;\r\n    this.panes.forEach(p =>\r\n      this._destroyPane(p)\r\n    );\r\n    this.tabs.splice(this.selectedTabIndex, 1);\r\n    this.panes.splice(0, this.panes.length, tab);\r\n\r\n    tab._mode = 'pane';\r\n    this.selectedTabIndex = this.tabs.length ? 0 : -1;\r\n    this._syncBrowserHistory();\r\n  }\r\n\r\n  select(position: number) {\r\n    if (this.selectedIndex === position) return;\r\n    if (position === -1) {\r\n      if (this.panes.length) position = this.panes.length - 1;\r\n      else return;\r\n    }\r\n    this.selectedIndex = position;\r\n    const pane = this.panes[position];\r\n    const evt = new NavigationFocus(pane);\r\n    pane._events$.next(evt);\r\n    this._router._events$.next(evt);\r\n    this._title.set(pane.title);\r\n  }\r\n  async removeAt(position: number) {\r\n    const pane = this.panes[position];\r\n\r\n    if (!this._closing(pane)) return;\r\n\r\n    await this._dismiss(pane);\r\n\r\n    this._discardPane(pane);\r\n\r\n    if (position >= this.selectedIndex)\r\n      this.select(-1);\r\n    this._syncBrowserHistory();\r\n  }\r\n  /**\r\n   * \r\n   * @param pane\r\n   */\r\n  private async _dismiss(pane: PaneRef<any>) {\r\n    const panes = this.panes.concat(this.tabs).\r\n      filter(s => s.decendentOf(pane) && s.route && s.route.canDismiss).\r\n      reverse();\r\n\r\n    pane.route && pane.route.canDismiss &&\r\n      panes.push(pane);\r\n\r\n    for (let i = 0; i < panes.length; i++) {\r\n      let ok = await this._dismissable(panes[i]);\r\n      if (!ok) throw '';\r\n    }\r\n  }\r\n  /**\r\n   * \r\n   * @param pane\r\n   */\r\n  private _discardPane(pane: PaneRef<any>) {\r\n    this.panes.concat(this.tabs).\r\n      filter(s => s.decendentOf(pane)).\r\n      reverse().\r\n      forEach(s => this._discardPane(s));\r\n    this._destroyPane(pane);\r\n    const index = this.panes.indexOf(pane);\r\n    this.panes.splice(index, 1);\r\n  }\r\n  private _clearPending() {\r\n    this._pending.splice(0, this._pending.length);\r\n  }\r\n  /** */\r\n  private async _clearPanes() {\r\n    await this._dismissAll(this.panes);\r\n    this.panes.forEach(p => this._destroyPane(p));\r\n    this.panes.splice(0, this.panes.length);\r\n    this.selectedIndex = -1;\r\n    this.swap = null;\r\n  }\r\n  private async _clearTabs() {\r\n    if (!this.tabs.length) return;\r\n    await this._dismissAll(this.tabs);\r\n    this.tabs.forEach(t => this._destroyPane(t));\r\n    this.tabs.splice(0, this.tabs.length);\r\n    this.selectedTabIndex = -1;\r\n    this.swapTab = null;\r\n  }\r\n  /**\r\n   * \r\n   * @param panes\r\n   */\r\n  private async _dismissAll(panes: PaneRef[]) {\r\n    for (let pane of panes.\r\n      filter(s => s.route && s.route.canDismiss)) {\r\n      let ok = await this._dismissable(pane);\r\n      if (!ok)\r\n        throw '';\r\n    }\r\n  }\r\n\r\n  /**\r\n   * \r\n   * @param pane\r\n   */\r\n  private _dismissable(pane: PaneRef<any>) {\r\n    const { instance, route: { canDismiss } } = pane;\r\n    const dismissable = this._injector.get(canDismiss) as CanDismiss<any>;\r\n    const ok = dismissable.onDismiss(instance);\r\n    if (isBoolean(ok))\r\n      return Promise.resolve(ok);\r\n    else if (isPromise(ok))\r\n      return ok;\r\n    else\r\n      return ok.toPromise();\r\n  }\r\n  scrollTo(index: number) {\r\n    const item = this._children.item(index) as HTMLDivElement;\r\n    item && item.scrollIntoView({ behavior: 'smooth', inline: 'end', block: 'end' });\r\n  }\r\n\r\n  private get _children() {\r\n    return this._panesContainerRef.element.nativeElement.querySelectorAll('.pane-content');\r\n  }\r\n  done() {\r\n    this.enableNavigationArrows();\r\n    this._resize();\r\n  }\r\n  enableNavigationArrows(_?: Event) {\r\n    const container = this._panesContainerRef.element.nativeElement,\r\n      scrollLeft = Math.round(container.scrollLeft);\r\n    this.next = this._rtl ? container.clientWidth - scrollLeft < container.scrollWidth :\r\n      scrollLeft + container.clientWidth < container.scrollWidth;\r\n    this.prev = this._rtl ? scrollLeft < 0 : scrollLeft > 0;\r\n  }\r\n  scrollBy(n: number) {\r\n    const left = n * (this._rtl ? -1 : 1);\r\n    this._panesContainerRef.element.nativeElement.scrollBy({ behavior: 'smooth', left });\r\n  }\r\n  focus(index) {\r\n    const el = this._children.item(index) as HTMLDivElement;\r\n    el.focus();\r\n  }\r\n  onPaneResize(pane: PaneRef<any>, event: MouseEvent) {\r\n    const el = (event.srcElement as HTMLDivElement).previousElementSibling as HTMLDivElement;\r\n\r\n    const // remember mouse down info\r\n      width = el.clientWidth,\r\n      d = this._rtl ? -1 : 1;\r\n\r\n    (event.srcElement as HTMLDivElement).classList.add('resizing');\r\n\r\n    this.dragging = true;\r\n\r\n    document.onmousemove = onMouseMove;\r\n    document.onmouseup = () => {\r\n      (event.srcElement as HTMLDivElement).classList.remove('resizing');\r\n      document.onmousemove = document.onmouseup = null;\r\n      this.dragging = false;\r\n    };\r\n    function onMouseMove(e) {\r\n\r\n      const delta = (e.clientX - event.clientX) * d;\r\n      el.style.width = el.style.minWidth\r\n        = Math.max(width + delta, 350) + 'px';\r\n      pane._events$.next(new NavigationResize({} as any, pane));\r\n    }\r\n  }\r\n  onTabResize(event: MouseEvent) {\r\n    const el = (event.srcElement as HTMLDivElement).nextElementSibling as HTMLDivElement;\r\n\r\n    const\r\n      me = this,\r\n      // remember mouse down info\r\n      width = el.clientWidth,\r\n      d = this._rtl ? 1 : -1;\r\n\r\n    (event.srcElement as HTMLDivElement).classList.add('resizing');\r\n\r\n    this.dragging = true;\r\n\r\n    document.onmousemove = onMouseMove;\r\n    document.onmouseup = () => {\r\n      (event.srcElement as HTMLDivElement).classList.remove('resizing');\r\n      document.onmousemove = document.onmouseup = null;\r\n      this.dragging = false;\r\n      me.enableNavigationArrows();\r\n      this._resize();\r\n    };\r\n    function onMouseMove(e) {\r\n\r\n      // prevent negative-sized elements\r\n      const delta = Math.max((e.clientX - event.clientX) * d, -width);\r\n      el.style.width = el.style.minWidth = (width + delta) + 'px';\r\n      localStorage.setItem('tabs', el.style.width);\r\n    }\r\n  }\r\n  private _destroyPane(pane: PaneRef) {\r\n    pane._destroy();\r\n    const evt = new NavigationEnd(pane);\r\n    pane._events$.next(evt);\r\n    this._router._events$.next(evt);\r\n  }\r\n  ngOnDestroy(): void {\r\n    this._destroy.next();\r\n    this._destroy.complete();\r\n  }\r\n}\r\n\r\nconst PANE_PARAMS_REGEX = /(:[\\w\\-]+)/g;\r\n\r\nfunction prepareRoutes(routes: PaneRoute[], treePath?: string): ExtendedRoute[] {\r\n  for (let i = 0; i < routes.length; i++) {\r\n    let route = routes[i], fullPath = (treePath ? (treePath + '/') : '') + route.path;\r\n\r\n    Object.assign(route, {\r\n      fullPath,\r\n      regEx: new RegExp('^' + fullPath.\r\n        replace('/', '\\\\/').\r\n        replace(PANE_PARAMS_REGEX, e => `(?<${e.substr(1)}>[\\\\w@\\\\-]*)`))\r\n    });\r\n    if (route.children) {\r\n      let children = prepareRoutes(route.children, fullPath);\r\n      for (var j = 0; j < children.length; j++)\r\n        Object.assign(children[j], {\r\n          parent: route\r\n        });\r\n    }\r\n  }\r\n  return routes as ExtendedRoute[];\r\n}\r\n\r\ninterface ExtendedRoute extends PaneRoute {\r\n  fullPath: string;\r\n  regEx: RegExp;\r\n  parent?: ExtendedRoute;\r\n  children?: ExtendedRoute[];\r\n}\r\ninterface HistoryState {\r\n  bizdoc: true;\r\n  step: number;\r\n  swap?: number;\r\n  swapTab?: number;\r\n  group?: string;\r\n  prevGroup?: string;\r\n  panes: any[];\r\n  tabs: any[];\r\n  selectedTabIndex?: number;\r\n}\r\n","<div class=\"panes\">\r\n  <div class=\"scroll-arrow\" (click)=\"scrollBy(-400)\" matRipple [matRippleUnbounded]=\"true\" [matRippleCentered]=\"true\" [matRippleColor]=\"accent\"\r\n       *ngIf=\"prev\">\r\n    <i class=\"material-icons mat-icon-rtl-mirror\">\r\n      arrow_back_ios\r\n    </i>\r\n  </div>\r\n  <div class=\"panes-title\" [@title]=\"titleAnimation\">\r\n    <h1>\r\n      <button mat-icon-button (click)=\"back()\" *ngIf=\"swap\" [bizdocTooltip]=\"'Back'|translate\"><mat-icon class=\"mat-icon-rtl-mirror\">arrow_circle_left</mat-icon></button>\r\n      <ng-container *ngFor=\"let p of panes; let first = first\">\r\n        <span class=\"breadcrumbs\" *ngIf=\"!first\">\\</span>\r\n        {{p.title}}\r\n      </ng-container>\r\n      <button mat-icon-button (click)=\"guide(panes[0].guide)\" *ngIf=\"panes[0]?.guide\" [bizdocTooltip]=\"'Help'|translate\"><mat-icon>help</mat-icon></button>\r\n    </h1>\r\n    <span class=\"divider\">\r\n    </span>\r\n    <bizdoc-quicktools></bizdoc-quicktools>\r\n  </div>\r\n  <div #panning class=\"panes-container\"\r\n       cdkScrollable\r\n       @panes\r\n       (scroll)=\"enableNavigationArrows($event)\">\r\n    <ng-container *ngFor=\"let p of panes; let i = index\">\r\n      <div (mouseenter)=\"selectedIndex !== i && !dragging && select(i)\"\r\n           (click)=\"select(i)\"\r\n           [class.active]=\"selectedIndex === i\" class=\"pane-content\" @pane>\r\n        <ngx-component-outlet [type]=\"p.component\" [injector]=\"p.injector\" (create)=\"p._instance = $event\"></ngx-component-outlet>\r\n      </div>\r\n      <div class=\"pane-separator\" *ngIf=\"i < panes.length - 1\" (mousedown)=\"onPaneResize(p, $event)\">&nbsp;</div>\r\n    </ng-container>\r\n  </div>\r\n  <div class=\"backdrop\" *ngIf=\"dialog\" (click)=\"closeTab(selectedTabIndex)\"></div>\r\n  <div class=\"scroll-arrow forward\"\r\n       *ngIf=\"next\">\r\n    <i class=\"material-icons mat-icon-rtl-mirror\" matRipple [matRippleUnbounded]=\"true\" [matRippleCentered]=\"true\" [matRippleRadius]=\"30\" [matRippleColor]=\"accent\"\r\n       (click)=\"scrollBy(400)\">\r\n      arrow_forward_ios\r\n    </i>\r\n  </div>\r\n</div>\r\n<ng-container *ngIf=\"tabs.length\">\r\n  <div class=\"tabs-separator\" (mousedown)=\"onTabResize($event)\">&nbsp;</div>\r\n  <div class=\"mat-elevation-z18 tabs\" [@tabs]=\"tabsAnimation\" (@tabs.done)=\"done()\" #tabing>\r\n    <div class=\"row tabs-title\">\r\n      <button mat-icon-button (click)=\"tabBack()\" *ngIf=\"swapTab\" [bizdocTooltip]=\"prevGroup || ('Back'|translate)\"><mat-icon class=\"mat-icon-rtl-mirror\">arrow_back</mat-icon></button>\r\n      <h2>{{group}}</h2>\r\n      <button mat-icon-button (click)=\"expandTab()\" [bizdocTooltip]=\"'Expand'| translate\"><mat-icon inline=\"true\" class=\"mat-icon-rtl-mirror\">open_in_full</mat-icon></button>\r\n      <!--*ngIf=\"selectedTabIndex <=< -1 && tabs[selectedTabIndex].expandable\"-->\r\n      <span class=\"divider\"></span>\r\n      <button mat-icon-button (click)=\"collapse()\" bizdocTooltip=\"Esc\"><mat-icon>close</mat-icon></button>\r\n    </div>\r\n    <nav mat-tab-nav-bar color=\"accent\" [disablePagination]=\"true\">\r\n      <a mat-tab-link *ngFor=\"let t of tabs; let i = index\" class=\"mat-tab-link\"\r\n         (click)=\"selectedTabIndex = i\"\r\n         [active]=\"selectedTabIndex === i\">\r\n        <mat-icon [matBadge]=\"t.badge\" [matBadgeHidden]=\"!t.badge\" matBadgeSize=\"small\" matBadgeColor=\"accent\">{{t.icon}}</mat-icon>&nbsp;\r\n        {{t.title}}\r\n        <mat-icon *ngIf=\"t.dismissable\" (click)=\"closeTab(i)\" class=\"tool\">close</mat-icon>\r\n        <!--inline=\"true\"-->\r\n      </a>\r\n    </nav>\r\n    <div *ngFor=\"let t of tabs; let i = index\" [style.display]=\"selectedTabIndex === i ? '': 'none'\" class=\"tab\" [@tab]=\"selectedTabIndex\">\r\n      <ngx-component-outlet [type]=\"t.component\" [injector]=\"t.injector\" (create)=\"t._instance = $event\"></ngx-component-outlet>\r\n    </div>\r\n  </div>\r\n</ng-container>\r\n"]}