@alfresco/aca-content 4.0.0-4895233349

package/esm2020/lib/components/sidenav/directives/action.directive.mjs

@@ -0,0 +1,74 @@
+/*!
+ * Copyright © 2005-2023 Hyland Software, Inc. and its affiliates. All rights reserved.
+ *
+ * Alfresco Example Content Application
+ *
+ * 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
+ * from Hyland Software. If not, see <http://www.gnu.org/licenses/>.
+ */
+import { Directive, Input, HostListener } from '@angular/core';
+import { PRIMARY_OUTLET, Router } from '@angular/router';
+import { Store } from '@ngrx/store';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/router";
+import * as i2 from "@ngrx/store";
+export class ActionDirective {
+    constructor(router, store) {
+        this.router = router;
+        this.store = store;
+    }
+    onClick() {
+        if (this.action.url) {
+            this.router.navigate(this.getNavigationCommands(this.action.url));
+        }
+        else if (this.action.click) {
+            this.store.dispatch({
+                type: this.action.click.action,
+                payload: this.getNavigationCommands(this.action.click.payload)
+            });
+        }
+    }
+    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;
+        }, []);
+    }
+}
+ActionDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.1.3", ngImport: i0, type: ActionDirective, deps: [{ token: i1.Router }, { token: i2.Store }], target: i0.ɵɵFactoryTarget.Directive });
+ActionDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "14.1.3", type: ActionDirective, selector: "[action]", inputs: { action: "action" }, host: { listeners: { "click": "onClick()" } }, exportAs: ["action"], ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.1.3", ngImport: i0, type: ActionDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    /* eslint-disable-next-line */
+                    selector: '[action]',
+                    exportAs: 'action'
+                }]
+        }], ctorParameters: function () { return [{ type: i1.Router }, { type: i2.Store }]; }, propDecorators: { action: [{
+                type: Input
+            }], onClick: [{
+                type: HostListener,
+                args: ['click']
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,92 @@
+/*!
+ * Copyright © 2005-2023 Hyland Software, Inc. and its affiliates. All rights reserved.
+ *
+ * Alfresco Example Content Application
+ *
+ * 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
+ * from Hyland Software. 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.3", 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.3", 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.3", 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,101 @@
+/*!
+ * Copyright © 2005-2023 Hyland Software, Inc. and its affiliates. All rights reserved.
+ *
+ * Alfresco Example Content Application
+ *
+ * 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
+ * from Hyland Software. 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.3", 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.3", type: ExpansionPanelDirective, selector: "[acaExpansionPanel]", inputs: { acaExpansionPanel: "acaExpansionPanel" }, host: { listeners: { "click": "onClick()" } }, exportAs: ["acaExpansionPanel"], ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.1.3", 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;;;;;;;;;;;;;;;;;;;;;;GAsBG;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 * Copyright © 2005-2023 Hyland Software, Inc. and its affiliates. All rights reserved.\n *\n * Alfresco Example Content Application\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 * from Hyland Software. 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,98 @@
+/*!
+ * Copyright © 2005-2023 Hyland Software, Inc. and its affiliates. All rights reserved.
+ *
+ * Alfresco Example Content Application
+ *
+ * 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
+ * from Hyland Software. 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.3", 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.3", type: MenuPanelDirective, selector: "[acaMenuPanel]", inputs: { acaMenuPanel: "acaMenuPanel" }, host: { listeners: { "menuOpened": "menuOpened()" } }, exportAs: ["acaMenuPanel"], ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.1.3", 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,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibWVudS1wYW5lbC5kaXJlY3RpdmUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9hY2EtY29udGVudC9zcmMvbGliL2NvbXBvbmVudHMvc2lkZW5hdi9kaXJlY3RpdmVzL21lbnUtcGFuZWwuZGlyZWN0aXZlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOzs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7O0dBc0JHO0FBRUgsT0FBTyxFQUFFLFNBQVMsRUFBRSxLQUFLLEVBQXFCLFlBQVksRUFBRSxNQUFNLGVBQWUsQ0FBQztBQUNsRixPQUFPLEVBQUUsTUFBTSxFQUFFLGFBQWEsRUFBRSxjQUFjLEVBQUUsTUFBTSxpQkFBaUIsQ0FBQztBQUN4RSxPQUFPLEVBQUUsTUFBTSxFQUFFLFNBQVMsRUFBRSxNQUFNLGdCQUFnQixDQUFDO0FBQ25ELE9BQU8sRUFBRSxPQUFPLEVBQUUsTUFBTSxNQUFNLENBQUM7QUFDL0IsT0FBTyxFQUFFLEtBQUssRUFBRSxNQUFNLGFBQWEsQ0FBQzs7OztBQU1wQyxNQUFNLE9BQU8sa0JBQWtCO0lBcUI3QixZQUFvQixLQUFpQixFQUFVLE1BQWM7UUFBekMsVUFBSyxHQUFMLEtBQUssQ0FBWTtRQUFVLFdBQU0sR0FBTixNQUFNLENBQVE7UUFuQjdELHNCQUFpQixHQUFHLEtBQUssQ0FBQztRQUVsQixlQUFVLEdBQXFCLElBQUksT0FBTyxFQUFXLENBQUM7SUFpQkUsQ0FBQztJQWRqRSxVQUFVO1FBQ1IsSUFBSSxJQUFJLENBQUMsWUFBWSxDQUFDLFFBQVEsSUFBSSxDQUFDLElBQUksQ0FBQyxjQUFjLEVBQUUsRUFBRTtZQUN4RCxNQUFNLFVBQVUsR0FBRyxJQUFJLENBQUMsWUFBWSxDQUFDLFFBQVEsQ0FBQyxDQUFDLENBQUMsQ0FBQztZQUNqRCxJQUFJLFVBQVUsQ0FBQyxHQUFHLEVBQUU7Z0JBQ2xCLElBQUksQ0FBQyxNQUFNLENBQUMsUUFBUSxDQUFDLElBQUksQ0FBQyxxQkFBcUIsQ0FBQyxVQUFVLENBQUMsR0FBRyxDQUFDLENBQUMsQ0FBQzthQUNsRTtpQkFBTTtnQkFDTCxJQUFJLENBQUMsS0FBSyxDQUFDLFFBQVEsQ0FBQztvQkFDbEIsSUFBSSxFQUFFLFVBQVUsQ0FBQyxNQUFNLENBQUMsTUFBTTtvQkFDOUIsT0FBTyxFQUFFLElBQUksQ0FBQyxxQkFBcUIsQ0FBQyxVQUFVLENBQUMsTUFBTSxDQUFDLE9BQU8sQ0FBQztpQkFDL0QsQ0FBQyxDQUFDO2FBQ0o7U0FDRjtJQUNILENBQUM7SUFJRCxjQUFjO1FBQ1osSUFBSSxJQUFJLENBQUMsWUFBWSxJQUFJLElBQUksQ0FBQyxZQUFZLENBQUMsUUFBUSxFQUFFO1lBQ25ELE9BQU8sSUFBSSxDQUFDLFlBQVksQ0FBQyxRQUFRLENBQUMsSUFBSSxDQUFDLENBQUMsS0FBSyxFQUFFLEVBQUUsQ0FBQyxJQUFJLENBQUMsTUFBTSxDQUFDLEdBQUcsQ0FBQyxVQUFVLENBQUMsS0FBSyxDQUFDLEdBQUcsSUFBSSxLQUFLLENBQUMsTUFBTSxDQUFDLE9BQU8sQ0FBQyxDQUFDLENBQUM7U0FDbEg7UUFDRCxPQUFPLEtBQUssQ0FBQztJQUNmLENBQUM7SUFFRCxRQUFRO1FBQ04sSUFBSSxDQUFDLGlCQUFpQixHQUFHLElBQUksQ0FBQyxjQUFjLEVBQUUsQ0FBQztRQUUvQyxJQUFJLENBQUMsTUFBTSxDQUFDLE1BQU07YUFDZixJQUFJLENBQ0gsTUFBTSxDQUFDLENBQUMsS0FBSyxFQUFFLEVBQUUsQ0FBQyxLQUFLLFlBQVksYUFBYSxDQUFDLEVBQ2pELFNBQVMsQ0FBQyxJQUFJLENBQUMsVUFBVSxDQUFDLENBQzNCO2FBQ0EsU0FBUyxDQUFDLEdBQUcsRUFBRTtZQUNkLElBQUksQ0FBQyxpQkFBaUIsR0FBRyxJQUFJLENBQUMsY0FBYyxFQUFFLENBQUM7UUFDakQsQ0FBQyxDQUFDLENBQUM7SUFDUCxDQUFDO0lBRUQsV0FBVztRQUNULElBQUksQ0FBQyxVQUFVLENBQUMsSUFBSSxDQUFDLElBQUksQ0FBQyxDQUFDO1FBQzNCLElBQUksQ0FBQyxVQUFVLENBQUMsUUFBUSxFQUFFLENBQUM7SUFDN0IsQ0FBQztJQUVPLHFCQUFxQixDQUFDLEdBQVc7UUFDdkMsTUFBTSxPQUFPLEdBQUcsSUFBSSxDQUFDLE1BQU0sQ0FBQyxRQUFRLENBQUMsR0FBRyxDQUFDLENBQUM7UUFDMUMsTUFBTSxlQUFlLEdBQUcsT0FBTyxDQUFDLElBQUksQ0FBQyxRQUFRLENBQUMsY0FBYyxDQUFDLENBQUM7UUFFOUQsSUFBSSxDQUFDLGVBQWUsRUFBRTtZQUNwQixPQUFPLENBQUMsR0FBRyxDQUFDLENBQUM7U0FDZDtRQUVELE1BQU0sV0FBVyxHQUFHLGVBQWUsQ0FBQyxRQUFRLENBQUM7UUFFN0MsT0FBTyxXQUFXLENBQUMsTUFBTSxDQUFDLFVBQVUsR0FBRyxFQUFFLElBQUk7WUFDM0MsR0FBRyxDQUFDLElBQUksQ0FBQyxJQUFJLENBQUMsSUFBSSxFQUFFLElBQUksQ0FBQyxVQUFVLENBQUMsQ0FBQztZQUNyQyxPQUFPLEdBQUcsQ0FBQztRQUNiLENBQUMsRUFBRSxFQUFFLENBQUMsQ0FBQztJQUNULENBQUM7OytHQTlEVSxrQkFBa0I7bUdBQWxCLGtCQUFrQjsyRkFBbEIsa0JBQWtCO2tCQUo5QixTQUFTO21CQUFDO29CQUNULFFBQVEsRUFBRSxnQkFBZ0I7b0JBQzFCLFFBQVEsRUFBRSxjQUFjO2lCQUN6QjtpSEFFVSxZQUFZO3NCQUFwQixLQUFLO2dCQU1OLFVBQVU7c0JBRFQsWUFBWTt1QkFBQyxZQUFZIiwic291cmNlc0NvbnRlbnQiOlsiLyohXG4gKiBDb3B5cmlnaHQgwqkgMjAwNS0yMDIzIEh5bGFuZCBTb2Z0d2FyZSwgSW5jLiBhbmQgaXRzIGFmZmlsaWF0ZXMuIEFsbCByaWdodHMgcmVzZXJ2ZWQuXG4gKlxuICogQWxmcmVzY28gRXhhbXBsZSBDb250ZW50IEFwcGxpY2F0aW9uXG4gKlxuICogVGhpcyBmaWxlIGlzIHBhcnQgb2YgdGhlIEFsZnJlc2NvIEV4YW1wbGUgQ29udGVudCBBcHBsaWNhdGlvbi5cbiAqIElmIHRoZSBzb2Z0d2FyZSB3YXMgcHVyY2hhc2VkIHVuZGVyIGEgcGFpZCBBbGZyZXNjbyBsaWNlbnNlLCB0aGUgdGVybXMgb2ZcbiAqIHRoZSBwYWlkIGxpY2Vuc2UgYWdyZWVtZW50IHdpbGwgcHJldmFpbC4gT3RoZXJ3aXNlLCB0aGUgc29mdHdhcmUgaXNcbiAqIHByb3ZpZGVkIHVuZGVyIHRoZSBmb2xsb3dpbmcgb3BlbiBzb3VyY2UgbGljZW5zZSB0ZXJtczpcbiAqXG4gKiBUaGUgQWxmcmVzY28gRXhhbXBsZSBDb250ZW50IEFwcGxpY2F0aW9uIGlzIGZyZWUgc29mdHdhcmU6IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vciBtb2RpZnlcbiAqIGl0IHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgR05VIExlc3NlciBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGFzIHB1Ymxpc2hlZCBieVxuICogdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbiwgZWl0aGVyIHZlcnNpb24gMyBvZiB0aGUgTGljZW5zZSwgb3JcbiAqIChhdCB5b3VyIG9wdGlvbikgYW55IGxhdGVyIHZlcnNpb24uXG4gKlxuICogVGhlIEFsZnJlc2NvIEV4YW1wbGUgQ29udGVudCBBcHBsaWNhdGlvbiBpcyBkaXN0cmlidXRlZCBpbiB0aGUgaG9wZSB0aGF0IGl0IHdpbGwgYmUgdXNlZnVsLFxuICogYnV0IFdJVEhPVVQgQU5ZIFdBUlJBTlRZOyB3aXRob3V0IGV2ZW4gdGhlIGltcGxpZWQgd2FycmFudHkgb2ZcbiAqIE1FUkNIQU5UQUJJTElUWSBvciBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRS4gU2VlIHRoZVxuICogR05VIExlc3NlciBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGZvciBtb3JlIGRldGFpbHMuXG4gKlxuICogWW91IHNob3VsZCBoYXZlIHJlY2VpdmVkIGEgY29weSBvZiB0aGUgR05VIExlc3NlciBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlXG4gKiBmcm9tIEh5bGFuZCBTb2Z0d2FyZS4gSWYgbm90LCBzZWUgPGh0dHA6Ly93d3cuZ251Lm9yZy9saWNlbnNlcy8+LlxuICovXG5cbmltcG9ydCB7IERpcmVjdGl2ZSwgSW5wdXQsIE9uSW5pdCwgT25EZXN0cm95LCBIb3N0TGlzdGVuZXIgfSBmcm9tICdAYW5ndWxhci9jb3JlJztcbmltcG9ydCB7IFJvdXRlciwgTmF2aWdhdGlvbkVuZCwgUFJJTUFSWV9PVVRMRVQgfSBmcm9tICdAYW5ndWxhci9yb3V0ZXInO1xuaW1wb3J0IHsgZmlsdGVyLCB0YWtlVW50aWwgfSBmcm9tICdyeGpzL29wZXJhdG9ycyc7XG5pbXBvcnQgeyBTdWJqZWN0IH0gZnJvbSAncnhqcyc7XG5pbXBvcnQgeyBTdG9yZSB9IGZyb20gJ0BuZ3J4L3N0b3JlJztcblxuQERpcmVjdGl2ZSh7XG4gIHNlbGVjdG9yOiAnW2FjYU1lbnVQYW5lbF0nLFxuICBleHBvcnRBczogJ2FjYU1lbnVQYW5lbCdcbn0pXG5leHBvcnQgY2xhc3MgTWVudVBhbmVsRGlyZWN0aXZlIGltcGxlbWVudHMgT25Jbml0LCBPbkRlc3Ryb3kge1xuICBASW5wdXQoKSBhY2FNZW51UGFuZWw7XG4gIGhhc0FjdGl2ZUNoaWxkcmVuID0gZmFsc2U7XG5cbiAgcHJpdmF0ZSBvbkRlc3Ryb3kkOiBTdWJqZWN0PGJvb2xlYW4+ID0gbmV3IFN1YmplY3Q8Ym9vbGVhbj4oKTtcblxuICBASG9zdExpc3RlbmVyKCdtZW51T3BlbmVkJylcbiAgbWVudU9wZW5lZCgpIHtcbiAgICBpZiAodGhpcy5hY2FNZW51UGFuZWwuY2hpbGRyZW4gJiYgIXRoaXMuaGFzQWN0aXZlTGlua3MoKSkge1xuICAgICAgY29uc3QgZmlyc3RDaGlsZCA9IHRoaXMuYWNhTWVudVBhbmVsLmNoaWxkcmVuWzBdO1xuICAgICAgaWYgKGZpcnN0Q2hpbGQudXJsKSB7XG4gICAgICAgIHRoaXMucm91dGVyLm5hdmlnYXRlKHRoaXMuZ2V0TmF2aWdhdGlvbkNvbW1hbmRzKGZpcnN0Q2hpbGQudXJsKSk7XG4gICAgICB9IGVsc2Uge1xuICAgICAgICB0aGlzLnN0b3JlLmRpc3BhdGNoKHtcbiAgICAgICAgICB0eXBlOiBmaXJzdENoaWxkLmFjdGlvbi5hY3Rpb24sXG4gICAgICAgICAgcGF5bG9hZDogdGhpcy5nZXROYXZpZ2F0aW9uQ29tbWFuZHMoZmlyc3RDaGlsZC5hY3Rpb24ucGF5bG9hZClcbiAgICAgICAgfSk7XG4gICAgICB9XG4gICAgfVxuICB9XG5cbiAgY29uc3RydWN0b3IocHJpdmF0ZSBzdG9yZTogU3RvcmU8YW55PiwgcHJpdmF0ZSByb3V0ZXI6IFJvdXRlcikge31cblxuICBoYXNBY3RpdmVMaW5rcygpIHtcbiAgICBpZiAodGhpcy5hY2FNZW51UGFuZWwgJiYgdGhpcy5hY2FNZW51UGFuZWwuY2hpbGRyZW4pIHtcbiAgICAgIHJldHVybiB0aGlzLmFjYU1lbnVQYW5lbC5jaGlsZHJlbi5zb21lKChjaGlsZCkgPT4gdGhpcy5yb3V0ZXIudXJsLnN0YXJ0c1dpdGgoY2hpbGQudXJsIHx8IGNoaWxkLmFjdGlvbi5wYXlsb2FkKSk7XG4gICAgfVxuICAgIHJldHVybiBmYWxzZTtcbiAgfVxuXG4gIG5nT25Jbml0KCkge1xuICAgIHRoaXMuaGFzQWN0aXZlQ2hpbGRyZW4gPSB0aGlzLmhhc0FjdGl2ZUxpbmtzKCk7XG5cbiAgICB0aGlzLnJvdXRlci5ldmVudHNcbiAgICAgIC5waXBlKFxuICAgICAgICBmaWx0ZXIoKGV2ZW50KSA9PiBldmVudCBpbnN0YW5jZW9mIE5hdmlnYXRpb25FbmQpLFxuICAgICAgICB0YWtlVW50aWwodGhpcy5vbkRlc3Ryb3kkKVxuICAgICAgKVxuICAgICAgLnN1YnNjcmliZSgoKSA9PiB7XG4gICAgICAgIHRoaXMuaGFzQWN0aXZlQ2hpbGRyZW4gPSB0aGlzLmhhc0FjdGl2ZUxpbmtzKCk7XG4gICAgICB9KTtcbiAgfVxuXG4gIG5nT25EZXN0cm95KCkge1xuICAgIHRoaXMub25EZXN0cm95JC5uZXh0KHRydWUpO1xuICAgIHRoaXMub25EZXN0cm95JC5jb21wbGV0ZSgpO1xuICB9XG5cbiAgcHJpdmF0ZSBnZXROYXZpZ2F0aW9uQ29tbWFuZHModXJsOiBzdHJpbmcpOiBhbnlbXSB7XG4gICAgY29uc3QgdXJsVHJlZSA9IHRoaXMucm91dGVyLnBhcnNlVXJsKHVybCk7XG4gICAgY29uc3QgdXJsU2VnbWVudEdyb3VwID0gdXJsVHJlZS5yb290LmNoaWxkcmVuW1BSSU1BUllfT1VUTEVUXTtcblxuICAgIGlmICghdXJsU2VnbWVudEdyb3VwKSB7XG4gICAgICByZXR1cm4gW3VybF07XG4gICAgfVxuXG4gICAgY29uc3QgdXJsU2VnbWVudHMgPSB1cmxTZWdtZW50R3JvdXAuc2VnbWVudHM7XG5cbiAgICByZXR1cm4gdXJsU2VnbWVudHMucmVkdWNlKGZ1bmN0aW9uIChhY2MsIGl0ZW0pIHtcbiAgICAgIGFjYy5wdXNoKGl0ZW0ucGF0aCwgaXRlbS5wYXJhbWV0ZXJzKTtcbiAgICAgIHJldHVybiBhY2M7XG4gICAgfSwgW10pO1xuICB9XG59XG4iXX0=

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

@@ -0,0 +1,83 @@
+/*!
+ * Copyright © 2005-2023 Hyland Software, Inc. and its affiliates. All rights reserved.
+ *
+ * Alfresco Example Content Application
+ *
+ * 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
+ * from Hyland Software. 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, AppService } 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 "./components/expand-menu.component";
+import * as i7 from "./components/sidenav-header.component";
+export class SidenavComponent {
+    constructor(store, extensions, appService) {
+        this.store = store;
+        this.extensions = extensions;
+        this.appService = appService;
+        this.data = {};
+        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);
+        });
+        this.appService.appNavNarMode$.next(this.data.mode);
+        this.appService.toggleAppNavBar$.pipe(takeUntil(this.onDestroy$)).subscribe(() => this.toggleNavBar());
+    }
+    trackByGroupId(_, obj) {
+        return obj.id;
+    }
+    trackByLinkId(_, obj) {
+        return obj.id;
+    }
+    toggleClick() {
+        this.toggleNavBar();
+    }
+    toggleNavBar() {
+        this.data.layout.toggleMenu();
+        this.appService.appNavNarMode$.next(this.data.layout.isMenuMinimized ? 'collapsed' : 'expanded');
+    }
+    ngOnDestroy() {
+        this.onDestroy$.next(true);
+        this.onDestroy$.complete();
+    }
+}
+SidenavComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.1.3", ngImport: i0, type: SidenavComponent, deps: [{ token: i1.Store }, { token: i2.AppExtensionService }, { token: i2.AppService }], target: i0.ɵɵFactoryTarget.Component });
+SidenavComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "14.1.3", type: SidenavComponent, selector: "app-sidenav", inputs: { data: "data" }, host: { classAttribute: "app-sidenav" }, ngImport: i0, template: "<div class=\"sidenav\">\n    <app-sidenav-header (toggleNavBar)=\"toggleClick()\"></app-sidenav-header>\n\n    <div class=\"section-sub-actions\">\n      <div *ngFor=\"let group of groups; trackBy: trackByGroupId\" class=\"section\">\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            <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      </div>\n    </div>\n</div>\n", styles: [".sidenav{display:flex;flex:1;flex-direction:column;height:100%;overflow-y:hidden;background:var(--theme-sidenav-background-color)}.sidenav-header{padding:32px 0}.sidenav-header-title{display:flex;flex-direction:row;align-items:center;height:32px;padding:0 24px}.sidenav-header-title-logo img{cursor:pointer;height:28px;vertical-align:middle;transform:scale(.7)}.sidenav-header-title-text{flex:1;color:var(--theme-selected-text-color);padding-left:12px;letter-spacing:.25px;font-style:normal;font-weight:400;font-size:var(--theme-body-1-font-size);cursor:pointer}.sidenav .section:last-child{border-bottom:0}.sidenav .section-sub-actions{overflow-y:auto}.sidenav .section-sub-actions .mat-expansion-panel{width:100%;background-color:unset;box-shadow:none;border-radius:0}.sidenav .section-sub-actions .mat-expansion-panel-header{height:32px!important;padding:0 32px 0 0;display:flex;align-items:center;border:none}.sidenav .section-sub-actions .mat-expansion-panel-header-title{display:flex;flex-direction:row}.sidenav .section-sub-actions .mat-expansion-panel-header-title .mat-button{line-height:32px;align-items:center;border:none!important}.sidenav .section-sub-actions .mat-expansion-panel-header-title .action-button__label{font-size:var(--theme-caption-font-size)}.sidenav .section-sub-actions .mat-expansion-panel-body{padding:0 0 16px;font-size:var(--theme-body-1-font-size)}.sidenav .section-sub-actions .mat-expansion-panel-body .mat-button{line-height:32px;align-items:center}.sidenav .section-sub-actions .mat-expansion-panel-body .mat-button .mat-button-wrapper{display:flex}.sidenav .section-sub-actions .mat-expansion-panel .mat-expansion-indicator{display:flex;align-content:center}.sidenav .section-sub-actions .mat-expansion-panel .mat-expansion-indicator:after{transform:rotate(226deg)}.sidenav .section-sub-actions .mat-expansion-panel:not(.mat-expanded) .mat-expansion-panel-header:not([aria-disabled=true]):hover{background:none!important}.sidenav .section-sub-actions .item{flex-direction:row;display:flex;align-items:center;text-decoration:none;width:100%;-webkit-user-select:none;user-select:none}.sidenav .section-sub-actions .item:hover .action-button__label{color:var(--theme-selected-text-color)}.sidenav .section-sub-actions .action-button{color:var(--theme-action-button-text-color);height:32px;padding:0 24px;border-radius:0}.sidenav .section-sub-actions .full-width{display:flex;width:100%}.sidenav .section-sub-actions .action-button--active{color:var(--theme-selected-text-color)!important;background:var(--theme-selected-background-color)}\n"], dependencies: [{ kind: "directive", type: i3.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }, { kind: "directive", type: i3.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { 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.ExpandMenuComponent, selector: "app-expand-menu", inputs: ["item"] }, { kind: "component", type: i7.SidenavHeaderComponent, selector: "app-sidenav-header", outputs: ["toggleNavBar"] }], encapsulation: i0.ViewEncapsulation.None });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.1.3", ngImport: i0, type: SidenavComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'app-sidenav', encapsulation: ViewEncapsulation.None, host: { class: 'app-sidenav' }, template: "<div class=\"sidenav\">\n    <app-sidenav-header (toggleNavBar)=\"toggleClick()\"></app-sidenav-header>\n\n    <div class=\"section-sub-actions\">\n      <div *ngFor=\"let group of groups; trackBy: trackByGroupId\" class=\"section\">\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            <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      </div>\n    </div>\n</div>\n", styles: [".sidenav{display:flex;flex:1;flex-direction:column;height:100%;overflow-y:hidden;background:var(--theme-sidenav-background-color)}.sidenav-header{padding:32px 0}.sidenav-header-title{display:flex;flex-direction:row;align-items:center;height:32px;padding:0 24px}.sidenav-header-title-logo img{cursor:pointer;height:28px;vertical-align:middle;transform:scale(.7)}.sidenav-header-title-text{flex:1;color:var(--theme-selected-text-color);padding-left:12px;letter-spacing:.25px;font-style:normal;font-weight:400;font-size:var(--theme-body-1-font-size);cursor:pointer}.sidenav .section:last-child{border-bottom:0}.sidenav .section-sub-actions{overflow-y:auto}.sidenav .section-sub-actions .mat-expansion-panel{width:100%;background-color:unset;box-shadow:none;border-radius:0}.sidenav .section-sub-actions .mat-expansion-panel-header{height:32px!important;padding:0 32px 0 0;display:flex;align-items:center;border:none}.sidenav .section-sub-actions .mat-expansion-panel-header-title{display:flex;flex-direction:row}.sidenav .section-sub-actions .mat-expansion-panel-header-title .mat-button{line-height:32px;align-items:center;border:none!important}.sidenav .section-sub-actions .mat-expansion-panel-header-title .action-button__label{font-size:var(--theme-caption-font-size)}.sidenav .section-sub-actions .mat-expansion-panel-body{padding:0 0 16px;font-size:var(--theme-body-1-font-size)}.sidenav .section-sub-actions .mat-expansion-panel-body .mat-button{line-height:32px;align-items:center}.sidenav .section-sub-actions .mat-expansion-panel-body .mat-button .mat-button-wrapper{display:flex}.sidenav .section-sub-actions .mat-expansion-panel .mat-expansion-indicator{display:flex;align-content:center}.sidenav .section-sub-actions .mat-expansion-panel .mat-expansion-indicator:after{transform:rotate(226deg)}.sidenav .section-sub-actions .mat-expansion-panel:not(.mat-expanded) .mat-expansion-panel-header:not([aria-disabled=true]):hover{background:none!important}.sidenav .section-sub-actions .item{flex-direction:row;display:flex;align-items:center;text-decoration:none;width:100%;-webkit-user-select:none;user-select:none}.sidenav .section-sub-actions .item:hover .action-button__label{color:var(--theme-selected-text-color)}.sidenav .section-sub-actions .action-button{color:var(--theme-action-button-text-color);height:32px;padding:0 24px;border-radius:0}.sidenav .section-sub-actions .full-width{display:flex;width:100%}.sidenav .section-sub-actions .action-button--active{color:var(--theme-selected-text-color)!important;background:var(--theme-selected-background-color)}\n"] }]
+        }], ctorParameters: function () { return [{ type: i1.Store }, { type: i2.AppExtensionService }, { type: i2.AppService }]; }, propDecorators: { data: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"sidenav.component.js","sourceRoot":"","sources":["../../../../../../../projects/aca-content/src/lib/components/sidenav/sidenav.component.ts","../../../../../../../projects/aca-content/src/lib/components/sidenav/sidenav.component.html"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAEH,OAAO,EAAE,SAAS,EAAE,KAAK,EAAU,iBAAiB,EAAa,MAAM,eAAe,CAAC;AAEvF,OAAO,EAAE,KAAK,EAAE,MAAM,aAAa,CAAC;AACpC,OAAO,EAAY,eAAe,EAAE,MAAM,4BAA4B,CAAC;AACvE,OAAO,EAAE,OAAO,EAAE,MAAM,MAAM,CAAC;AAC/B,OAAO,EAAE,SAAS,EAAE,oBAAoB,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAC/E,OAAO,EAAE,mBAAmB,EAAE,UAAU,EAAE,MAAM,sBAAsB,CAAC;;;;;;;;;AAUvE,MAAM,OAAO,gBAAgB;IAU3B,YAAoB,KAAsB,EAAU,UAA+B,EAAU,UAAsB;QAA/F,UAAK,GAAL,KAAK,CAAiB;QAAU,eAAU,GAAV,UAAU,CAAqB;QAAU,eAAU,GAAV,UAAU,CAAY;QARnH,SAAI,GAGA,EAAE,CAAC;QAEP,WAAM,GAA0B,EAAE,CAAC;QAC3B,eAAU,GAAG,IAAI,OAAO,EAAW,CAAC;IAE0E,CAAC;IAEvH,QAAQ;QACN,IAAI,CAAC,KAAK;aACP,MAAM,CAAC,eAAe,CAAC;aACvB,IAAI,CAAC,YAAY,CAAC,GAAG,CAAC,EAAE,oBAAoB,EAAE,EAAE,SAAS,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC;aAC3E,SAAS,CAAC,GAAG,EAAE;YACd,IAAI,CAAC,MAAM,GAAG,IAAI,CAAC,UAAU,CAAC,wBAAwB,CAAC,IAAI,CAAC,UAAU,CAAC,MAAM,CAAC,CAAC;QACjF,CAAC,CAAC,CAAC;QAEL,IAAI,CAAC,UAAU,CAAC,cAAc,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QACpD,IAAI,CAAC,UAAU,CAAC,gBAAgB,CAAC,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC,CAAC,SAAS,CAAC,GAAG,EAAE,CAAC,IAAI,CAAC,YAAY,EAAE,CAAC,CAAC;IACzG,CAAC;IAED,cAAc,CAAC,CAAS,EAAE,GAAmB;QAC3C,OAAO,GAAG,CAAC,EAAE,CAAC;IAChB,CAAC;IAED,aAAa,CAAC,CAAS,EAAE,GAAkB;QACzC,OAAO,GAAG,CAAC,EAAE,CAAC;IAChB,CAAC;IAED,WAAW;QACT,IAAI,CAAC,YAAY,EAAE,CAAC;IACtB,CAAC;IAEO,YAAY;QAClB,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,UAAU,EAAE,CAAC;QAC9B,IAAI,CAAC,UAAU,CAAC,cAAc,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,eAAe,CAAC,CAAC,CAAC,WAAW,CAAC,CAAC,CAAC,UAAU,CAAC,CAAC;IACnG,CAAC;IAED,WAAW;QACT,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QAC3B,IAAI,CAAC,UAAU,CAAC,QAAQ,EAAE,CAAC;IAC7B,CAAC;;6GA5CU,gBAAgB;iGAAhB,gBAAgB,sHCxC7B,6uBAgBA;2FDwBa,gBAAgB;kBAP5B,SAAS;+BACE,aAAa,iBAGR,iBAAiB,CAAC,IAAI,QAC/B,EAAE,KAAK,EAAE,aAAa,EAAE;uJAI9B,IAAI;sBADH,KAAK","sourcesContent":["/*!\n * Copyright © 2005-2023 Hyland Software, Inc. and its affiliates. All rights reserved.\n *\n * Alfresco Example Content Application\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 * from Hyland Software. If not, see <http://www.gnu.org/licenses/>.\n */\n\nimport { Component, Input, OnInit, ViewEncapsulation, OnDestroy } from '@angular/core';\nimport { NavBarGroupRef, NavBarLinkRef } from '@alfresco/adf-extensions';\nimport { Store } from '@ngrx/store';\nimport { AppStore, getSideNavState } from '@alfresco/aca-shared/store';\nimport { Subject } from 'rxjs';\nimport { takeUntil, distinctUntilChanged, debounceTime } from 'rxjs/operators';\nimport { AppExtensionService, AppService } from '@alfresco/aca-shared';\nimport { SidenavLayoutComponent } from '@alfresco/adf-core';\n\n@Component({\n  selector: 'app-sidenav',\n  templateUrl: './sidenav.component.html',\n  styleUrls: ['./sidenav.component.scss'],\n  encapsulation: ViewEncapsulation.None,\n  host: { class: 'app-sidenav' }\n})\nexport class SidenavComponent implements OnInit, OnDestroy {\n  @Input()\n  data: {\n    layout?: SidenavLayoutComponent;\n    mode?: 'collapsed' | 'expanded';\n  } = {};\n\n  groups: Array<NavBarGroupRef> = [];\n  private onDestroy$ = new Subject<boolean>();\n\n  constructor(private store: Store<AppStore>, private extensions: AppExtensionService, private appService: AppService) {}\n\n  ngOnInit() {\n    this.store\n      .select(getSideNavState)\n      .pipe(debounceTime(300), distinctUntilChanged(), takeUntil(this.onDestroy$))\n      .subscribe(() => {\n        this.groups = this.extensions.getApplicationNavigation(this.extensions.navbar);\n      });\n\n    this.appService.appNavNarMode$.next(this.data.mode);\n    this.appService.toggleAppNavBar$.pipe(takeUntil(this.onDestroy$)).subscribe(() => this.toggleNavBar());\n  }\n\n  trackByGroupId(_: number, obj: NavBarGroupRef): string {\n    return obj.id;\n  }\n\n  trackByLinkId(_: number, obj: NavBarLinkRef): string {\n    return obj.id;\n  }\n\n  toggleClick() {\n    this.toggleNavBar();\n  }\n\n  private toggleNavBar() {\n    this.data.layout.toggleMenu();\n    this.appService.appNavNarMode$.next(this.data.layout.isMenuMinimized ? 'collapsed' : 'expanded');\n  }\n\n  ngOnDestroy() {\n    this.onDestroy$.next(true);\n    this.onDestroy$.complete();\n  }\n}\n","<div class=\"sidenav\">\n    <app-sidenav-header (toggleNavBar)=\"toggleClick()\"></app-sidenav-header>\n\n    <div class=\"section-sub-actions\">\n      <div *ngFor=\"let group of groups; trackBy: trackByGroupId\" class=\"section\">\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            <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      </div>\n    </div>\n</div>\n"]}

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

@@ -0,0 +1,84 @@
+/*!
+ * Copyright © 2005-2023 Hyland Software, Inc. and its affiliates. All rights reserved.
+ *
+ * Alfresco Example Content Application
+ *
+ * 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
+ * from Hyland Software. If not, see <http://www.gnu.org/licenses/>.
+ */
+import { NgModule } from '@angular/core';
+import { AppCreateMenuModule } from '../create-menu/create-menu.module';
+import { CoreModule } from '@alfresco/adf-core';
+import { RouterModule } from '@angular/router';
+import { ExtensionsModule } from '@alfresco/adf-extensions';
+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 { SidenavHeaderComponent } from './components/sidenav-header.component';
+import { SharedToolbarModule } from '@alfresco/aca-shared';
+import * as i0 from "@angular/core";
+import * as i1 from "@alfresco/adf-core";
+import * as i2 from "@alfresco/adf-extensions";
+export class AppSidenavModule {
+}
+AppSidenavModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.1.3", ngImport: i0, type: AppSidenavModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+AppSidenavModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "14.1.3", ngImport: i0, type: AppSidenavModule, declarations: [MenuPanelDirective,
+        ExpansionPanelDirective,
+        ActiveLinkDirective,
+        ActionDirective,
+        ExpandMenuComponent,
+        ButtonMenuComponent,
+        SidenavComponent,
+        SidenavHeaderComponent], imports: [i1.CoreModule, i2.ExtensionsModule, RouterModule, AppCreateMenuModule, SharedToolbarModule], exports: [MenuPanelDirective,
+        ExpansionPanelDirective,
+        ActiveLinkDirective,
+        ActionDirective,
+        ExpandMenuComponent,
+        ButtonMenuComponent,
+        SidenavComponent] });
+AppSidenavModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "14.1.3", ngImport: i0, type: AppSidenavModule, imports: [CoreModule.forChild(), ExtensionsModule.forChild(), RouterModule, AppCreateMenuModule, SharedToolbarModule] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.1.3", ngImport: i0, type: AppSidenavModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [CoreModule.forChild(), ExtensionsModule.forChild(), RouterModule, AppCreateMenuModule, SharedToolbarModule],
+                    declarations: [
+                        MenuPanelDirective,
+                        ExpansionPanelDirective,
+                        ActiveLinkDirective,
+                        ActionDirective,
+                        ExpandMenuComponent,
+                        ButtonMenuComponent,
+                        SidenavComponent,
+                        SidenavHeaderComponent
+                    ],
+                    exports: [
+                        MenuPanelDirective,
+                        ExpansionPanelDirective,
+                        ActiveLinkDirective,
+                        ActionDirective,
+                        ExpandMenuComponent,
+                        ButtonMenuComponent,
+                        SidenavComponent
+                    ]
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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