@alfresco/aca-content 4.0.0-A.2-9984

package/esm2020/lib/components/sidenav/directives/active-link.directive.mjs

@@ -0,0 +1,93 @@
+/*!
+ * @license
+ * Alfresco Example Content Application
+ *
+ * Copyright (C) 2005 - 2020 Alfresco Software Limited
+ *
+ * This file is part of the Alfresco Example Content Application.
+ * If the software was purchased under a paid Alfresco license, the terms of
+ * the paid license agreement will prevail.  Otherwise, the software is
+ * provided under the following open source license terms:
+ *
+ * The Alfresco Example Content Application is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * The Alfresco Example Content Application is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with Alfresco. If not, see <http://www.gnu.org/licenses/>.
+ */
+import { Directive, Input, ElementRef, Renderer2, ContentChildren, QueryList, Optional } from '@angular/core';
+import { Router, NavigationEnd } from '@angular/router';
+import { filter, takeUntil } from 'rxjs/operators';
+import { Subject } from 'rxjs';
+import { ActionDirective } from './action.directive';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/router";
+import * as i2 from "./action.directive";
+export class ActiveLinkDirective {
+    constructor(router, element, renderer, action) {
+        this.router = router;
+        this.element = element;
+        this.renderer = renderer;
+        this.action = action;
+        this.isLinkActive = false;
+        this.onDestroy$ = new Subject();
+    }
+    ngOnInit() {
+        this.router.events
+            .pipe(filter((event) => event instanceof NavigationEnd), takeUntil(this.onDestroy$))
+            .subscribe((event) => {
+            this.update(event.urlAfterRedirects);
+        });
+    }
+    update(url) {
+        if (this.action) {
+            const itemUrl = this.resolveUrl(this.action);
+            this.render(url, itemUrl);
+        }
+        this.links.map((item) => {
+            const itemUrl = this.resolveUrl(item);
+            this.render(url, itemUrl);
+        });
+    }
+    render(routerUrl, actionUrl) {
+        if (routerUrl && routerUrl.substring(1).startsWith(actionUrl)) {
+            this.isLinkActive = true;
+            this.renderer.addClass(this.element.nativeElement, this.acaActiveLink);
+        }
+        else {
+            this.isLinkActive = false;
+            this.renderer.removeClass(this.element.nativeElement, this.acaActiveLink);
+        }
+    }
+    ngAfterContentInit() {
+        this.links.changes.subscribe(() => this.update(this.router.url));
+        this.update(this.router.url);
+    }
+    resolveUrl(item) {
+        return (item.action && item.action.click && item.action.click.payload) || item.action.route;
+    }
+}
+ActiveLinkDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.1.2", ngImport: i0, type: ActiveLinkDirective, deps: [{ token: i1.Router }, { token: i0.ElementRef }, { token: i0.Renderer2 }, { token: i2.ActionDirective, optional: true }], target: i0.ɵɵFactoryTarget.Directive });
+ActiveLinkDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "14.1.2", type: ActiveLinkDirective, selector: "[acaActiveLink]", inputs: { acaActiveLink: "acaActiveLink" }, queries: [{ propertyName: "links", predicate: ActionDirective, descendants: true }], exportAs: ["acaActiveLink"], ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.1.2", ngImport: i0, type: ActiveLinkDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[acaActiveLink]',
+                    exportAs: 'acaActiveLink'
+                }]
+        }], ctorParameters: function () { return [{ type: i1.Router }, { type: i0.ElementRef }, { type: i0.Renderer2 }, { type: i2.ActionDirective, decorators: [{
+                    type: Optional
+                }] }]; }, propDecorators: { acaActiveLink: [{
+                type: Input
+            }], links: [{
+                type: ContentChildren,
+                args: [ActionDirective, { descendants: true }]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/components/sidenav/directives/expansion-panel.directive.mjs

@@ -0,0 +1,102 @@
+/*!
+ * @license
+ * Alfresco Example Content Application
+ *
+ * Copyright (C) 2005 - 2020 Alfresco Software Limited
+ *
+ * This file is part of the Alfresco Example Content Application.
+ * If the software was purchased under a paid Alfresco license, the terms of
+ * the paid license agreement will prevail.  Otherwise, the software is
+ * provided under the following open source license terms:
+ *
+ * The Alfresco Example Content Application is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * The Alfresco Example Content Application is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with Alfresco. If not, see <http://www.gnu.org/licenses/>.
+ */
+import { Directive, Input, HostListener } from '@angular/core';
+import { Router, NavigationEnd, PRIMARY_OUTLET } from '@angular/router';
+import { filter, takeUntil } from 'rxjs/operators';
+import { Subject } from 'rxjs';
+import { MatExpansionPanel } from '@angular/material/expansion';
+import { Store } from '@ngrx/store';
+import * as i0 from "@angular/core";
+import * as i1 from "@ngrx/store";
+import * as i2 from "@angular/router";
+import * as i3 from "@angular/material/expansion";
+export class ExpansionPanelDirective {
+    constructor(store, router, expansionPanel) {
+        this.store = store;
+        this.router = router;
+        this.expansionPanel = expansionPanel;
+        this.hasActiveChildren = false;
+        this.onDestroy$ = new Subject();
+    }
+    onClick() {
+        if (this.expansionPanel.expanded && !this.hasActiveLinks()) {
+            const firstChild = this.acaExpansionPanel.children[0];
+            if (firstChild.url) {
+                this.router.navigate(this.getNavigationCommands(firstChild.url));
+            }
+            else {
+                this.store.dispatch({
+                    type: firstChild.action.action,
+                    payload: this.getNavigationCommands(firstChild.action.payload)
+                });
+            }
+        }
+    }
+    hasActiveLinks() {
+        if (this.acaExpansionPanel && this.acaExpansionPanel.children) {
+            return this.acaExpansionPanel.children.some((child) => this.router.url.startsWith(child.url || child.action.payload));
+        }
+        return false;
+    }
+    ngOnInit() {
+        this.hasActiveChildren = this.hasActiveLinks();
+        this.router.events
+            .pipe(filter((event) => event instanceof NavigationEnd), takeUntil(this.onDestroy$))
+            .subscribe(() => {
+            this.hasActiveChildren = this.hasActiveLinks();
+        });
+    }
+    ngOnDestroy() {
+        this.onDestroy$.next(true);
+        this.onDestroy$.complete();
+    }
+    getNavigationCommands(url) {
+        const urlTree = this.router.parseUrl(url);
+        const urlSegmentGroup = urlTree.root.children[PRIMARY_OUTLET];
+        if (!urlSegmentGroup) {
+            return [url];
+        }
+        const urlSegments = urlSegmentGroup.segments;
+        return urlSegments.reduce(function (acc, item) {
+            acc.push(item.path, item.parameters);
+            return acc;
+        }, []);
+    }
+}
+ExpansionPanelDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.1.2", ngImport: i0, type: ExpansionPanelDirective, deps: [{ token: i1.Store }, { token: i2.Router }, { token: i3.MatExpansionPanel }], target: i0.ɵɵFactoryTarget.Directive });
+ExpansionPanelDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "14.1.2", type: ExpansionPanelDirective, selector: "[acaExpansionPanel]", inputs: { acaExpansionPanel: "acaExpansionPanel" }, host: { listeners: { "click": "onClick()" } }, exportAs: ["acaExpansionPanel"], ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.1.2", ngImport: i0, type: ExpansionPanelDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[acaExpansionPanel]',
+                    exportAs: 'acaExpansionPanel'
+                }]
+        }], ctorParameters: function () { return [{ type: i1.Store }, { type: i2.Router }, { type: i3.MatExpansionPanel }]; }, propDecorators: { acaExpansionPanel: [{
+                type: Input
+            }], onClick: [{
+                type: HostListener,
+                args: ['click']
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"expansion-panel.directive.js","sourceRoot":"","sources":["../../../../../../../../projects/aca-content/src/lib/components/sidenav/directives/expansion-panel.directive.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAEH,OAAO,EAAE,SAAS,EAAE,KAAK,EAAE,YAAY,EAAqB,MAAM,eAAe,CAAC;AAClF,OAAO,EAAE,MAAM,EAAE,aAAa,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAC;AACxE,OAAO,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AACnD,OAAO,EAAE,OAAO,EAAE,MAAM,MAAM,CAAC;AAC/B,OAAO,EAAE,iBAAiB,EAAE,MAAM,6BAA6B,CAAC;AAChE,OAAO,EAAE,KAAK,EAAE,MAAM,aAAa,CAAC;;;;;AAMpC,MAAM,OAAO,uBAAuB;IAqBlC,YAAoB,KAAiB,EAAU,MAAc,EAAU,cAAiC;QAApF,UAAK,GAAL,KAAK,CAAY;QAAU,WAAM,GAAN,MAAM,CAAQ;QAAU,mBAAc,GAAd,cAAc,CAAmB;QAnBjG,sBAAiB,GAAG,KAAK,CAAC;QAEzB,eAAU,GAAqB,IAAI,OAAO,EAAW,CAAC;IAiB6C,CAAC;IAd5G,OAAO;QACL,IAAI,IAAI,CAAC,cAAc,CAAC,QAAQ,IAAI,CAAC,IAAI,CAAC,cAAc,EAAE,EAAE;YAC1D,MAAM,UAAU,GAAG,IAAI,CAAC,iBAAiB,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC;YACtD,IAAI,UAAU,CAAC,GAAG,EAAE;gBAClB,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,IAAI,CAAC,qBAAqB,CAAC,UAAU,CAAC,GAAG,CAAC,CAAC,CAAC;aAClE;iBAAM;gBACL,IAAI,CAAC,KAAK,CAAC,QAAQ,CAAC;oBAClB,IAAI,EAAE,UAAU,CAAC,MAAM,CAAC,MAAM;oBAC9B,OAAO,EAAE,IAAI,CAAC,qBAAqB,CAAC,UAAU,CAAC,MAAM,CAAC,OAAO,CAAC;iBAC/D,CAAC,CAAC;aACJ;SACF;IACH,CAAC;IAID,cAAc;QACZ,IAAI,IAAI,CAAC,iBAAiB,IAAI,IAAI,CAAC,iBAAiB,CAAC,QAAQ,EAAE;YAC7D,OAAO,IAAI,CAAC,iBAAiB,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,UAAU,CAAC,KAAK,CAAC,GAAG,IAAI,KAAK,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC,CAAC;SACvH;QACD,OAAO,KAAK,CAAC;IACf,CAAC;IAED,QAAQ;QACN,IAAI,CAAC,iBAAiB,GAAG,IAAI,CAAC,cAAc,EAAE,CAAC;QAE/C,IAAI,CAAC,MAAM,CAAC,MAAM;aACf,IAAI,CACH,MAAM,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,KAAK,YAAY,aAAa,CAAC,EACjD,SAAS,CAAC,IAAI,CAAC,UAAU,CAAC,CAC3B;aACA,SAAS,CAAC,GAAG,EAAE;YACd,IAAI,CAAC,iBAAiB,GAAG,IAAI,CAAC,cAAc,EAAE,CAAC;QACjD,CAAC,CAAC,CAAC;IACP,CAAC;IAED,WAAW;QACT,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QAC3B,IAAI,CAAC,UAAU,CAAC,QAAQ,EAAE,CAAC;IAC7B,CAAC;IAEO,qBAAqB,CAAC,GAAW;QACvC,MAAM,OAAO,GAAG,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC;QAC1C,MAAM,eAAe,GAAG,OAAO,CAAC,IAAI,CAAC,QAAQ,CAAC,cAAc,CAAC,CAAC;QAE9D,IAAI,CAAC,eAAe,EAAE;YACpB,OAAO,CAAC,GAAG,CAAC,CAAC;SACd;QAED,MAAM,WAAW,GAAG,eAAe,CAAC,QAAQ,CAAC;QAE7C,OAAO,WAAW,CAAC,MAAM,CAAC,UAAU,GAAG,EAAE,IAAI;YAC3C,GAAG,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,EAAE,IAAI,CAAC,UAAU,CAAC,CAAC;YACrC,OAAO,GAAG,CAAC;QACb,CAAC,EAAE,EAAE,CAAC,CAAC;IACT,CAAC;;oHA9DU,uBAAuB;wGAAvB,uBAAuB;2FAAvB,uBAAuB;kBAJnC,SAAS;mBAAC;oBACT,QAAQ,EAAE,qBAAqB;oBAC/B,QAAQ,EAAE,mBAAmB;iBAC9B;iJAEU,iBAAiB;sBAAzB,KAAK;gBAMN,OAAO;sBADN,YAAY;uBAAC,OAAO","sourcesContent":["/*!\n * @license\n * Alfresco Example Content Application\n *\n * Copyright (C) 2005 - 2020 Alfresco Software Limited\n *\n * This file is part of the Alfresco Example Content Application.\n * If the software was purchased under a paid Alfresco license, the terms of\n * the paid license agreement will prevail.  Otherwise, the software is\n * provided under the following open source license terms:\n *\n * The Alfresco Example Content Application is free software: you can redistribute it and/or modify\n * it under the terms of the GNU Lesser General Public License as published by\n * the Free Software Foundation, either version 3 of the License, or\n * (at your option) any later version.\n *\n * The Alfresco Example Content Application is distributed in the hope that it will be useful,\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n * GNU Lesser General Public License for more details.\n *\n * You should have received a copy of the GNU Lesser General Public License\n * along with Alfresco. If not, see <http://www.gnu.org/licenses/>.\n */\n\nimport { Directive, Input, HostListener, OnInit, OnDestroy } from '@angular/core';\nimport { Router, NavigationEnd, PRIMARY_OUTLET } from '@angular/router';\nimport { filter, takeUntil } from 'rxjs/operators';\nimport { Subject } from 'rxjs';\nimport { MatExpansionPanel } from '@angular/material/expansion';\nimport { Store } from '@ngrx/store';\n\n@Directive({\n  selector: '[acaExpansionPanel]',\n  exportAs: 'acaExpansionPanel'\n})\nexport class ExpansionPanelDirective implements OnInit, OnDestroy {\n  @Input() acaExpansionPanel;\n  public hasActiveChildren = false;\n\n  private onDestroy$: Subject<boolean> = new Subject<boolean>();\n\n  @HostListener('click')\n  onClick() {\n    if (this.expansionPanel.expanded && !this.hasActiveLinks()) {\n      const firstChild = this.acaExpansionPanel.children[0];\n      if (firstChild.url) {\n        this.router.navigate(this.getNavigationCommands(firstChild.url));\n      } else {\n        this.store.dispatch({\n          type: firstChild.action.action,\n          payload: this.getNavigationCommands(firstChild.action.payload)\n        });\n      }\n    }\n  }\n\n  constructor(private store: Store<any>, private router: Router, private expansionPanel: MatExpansionPanel) {}\n\n  hasActiveLinks() {\n    if (this.acaExpansionPanel && this.acaExpansionPanel.children) {\n      return this.acaExpansionPanel.children.some((child) => this.router.url.startsWith(child.url || child.action.payload));\n    }\n    return false;\n  }\n\n  ngOnInit() {\n    this.hasActiveChildren = this.hasActiveLinks();\n\n    this.router.events\n      .pipe(\n        filter((event) => event instanceof NavigationEnd),\n        takeUntil(this.onDestroy$)\n      )\n      .subscribe(() => {\n        this.hasActiveChildren = this.hasActiveLinks();\n      });\n  }\n\n  ngOnDestroy() {\n    this.onDestroy$.next(true);\n    this.onDestroy$.complete();\n  }\n\n  private getNavigationCommands(url: string): any[] {\n    const urlTree = this.router.parseUrl(url);\n    const urlSegmentGroup = urlTree.root.children[PRIMARY_OUTLET];\n\n    if (!urlSegmentGroup) {\n      return [url];\n    }\n\n    const urlSegments = urlSegmentGroup.segments;\n\n    return urlSegments.reduce(function (acc, item) {\n      acc.push(item.path, item.parameters);\n      return acc;\n    }, []);\n  }\n}\n"]}

package/esm2020/lib/components/sidenav/directives/menu-panel.directive.mjs

@@ -0,0 +1,99 @@
+/*!
+ * @license
+ * Alfresco Example Content Application
+ *
+ * Copyright (C) 2005 - 2020 Alfresco Software Limited
+ *
+ * This file is part of the Alfresco Example Content Application.
+ * If the software was purchased under a paid Alfresco license, the terms of
+ * the paid license agreement will prevail.  Otherwise, the software is
+ * provided under the following open source license terms:
+ *
+ * The Alfresco Example Content Application is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * The Alfresco Example Content Application is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with Alfresco. If not, see <http://www.gnu.org/licenses/>.
+ */
+import { Directive, Input, HostListener } from '@angular/core';
+import { Router, NavigationEnd, PRIMARY_OUTLET } from '@angular/router';
+import { filter, takeUntil } from 'rxjs/operators';
+import { Subject } from 'rxjs';
+import { Store } from '@ngrx/store';
+import * as i0 from "@angular/core";
+import * as i1 from "@ngrx/store";
+import * as i2 from "@angular/router";
+export class MenuPanelDirective {
+    constructor(store, router) {
+        this.store = store;
+        this.router = router;
+        this.hasActiveChildren = false;
+        this.onDestroy$ = new Subject();
+    }
+    menuOpened() {
+        if (this.acaMenuPanel.children && !this.hasActiveLinks()) {
+            const firstChild = this.acaMenuPanel.children[0];
+            if (firstChild.url) {
+                this.router.navigate(this.getNavigationCommands(firstChild.url));
+            }
+            else {
+                this.store.dispatch({
+                    type: firstChild.action.action,
+                    payload: this.getNavigationCommands(firstChild.action.payload)
+                });
+            }
+        }
+    }
+    hasActiveLinks() {
+        if (this.acaMenuPanel && this.acaMenuPanel.children) {
+            return this.acaMenuPanel.children.some((child) => this.router.url.startsWith(child.url || child.action.payload));
+        }
+        return false;
+    }
+    ngOnInit() {
+        this.hasActiveChildren = this.hasActiveLinks();
+        this.router.events
+            .pipe(filter((event) => event instanceof NavigationEnd), takeUntil(this.onDestroy$))
+            .subscribe(() => {
+            this.hasActiveChildren = this.hasActiveLinks();
+        });
+    }
+    ngOnDestroy() {
+        this.onDestroy$.next(true);
+        this.onDestroy$.complete();
+    }
+    getNavigationCommands(url) {
+        const urlTree = this.router.parseUrl(url);
+        const urlSegmentGroup = urlTree.root.children[PRIMARY_OUTLET];
+        if (!urlSegmentGroup) {
+            return [url];
+        }
+        const urlSegments = urlSegmentGroup.segments;
+        return urlSegments.reduce(function (acc, item) {
+            acc.push(item.path, item.parameters);
+            return acc;
+        }, []);
+    }
+}
+MenuPanelDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.1.2", ngImport: i0, type: MenuPanelDirective, deps: [{ token: i1.Store }, { token: i2.Router }], target: i0.ɵɵFactoryTarget.Directive });
+MenuPanelDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "14.1.2", type: MenuPanelDirective, selector: "[acaMenuPanel]", inputs: { acaMenuPanel: "acaMenuPanel" }, host: { listeners: { "menuOpened": "menuOpened()" } }, exportAs: ["acaMenuPanel"], ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.1.2", ngImport: i0, type: MenuPanelDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[acaMenuPanel]',
+                    exportAs: 'acaMenuPanel'
+                }]
+        }], ctorParameters: function () { return [{ type: i1.Store }, { type: i2.Router }]; }, propDecorators: { acaMenuPanel: [{
+                type: Input
+            }], menuOpened: [{
+                type: HostListener,
+                args: ['menuOpened']
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/components/sidenav/sidenav-wrapper/sidenav-wrapper.component.mjs

@@ -0,0 +1,45 @@
+/*!
+ * @license
+ * Alfresco Example Content Application
+ *
+ * Copyright (C) 2005 - 2020 Alfresco Software Limited
+ *
+ * This file is part of the Alfresco Example Content Application.
+ * If the software was purchased under a paid Alfresco license, the terms of
+ * the paid license agreement will prevail.  Otherwise, the software is
+ * provided under the following open source license terms:
+ *
+ * The Alfresco Example Content Application is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * The Alfresco Example Content Application is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with Alfresco. If not, see <http://www.gnu.org/licenses/>.
+ */
+import { Component, Input } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "../sidenav.component";
+/**
+ * This wrapper is designated to be used with 'adf-dynamic-component'.
+ * It forwards the dynamic component inputs to original sidenav.
+ */
+export class SidenavWrapperComponent {
+    constructor() {
+        this.data = {};
+    }
+}
+SidenavWrapperComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.1.2", ngImport: i0, type: SidenavWrapperComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+SidenavWrapperComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "14.1.2", type: SidenavWrapperComponent, selector: "aca-sidenav-wrapper", inputs: { data: "data" }, ngImport: i0, template: "<app-sidenav\n    [mode]=\"data.mode\"\n></app-sidenav>\n", dependencies: [{ kind: "component", type: i1.SidenavComponent, selector: "app-sidenav", inputs: ["mode"] }] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.1.2", ngImport: i0, type: SidenavWrapperComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'aca-sidenav-wrapper', template: "<app-sidenav\n    [mode]=\"data.mode\"\n></app-sidenav>\n" }]
+        }], propDecorators: { data: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/components/sidenav/sidenav.component.mjs

@@ -0,0 +1,76 @@
+/*!
+ * @license
+ * Alfresco Example Content Application
+ *
+ * Copyright (C) 2005 - 2020 Alfresco Software Limited
+ *
+ * This file is part of the Alfresco Example Content Application.
+ * If the software was purchased under a paid Alfresco license, the terms of
+ * the paid license agreement will prevail.  Otherwise, the software is
+ * provided under the following open source license terms:
+ *
+ * The Alfresco Example Content Application is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * The Alfresco Example Content Application is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with Alfresco. If not, see <http://www.gnu.org/licenses/>.
+ */
+import { Component, Input, ViewEncapsulation } from '@angular/core';
+import { Store } from '@ngrx/store';
+import { getSideNavState } from '@alfresco/aca-shared/store';
+import { Subject } from 'rxjs';
+import { takeUntil, distinctUntilChanged, debounceTime } from 'rxjs/operators';
+import { AppExtensionService } from '@alfresco/aca-shared';
+import * as i0 from "@angular/core";
+import * as i1 from "@ngrx/store";
+import * as i2 from "@alfresco/aca-shared";
+import * as i3 from "@angular/common";
+import * as i4 from "@angular/material/list";
+import * as i5 from "@alfresco/adf-extensions";
+import * as i6 from "../create-menu/create-menu.component";
+import * as i7 from "../main-action/main-action.component";
+import * as i8 from "./components/expand-menu.component";
+import * as i9 from "./components/button-menu.component";
+export class SidenavComponent {
+    constructor(store, extensions) {
+        this.store = store;
+        this.extensions = extensions;
+        this.mode = 'expanded';
+        this.groups = [];
+        this.onDestroy$ = new Subject();
+    }
+    ngOnInit() {
+        this.store
+            .select(getSideNavState)
+            .pipe(debounceTime(300), distinctUntilChanged(), takeUntil(this.onDestroy$))
+            .subscribe(() => {
+            this.groups = this.extensions.getApplicationNavigation(this.extensions.navbar);
+        });
+    }
+    trackByGroupId(_, obj) {
+        return obj.id;
+    }
+    trackByLinkId(_, obj) {
+        return obj.id;
+    }
+    ngOnDestroy() {
+        this.onDestroy$.next(true);
+        this.onDestroy$.complete();
+    }
+}
+SidenavComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.1.2", ngImport: i0, type: SidenavComponent, deps: [{ token: i1.Store }, { token: i2.AppExtensionService }], target: i0.ɵɵFactoryTarget.Component });
+SidenavComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "14.1.2", type: SidenavComponent, selector: "app-sidenav", inputs: { mode: "mode" }, host: { classAttribute: "app-sidenav" }, ngImport: i0, template: "<div class=\"sidenav\">\n  <ng-container [ngSwitch]=\"mode\">\n    <div class=\"section action-menu\" [ngClass]=\"'section--' + mode\">\n      <app-main-action [expanded]=\"mode === 'expanded'\"></app-main-action>\n      <app-create-menu [expanded]=\"mode === 'expanded'\"></app-create-menu>\n    </div>\n\n    <div class=\"section-sub-actions\">\n      <div *ngFor=\"let group of groups; trackBy: trackByGroupId\" class=\"section\" [ngClass]=\"'section--' + mode\">\n        <ng-container *ngSwitchCase=\"'expanded'\">\n          <mat-list-item *ngFor=\"let item of group.items; trackBy: trackByLinkId\">\n            <ng-container *ngIf=\"!item.component\">\n              <app-expand-menu [item]=\"item\"></app-expand-menu>\n            </ng-container>\n\n            <ng-container *ngIf=\"item.component\">\n              <adf-dynamic-component [data]=\"{ item: item, state: 'expanded' }\" [id]=\"item.component\"></adf-dynamic-component>\n            </ng-container>\n          </mat-list-item>\n        </ng-container>\n\n        <ng-container *ngSwitchCase=\"'collapsed'\">\n          <div class=\"list-item\" *ngFor=\"let item of group.items; trackBy: trackByLinkId\">\n            <ng-container *ngIf=\"!item.component\">\n              <app-button-menu [item]=\"item\"></app-button-menu>\n            </ng-container>\n\n            <ng-container *ngIf=\"item.component\">\n              <adf-dynamic-component [data]=\"{ item: item, state: 'collapsed' }\" [id]=\"item.component\"> </adf-dynamic-component>\n            </ng-container>\n          </div>\n        </ng-container>\n      </div>\n    </div>\n  </ng-container>\n</div>\n", styles: [".app-sidenav{display:flex;flex:1;flex-direction:column;height:100%;overflow-y:hidden}.aca-menu-panel .action-button--active{color:var(--theme-accent-color)!important}.aca-menu-panel .action-button{color:var(--theme-primary-color)}.aca-menu-panel .action-button:hover{color:var(--theme-accent-color)}.sidenav{display:flex;flex:1;flex-direction:column;height:100%;background-color:var(--theme-background-color)}.sidenav .section:last-child{border-bottom:0}.sidenav .action-menu{display:flex;flex-direction:column;justify-content:center;align-items:stretch}.sidenav .section.action-menu{padding:8px 14px;position:sticky}.sidenav .section-sub-actions{overflow-y:auto}.sidenav .section{padding:8px 6px;border-bottom:1px solid var(--theme-divider-color)}.sidenav .section--collapsed{display:flex;flex-direction:column;align-items:center}.sidenav .list-item{padding:12px 0;display:flex;align-items:center;height:24px}.sidenav .menu{display:flex;flex:1;flex-direction:row}.sidenav .full-width{display:flex;width:100%}.sidenav .action-button--active{color:var(--theme-primary-color)!important}.sidenav .action-button{color:var(--theme-text-color)}.sidenav .action-button .action-button__label{margin:0 8px!important}.sidenav .app-item,.sidenav .app-item .item{display:flex;flex:1;flex-direction:row}.sidenav .item{padding:12px 0;flex-direction:row;display:flex;align-items:center;text-decoration:none;height:24px;width:100%;-webkit-user-select:none;user-select:none}.sidenav .item:hover .action-button__label{color:var(--theme-primary-color)}.sidenav .mat-expansion-panel-header{padding:0 8px 0 0!important;display:flex;align-items:center;font-size:14px!important}.sidenav .mat-expansion-panel{width:100%;background-color:unset;box-shadow:none!important}.sidenav .mat-expansion-panel:not(.mat-expanded) .mat-expansion-panel-header:not([aria-disabled=true]):hover{background:none!important}.sidenav .mat-expansion-indicator{display:flex;align-content:center}.sidenav .mat-expansion-panel-body{padding-bottom:0}.sidenav .mat-expansion-panel-header-title{display:flex;flex-direction:row;align-items:center}[dir=rtl] .sidenav .mat-expansion-panel-header{padding:0 0 0 8px!important}\n"], dependencies: [{ kind: "directive", type: i3.NgClass, selector: "[ngClass]", inputs: ["class", "ngClass"] }, { kind: "directive", type: i3.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }, { kind: "directive", type: i3.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "directive", type: i3.NgSwitch, selector: "[ngSwitch]", inputs: ["ngSwitch"] }, { kind: "directive", type: i3.NgSwitchCase, selector: "[ngSwitchCase]", inputs: ["ngSwitchCase"] }, { kind: "component", type: i4.MatListItem, selector: "mat-list-item, a[mat-list-item], button[mat-list-item]", inputs: ["disableRipple", "disabled"], exportAs: ["matListItem"] }, { kind: "component", type: i5.DynamicExtensionComponent, selector: "adf-dynamic-component", inputs: ["id", "data"] }, { kind: "component", type: i6.CreateMenuComponent, selector: "app-create-menu", inputs: ["showLabel", "expanded"] }, { kind: "component", type: i7.MainActionComponent, selector: "app-main-action", inputs: ["expanded"] }, { kind: "component", type: i8.ExpandMenuComponent, selector: "app-expand-menu", inputs: ["item"] }, { kind: "component", type: i9.ButtonMenuComponent, selector: "app-button-menu", inputs: ["item"] }], encapsulation: i0.ViewEncapsulation.None });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.1.2", ngImport: i0, type: SidenavComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'app-sidenav', encapsulation: ViewEncapsulation.None, host: { class: 'app-sidenav' }, template: "<div class=\"sidenav\">\n  <ng-container [ngSwitch]=\"mode\">\n    <div class=\"section action-menu\" [ngClass]=\"'section--' + mode\">\n      <app-main-action [expanded]=\"mode === 'expanded'\"></app-main-action>\n      <app-create-menu [expanded]=\"mode === 'expanded'\"></app-create-menu>\n    </div>\n\n    <div class=\"section-sub-actions\">\n      <div *ngFor=\"let group of groups; trackBy: trackByGroupId\" class=\"section\" [ngClass]=\"'section--' + mode\">\n        <ng-container *ngSwitchCase=\"'expanded'\">\n          <mat-list-item *ngFor=\"let item of group.items; trackBy: trackByLinkId\">\n            <ng-container *ngIf=\"!item.component\">\n              <app-expand-menu [item]=\"item\"></app-expand-menu>\n            </ng-container>\n\n            <ng-container *ngIf=\"item.component\">\n              <adf-dynamic-component [data]=\"{ item: item, state: 'expanded' }\" [id]=\"item.component\"></adf-dynamic-component>\n            </ng-container>\n          </mat-list-item>\n        </ng-container>\n\n        <ng-container *ngSwitchCase=\"'collapsed'\">\n          <div class=\"list-item\" *ngFor=\"let item of group.items; trackBy: trackByLinkId\">\n            <ng-container *ngIf=\"!item.component\">\n              <app-button-menu [item]=\"item\"></app-button-menu>\n            </ng-container>\n\n            <ng-container *ngIf=\"item.component\">\n              <adf-dynamic-component [data]=\"{ item: item, state: 'collapsed' }\" [id]=\"item.component\"> </adf-dynamic-component>\n            </ng-container>\n          </div>\n        </ng-container>\n      </div>\n    </div>\n  </ng-container>\n</div>\n", styles: [".app-sidenav{display:flex;flex:1;flex-direction:column;height:100%;overflow-y:hidden}.aca-menu-panel .action-button--active{color:var(--theme-accent-color)!important}.aca-menu-panel .action-button{color:var(--theme-primary-color)}.aca-menu-panel .action-button:hover{color:var(--theme-accent-color)}.sidenav{display:flex;flex:1;flex-direction:column;height:100%;background-color:var(--theme-background-color)}.sidenav .section:last-child{border-bottom:0}.sidenav .action-menu{display:flex;flex-direction:column;justify-content:center;align-items:stretch}.sidenav .section.action-menu{padding:8px 14px;position:sticky}.sidenav .section-sub-actions{overflow-y:auto}.sidenav .section{padding:8px 6px;border-bottom:1px solid var(--theme-divider-color)}.sidenav .section--collapsed{display:flex;flex-direction:column;align-items:center}.sidenav .list-item{padding:12px 0;display:flex;align-items:center;height:24px}.sidenav .menu{display:flex;flex:1;flex-direction:row}.sidenav .full-width{display:flex;width:100%}.sidenav .action-button--active{color:var(--theme-primary-color)!important}.sidenav .action-button{color:var(--theme-text-color)}.sidenav .action-button .action-button__label{margin:0 8px!important}.sidenav .app-item,.sidenav .app-item .item{display:flex;flex:1;flex-direction:row}.sidenav .item{padding:12px 0;flex-direction:row;display:flex;align-items:center;text-decoration:none;height:24px;width:100%;-webkit-user-select:none;user-select:none}.sidenav .item:hover .action-button__label{color:var(--theme-primary-color)}.sidenav .mat-expansion-panel-header{padding:0 8px 0 0!important;display:flex;align-items:center;font-size:14px!important}.sidenav .mat-expansion-panel{width:100%;background-color:unset;box-shadow:none!important}.sidenav .mat-expansion-panel:not(.mat-expanded) .mat-expansion-panel-header:not([aria-disabled=true]):hover{background:none!important}.sidenav .mat-expansion-indicator{display:flex;align-content:center}.sidenav .mat-expansion-panel-body{padding-bottom:0}.sidenav .mat-expansion-panel-header-title{display:flex;flex-direction:row;align-items:center}[dir=rtl] .sidenav .mat-expansion-panel-header{padding:0 0 0 8px!important}\n"] }]
+        }], ctorParameters: function () { return [{ type: i1.Store }, { type: i2.AppExtensionService }]; }, propDecorators: { mode: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/components/sidenav/sidenav.module.mjs

@@ -0,0 +1,104 @@
+/*!
+ * @license
+ * Alfresco Example Content Application
+ *
+ * Copyright (C) 2005 - 2020 Alfresco Software Limited
+ *
+ * This file is part of the Alfresco Example Content Application.
+ * If the software was purchased under a paid Alfresco license, the terms of
+ * the paid license agreement will prevail.  Otherwise, the software is
+ * provided under the following open source license terms:
+ *
+ * The Alfresco Example Content Application is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * The Alfresco Example Content Application is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with Alfresco. If not, see <http://www.gnu.org/licenses/>.
+ */
+import { NgModule } from '@angular/core';
+import { AppCreateMenuModule } from '../create-menu/create-menu.module';
+import { CommonModule } from '@angular/common';
+import { CoreModule } from '@alfresco/adf-core';
+import { RouterModule } from '@angular/router';
+import { ExtensionsModule } from '@alfresco/adf-extensions';
+import { CoreExtensionsModule } from '../../extensions/core.extensions.module';
+import { ExpansionPanelDirective } from './directives/expansion-panel.directive';
+import { MenuPanelDirective } from './directives/menu-panel.directive';
+import { SidenavComponent } from './sidenav.component';
+import { ActiveLinkDirective } from './directives/active-link.directive';
+import { ExpandMenuComponent } from './components/expand-menu.component';
+import { ButtonMenuComponent } from './components/button-menu.component';
+import { ActionDirective } from './directives/action.directive';
+import { MainActionModule } from '../main-action/main-action.module';
+import { SidenavWrapperComponent } from './sidenav-wrapper/sidenav-wrapper.component';
+import * as i0 from "@angular/core";
+import * as i1 from "@alfresco/adf-core";
+import * as i2 from "../../extensions/core.extensions.module";
+import * as i3 from "@alfresco/adf-extensions";
+export class AppSidenavModule {
+}
+AppSidenavModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.1.2", ngImport: i0, type: AppSidenavModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+AppSidenavModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "14.1.2", ngImport: i0, type: AppSidenavModule, declarations: [MenuPanelDirective,
+        ExpansionPanelDirective,
+        ActiveLinkDirective,
+        ActionDirective,
+        ExpandMenuComponent,
+        ButtonMenuComponent,
+        SidenavComponent,
+        SidenavWrapperComponent], imports: [CommonModule, i1.CoreModule, i2.CoreExtensionsModule, i3.ExtensionsModule, RouterModule,
+        AppCreateMenuModule,
+        MainActionModule], exports: [MenuPanelDirective,
+        ExpansionPanelDirective,
+        ActiveLinkDirective,
+        ActionDirective,
+        ExpandMenuComponent,
+        ButtonMenuComponent,
+        SidenavComponent] });
+AppSidenavModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "14.1.2", ngImport: i0, type: AppSidenavModule, imports: [CommonModule,
+        CoreModule.forChild(),
+        CoreExtensionsModule.forChild(),
+        ExtensionsModule.forChild(),
+        RouterModule,
+        AppCreateMenuModule,
+        MainActionModule] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.1.2", ngImport: i0, type: AppSidenavModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [
+                        CommonModule,
+                        CoreModule.forChild(),
+                        CoreExtensionsModule.forChild(),
+                        ExtensionsModule.forChild(),
+                        RouterModule,
+                        AppCreateMenuModule,
+                        MainActionModule
+                    ],
+                    declarations: [
+                        MenuPanelDirective,
+                        ExpansionPanelDirective,
+                        ActiveLinkDirective,
+                        ActionDirective,
+                        ExpandMenuComponent,
+                        ButtonMenuComponent,
+                        SidenavComponent,
+                        SidenavWrapperComponent
+                    ],
+                    exports: [
+                        MenuPanelDirective,
+                        ExpansionPanelDirective,
+                        ActiveLinkDirective,
+                        ActionDirective,
+                        ExpandMenuComponent,
+                        ButtonMenuComponent,
+                        SidenavComponent
+                    ]
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2lkZW5hdi5tb2R1bGUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9hY2EtY29udGVudC9zcmMvbGliL2NvbXBvbmVudHMvc2lkZW5hdi9zaWRlbmF2Lm1vZHVsZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7R0F1Qkc7QUFFSCxPQUFPLEVBQUUsUUFBUSxFQUFFLE1BQU0sZUFBZSxDQUFDO0FBQ3pDLE9BQU8sRUFBRSxtQkFBbUIsRUFBRSxNQUFNLG1DQUFtQyxDQUFDO0FBQ3hFLE9BQU8sRUFBRSxZQUFZLEVBQUUsTUFBTSxpQkFBaUIsQ0FBQztBQUMvQyxPQUFPLEVBQUUsVUFBVSxFQUFFLE1BQU0sb0JBQW9CLENBQUM7QUFDaEQsT0FBTyxFQUFFLFlBQVksRUFBRSxNQUFNLGlCQUFpQixDQUFDO0FBQy9DLE9BQU8sRUFBRSxnQkFBZ0IsRUFBRSxNQUFNLDBCQUEwQixDQUFDO0FBQzVELE9BQU8sRUFBRSxvQkFBb0IsRUFBRSxNQUFNLHlDQUF5QyxDQUFDO0FBQy9FLE9BQU8sRUFBRSx1QkFBdUIsRUFBRSxNQUFNLHdDQUF3QyxDQUFDO0FBQ2pGLE9BQU8sRUFBRSxrQkFBa0IsRUFBRSxNQUFNLG1DQUFtQyxDQUFDO0FBQ3ZFLE9BQU8sRUFBRSxnQkFBZ0IsRUFBRSxNQUFNLHFCQUFxQixDQUFDO0FBQ3ZELE9BQU8sRUFBRSxtQkFBbUIsRUFBRSxNQUFNLG9DQUFvQyxDQUFDO0FBQ3pFLE9BQU8sRUFBRSxtQkFBbUIsRUFBRSxNQUFNLG9DQUFvQyxDQUFDO0FBQ3pFLE9BQU8sRUFBRSxtQkFBbUIsRUFBRSxNQUFNLG9DQUFvQyxDQUFDO0FBQ3pFLE9BQU8sRUFBRSxlQUFlLEVBQUUsTUFBTSwrQkFBK0IsQ0FBQztBQUNoRSxPQUFPLEVBQUUsZ0JBQWdCLEVBQUUsTUFBTSxtQ0FBbUMsQ0FBQztBQUNyRSxPQUFPLEVBQUUsdUJBQXVCLEVBQUUsTUFBTSw2Q0FBNkMsQ0FBQzs7Ozs7QUFnQ3RGLE1BQU0sT0FBTyxnQkFBZ0I7OzZHQUFoQixnQkFBZ0I7OEdBQWhCLGdCQUFnQixpQkFuQnpCLGtCQUFrQjtRQUNsQix1QkFBdUI7UUFDdkIsbUJBQW1CO1FBQ25CLGVBQWU7UUFDZixtQkFBbUI7UUFDbkIsbUJBQW1CO1FBQ25CLGdCQUFnQjtRQUNoQix1QkFBdUIsYUFoQnZCLFlBQVksK0RBSVosWUFBWTtRQUNaLG1CQUFtQjtRQUNuQixnQkFBZ0IsYUFhaEIsa0JBQWtCO1FBQ2xCLHVCQUF1QjtRQUN2QixtQkFBbUI7UUFDbkIsZUFBZTtRQUNmLG1CQUFtQjtRQUNuQixtQkFBbUI7UUFDbkIsZ0JBQWdCOzhHQUdQLGdCQUFnQixZQTVCekIsWUFBWTtRQUNaLFVBQVUsQ0FBQyxRQUFRLEVBQUU7UUFDckIsb0JBQW9CLENBQUMsUUFBUSxFQUFFO1FBQy9CLGdCQUFnQixDQUFDLFFBQVEsRUFBRTtRQUMzQixZQUFZO1FBQ1osbUJBQW1CO1FBQ25CLGdCQUFnQjsyRkFzQlAsZ0JBQWdCO2tCQTlCNUIsUUFBUTttQkFBQztvQkFDUixPQUFPLEVBQUU7d0JBQ1AsWUFBWTt3QkFDWixVQUFVLENBQUMsUUFBUSxFQUFFO3dCQUNyQixvQkFBb0IsQ0FBQyxRQUFRLEVBQUU7d0JBQy9CLGdCQUFnQixDQUFDLFFBQVEsRUFBRTt3QkFDM0IsWUFBWTt3QkFDWixtQkFBbUI7d0JBQ25CLGdCQUFnQjtxQkFDakI7b0JBQ0QsWUFBWSxFQUFFO3dCQUNaLGtCQUFrQjt3QkFDbEIsdUJBQXVCO3dCQUN2QixtQkFBbUI7d0JBQ25CLGVBQWU7d0JBQ2YsbUJBQW1CO3dCQUNuQixtQkFBbUI7d0JBQ25CLGdCQUFnQjt3QkFDaEIsdUJBQXVCO3FCQUN4QjtvQkFDRCxPQUFPLEVBQUU7d0JBQ1Asa0JBQWtCO3dCQUNsQix1QkFBdUI7d0JBQ3ZCLG1CQUFtQjt3QkFDbkIsZUFBZTt3QkFDZixtQkFBbUI7d0JBQ25CLG1CQUFtQjt3QkFDbkIsZ0JBQWdCO3FCQUNqQjtpQkFDRiIsInNvdXJjZXNDb250ZW50IjpbIi8qIVxuICogQGxpY2Vuc2VcbiAqIEFsZnJlc2NvIEV4YW1wbGUgQ29udGVudCBBcHBsaWNhdGlvblxuICpcbiAqIENvcHlyaWdodCAoQykgMjAwNSAtIDIwMjAgQWxmcmVzY28gU29mdHdhcmUgTGltaXRlZFxuICpcbiAqIFRoaXMgZmlsZSBpcyBwYXJ0IG9mIHRoZSBBbGZyZXNjbyBFeGFtcGxlIENvbnRlbnQgQXBwbGljYXRpb24uXG4gKiBJZiB0aGUgc29mdHdhcmUgd2FzIHB1cmNoYXNlZCB1bmRlciBhIHBhaWQgQWxmcmVzY28gbGljZW5zZSwgdGhlIHRlcm1zIG9mXG4gKiB0aGUgcGFpZCBsaWNlbnNlIGFncmVlbWVudCB3aWxsIHByZXZhaWwuICBPdGhlcndpc2UsIHRoZSBzb2Z0d2FyZSBpc1xuICogcHJvdmlkZWQgdW5kZXIgdGhlIGZvbGxvd2luZyBvcGVuIHNvdXJjZSBsaWNlbnNlIHRlcm1zOlxuICpcbiAqIFRoZSBBbGZyZXNjbyBFeGFtcGxlIENvbnRlbnQgQXBwbGljYXRpb24gaXMgZnJlZSBzb2Z0d2FyZTogeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yIG1vZGlmeVxuICogaXQgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUgTGVzc2VyIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgYXMgcHVibGlzaGVkIGJ5XG4gKiB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uLCBlaXRoZXIgdmVyc2lvbiAzIG9mIHRoZSBMaWNlbnNlLCBvclxuICogKGF0IHlvdXIgb3B0aW9uKSBhbnkgbGF0ZXIgdmVyc2lvbi5cbiAqXG4gKiBUaGUgQWxmcmVzY28gRXhhbXBsZSBDb250ZW50IEFwcGxpY2F0aW9uIGlzIGRpc3RyaWJ1dGVkIGluIHRoZSBob3BlIHRoYXQgaXQgd2lsbCBiZSB1c2VmdWwsXG4gKiBidXQgV0lUSE9VVCBBTlkgV0FSUkFOVFk7IHdpdGhvdXQgZXZlbiB0aGUgaW1wbGllZCB3YXJyYW50eSBvZlxuICogTUVSQ0hBTlRBQklMSVRZIG9yIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQVVJQT1NFLiAgU2VlIHRoZVxuICogR05VIExlc3NlciBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGZvciBtb3JlIGRldGFpbHMuXG4gKlxuICogWW91IHNob3VsZCBoYXZlIHJlY2VpdmVkIGEgY29weSBvZiB0aGUgR05VIExlc3NlciBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlXG4gKiBhbG9uZyB3aXRoIEFsZnJlc2NvLiBJZiBub3QsIHNlZSA8aHR0cDovL3d3dy5nbnUub3JnL2xpY2Vuc2VzLz4uXG4gKi9cblxuaW1wb3J0IHsgTmdNb2R1bGUgfSBmcm9tICdAYW5ndWxhci9jb3JlJztcbmltcG9ydCB7IEFwcENyZWF0ZU1lbnVNb2R1bGUgfSBmcm9tICcuLi9jcmVhdGUtbWVudS9jcmVhdGUtbWVudS5tb2R1bGUnO1xuaW1wb3J0IHsgQ29tbW9uTW9kdWxlIH0gZnJvbSAnQGFuZ3VsYXIvY29tbW9uJztcbmltcG9ydCB7IENvcmVNb2R1bGUgfSBmcm9tICdAYWxmcmVzY28vYWRmLWNvcmUnO1xuaW1wb3J0IHsgUm91dGVyTW9kdWxlIH0gZnJvbSAnQGFuZ3VsYXIvcm91dGVyJztcbmltcG9ydCB7IEV4dGVuc2lvbnNNb2R1bGUgfSBmcm9tICdAYWxmcmVzY28vYWRmLWV4dGVuc2lvbnMnO1xuaW1wb3J0IHsgQ29yZUV4dGVuc2lvbnNNb2R1bGUgfSBmcm9tICcuLi8uLi9leHRlbnNpb25zL2NvcmUuZXh0ZW5zaW9ucy5tb2R1bGUnO1xuaW1wb3J0IHsgRXhwYW5zaW9uUGFuZWxEaXJlY3RpdmUgfSBmcm9tICcuL2RpcmVjdGl2ZXMvZXhwYW5zaW9uLXBhbmVsLmRpcmVjdGl2ZSc7XG5pbXBvcnQgeyBNZW51UGFuZWxEaXJlY3RpdmUgfSBmcm9tICcuL2RpcmVjdGl2ZXMvbWVudS1wYW5lbC5kaXJlY3RpdmUnO1xuaW1wb3J0IHsgU2lkZW5hdkNvbXBvbmVudCB9IGZyb20gJy4vc2lkZW5hdi5jb21wb25lbnQnO1xuaW1wb3J0IHsgQWN0aXZlTGlua0RpcmVjdGl2ZSB9IGZyb20gJy4vZGlyZWN0aXZlcy9hY3RpdmUtbGluay5kaXJlY3RpdmUnO1xuaW1wb3J0IHsgRXhwYW5kTWVudUNvbXBvbmVudCB9IGZyb20gJy4vY29tcG9uZW50cy9leHBhbmQtbWVudS5jb21wb25lbnQnO1xuaW1wb3J0IHsgQnV0dG9uTWVudUNvbXBvbmVudCB9IGZyb20gJy4vY29tcG9uZW50cy9idXR0b24tbWVudS5jb21wb25lbnQnO1xuaW1wb3J0IHsgQWN0aW9uRGlyZWN0aXZlIH0gZnJvbSAnLi9kaXJlY3RpdmVzL2FjdGlvbi5kaXJlY3RpdmUnO1xuaW1wb3J0IHsgTWFpbkFjdGlvbk1vZHVsZSB9IGZyb20gJy4uL21haW4tYWN0aW9uL21haW4tYWN0aW9uLm1vZHVsZSc7XG5pbXBvcnQgeyBTaWRlbmF2V3JhcHBlckNvbXBvbmVudCB9IGZyb20gJy4vc2lkZW5hdi13cmFwcGVyL3NpZGVuYXYtd3JhcHBlci5jb21wb25lbnQnO1xuXG5ATmdNb2R1bGUoe1xuICBpbXBvcnRzOiBbXG4gICAgQ29tbW9uTW9kdWxlLFxuICAgIENvcmVNb2R1bGUuZm9yQ2hpbGQoKSxcbiAgICBDb3JlRXh0ZW5zaW9uc01vZHVsZS5mb3JDaGlsZCgpLFxuICAgIEV4dGVuc2lvbnNNb2R1bGUuZm9yQ2hpbGQoKSxcbiAgICBSb3V0ZXJNb2R1bGUsXG4gICAgQXBwQ3JlYXRlTWVudU1vZHVsZSxcbiAgICBNYWluQWN0aW9uTW9kdWxlXG4gIF0sXG4gIGRlY2xhcmF0aW9uczogW1xuICAgIE1lbnVQYW5lbERpcmVjdGl2ZSxcbiAgICBFeHBhbnNpb25QYW5lbERpcmVjdGl2ZSxcbiAgICBBY3RpdmVMaW5rRGlyZWN0aXZlLFxuICAgIEFjdGlvbkRpcmVjdGl2ZSxcbiAgICBFeHBhbmRNZW51Q29tcG9uZW50LFxuICAgIEJ1dHRvbk1lbnVDb21wb25lbnQsXG4gICAgU2lkZW5hdkNvbXBvbmVudCxcbiAgICBTaWRlbmF2V3JhcHBlckNvbXBvbmVudFxuICBdLFxuICBleHBvcnRzOiBbXG4gICAgTWVudVBhbmVsRGlyZWN0aXZlLFxuICAgIEV4cGFuc2lvblBhbmVsRGlyZWN0aXZlLFxuICAgIEFjdGl2ZUxpbmtEaXJlY3RpdmUsXG4gICAgQWN0aW9uRGlyZWN0aXZlLFxuICAgIEV4cGFuZE1lbnVDb21wb25lbnQsXG4gICAgQnV0dG9uTWVudUNvbXBvbmVudCxcbiAgICBTaWRlbmF2Q29tcG9uZW50XG4gIF1cbn0pXG5leHBvcnQgY2xhc3MgQXBwU2lkZW5hdk1vZHVsZSB7fVxuIl19