@theseam/ui-common 0.3.12 → 0.3.13-beta.1

package/esm2015/framework/nav/nav-utils.js

@@ -0,0 +1,110 @@
+import { hasProperty, isNullOrUndefined } from '@theseam/ui-common/utils';
+export function isHorizontalNavItemType(item, type) {
+    return item.itemType === type;
+}
+export function isHorizontalNavItemActive(item) {
+    var _a, _b;
+    return (_b = (_a = item.__state) === null || _a === void 0 ? void 0 : _a.active) !== null && _b !== void 0 ? _b : false;
+}
+export function isHorizontalNavItemExpanded(item) {
+    var _a, _b;
+    return (_b = (_a = item.__state) === null || _a === void 0 ? void 0 : _a.expanded) !== null && _b !== void 0 ? _b : false;
+}
+export function isHorizontalNavItemFocused(item) {
+    var _a, _b;
+    return (_b = (_a = item.__state) === null || _a === void 0 ? void 0 : _a.focused) !== null && _b !== void 0 ? _b : false;
+}
+export function horizontalNavItemHasChildren(item) {
+    return horizontalNavItemCanHaveChildren(item) && hasProperty(item, 'children') && item.children.length > 0;
+}
+export function horizontalNavItemCanHaveChildren(item) {
+    return isHorizontalNavItemType(item, 'basic') || isHorizontalNavItemType(item, 'link');
+}
+export function horizontalNavItemHasActiveChild(item) {
+    if (!horizontalNavItemHasChildren(item)) {
+        return false;
+    }
+    for (const child of item.children) {
+        if (getHorizontalNavItemStateProp(child, 'active') || horizontalNavItemHasActiveChild(child)) {
+            return true;
+        }
+    }
+    return false;
+}
+export function horizontalNavItemHasExpandedChild(item) {
+    if (!horizontalNavItemHasChildren(item)) {
+        return false;
+    }
+    for (const child of item.children) {
+        if (getHorizontalNavItemStateProp(child, 'expanded')) {
+            return true;
+        }
+    }
+    return false;
+}
+export function horizontalNavItemCanBeActive(item) {
+    return isHorizontalNavItemType(item, 'basic') || isHorizontalNavItemType(item, 'link');
+}
+export function horizontalNavItemCanExpand(item) {
+    return horizontalNavItemCanHaveChildren(item);
+}
+export function findHorizontalNavLinkItems(items) {
+    const linkItems = [];
+    const _fn = (_items) => {
+        for (const item of _items) {
+            if (isHorizontalNavItemType(item, 'link')) {
+                linkItems.push(item);
+            }
+            if (horizontalNavItemCanHaveChildren(item) && hasProperty(item, 'children')) {
+                _fn(item.children);
+            }
+        }
+    };
+    _fn(items);
+    return linkItems;
+}
+export function setHorizontalNavItemStateProp(item, prop, value) {
+    if (hasProperty(item, '__state')) {
+        item.__state[prop] = value;
+    }
+}
+export function getHorizontalNavItemStateProp(item, prop) {
+    return setDefaultHorizontalNavItemState(item).__state[prop];
+}
+export function setDefaultHorizontalNavItemState(item) {
+    if (hasProperty(item, '__state')) {
+        return item;
+    }
+    item.__state = {
+        active: false,
+        expanded: false,
+        focused: false
+    };
+    // TODO: See if there is a nice way to fix the typing for this.
+    return item;
+}
+export function areSameHorizontalNavItem(item1, item2) {
+    if (isNullOrUndefined(item1) || isNullOrUndefined(item2)) {
+        return false;
+    }
+    if (item1.itemType !== item2.itemType) {
+        return false;
+    }
+    if (isHorizontalNavItemType(item1, 'title') && isHorizontalNavItemType(item2, 'title')) {
+        return item1.label === item2.label;
+    }
+    else if (isHorizontalNavItemType(item1, 'divider') && isHorizontalNavItemType(item2, 'divider')) {
+        return item1.label === item2.label;
+    }
+    else if (isHorizontalNavItemType(item1, 'basic') && isHorizontalNavItemType(item2, 'basic')) {
+        return item1.label === item2.label;
+    }
+    else if (isHorizontalNavItemType(item1, 'link') && isHorizontalNavItemType(item2, 'link')) {
+        return item1.label === item2.label && item1.link === item2.link;
+    }
+    else if (isHorizontalNavItemType(item1, 'button') && isHorizontalNavItemType(item2, 'button')) {
+        return item1.onClick === item2.onClick;
+    }
+    return false;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"nav-utils.js","sourceRoot":"","sources":["../../../../../projects/ui-common/framework/nav/nav-utils.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,iBAAiB,EAAE,MAAM,0BAA0B,CAAA;AAmBzE,MAAM,UAAU,uBAAuB,CAAC,IAAc,EAAE,IAAY;IAClE,OAAO,IAAI,CAAC,QAAQ,KAAK,IAAI,CAAA;AAC/B,CAAC;AAED,MAAM,UAAU,yBAAyB,CAAC,IAAc;;IACtD,OAAO,MAAA,MAAA,IAAI,CAAC,OAAO,0CAAE,MAAM,mCAAI,KAAK,CAAA;AACtC,CAAC;AAED,MAAM,UAAU,2BAA2B,CAAC,IAAc;;IACxD,OAAO,MAAA,MAAA,IAAI,CAAC,OAAO,0CAAE,QAAQ,mCAAI,KAAK,CAAA;AACxC,CAAC;AAED,MAAM,UAAU,0BAA0B,CAAC,IAAc;;IACvD,OAAO,MAAA,MAAA,IAAI,CAAC,OAAO,0CAAE,OAAO,mCAAI,KAAK,CAAA;AACvC,CAAC;AAED,MAAM,UAAU,4BAA4B,CAAC,IAAc;IACzD,OAAO,gCAAgC,CAAC,IAAI,CAAC,IAAI,WAAW,CAAC,IAAI,EAAE,UAAU,CAAC,IAAI,IAAI,CAAC,QAAQ,CAAC,MAAM,GAAG,CAAC,CAAA;AAC5G,CAAC;AAED,MAAM,UAAU,gCAAgC,CAAC,IAAc;IAC7D,OAAO,uBAAuB,CAAC,IAAI,EAAE,OAAO,CAAC,IAAI,uBAAuB,CAAC,IAAI,EAAE,MAAM,CAAC,CAAA;AACxF,CAAC;AAED,MAAM,UAAU,+BAA+B,CAAC,IAAc;IAC5D,IAAI,CAAC,4BAA4B,CAAC,IAAI,CAAC,EAAE;QACvC,OAAO,KAAK,CAAA;KACb;IAED,KAAK,MAAM,KAAK,IAAI,IAAI,CAAC,QAAQ,EAAE;QACjC,IAAI,6BAA6B,CAAC,KAAK,EAAE,QAAQ,CAAC,IAAI,+BAA+B,CAAC,KAAK,CAAC,EAAE;YAC5F,OAAO,IAAI,CAAA;SACZ;KACF;IAED,OAAO,KAAK,CAAA;AACd,CAAC;AAED,MAAM,UAAU,iCAAiC,CAAC,IAAc;IAC9D,IAAI,CAAC,4BAA4B,CAAC,IAAI,CAAC,EAAE;QACvC,OAAO,KAAK,CAAA;KACb;IAED,KAAK,MAAM,KAAK,IAAI,IAAI,CAAC,QAAQ,EAAE;QACjC,IAAI,6BAA6B,CAAC,KAAK,EAAE,UAAU,CAAC,EAAE;YACpD,OAAO,IAAI,CAAA;SACZ;KACF;IAED,OAAO,KAAK,CAAA;AACd,CAAC;AAED,MAAM,UAAU,4BAA4B,CAAC,IAAc;IACzD,OAAO,uBAAuB,CAAC,IAAI,EAAE,OAAO,CAAC,IAAI,uBAAuB,CAAC,IAAI,EAAE,MAAM,CAAC,CAAA;AACxF,CAAC;AAED,MAAM,UAAU,0BAA0B,CAAC,IAAc;IACvD,OAAO,gCAAgC,CAAC,IAAI,CAAC,CAAA;AAC/C,CAAC;AAED,MAAM,UAAU,0BAA0B,CAAC,KAAiB;IAC1D,MAAM,SAAS,GAAe,EAAE,CAAA;IAEhC,MAAM,GAAG,GAAG,CAAC,MAAkB,EAAE,EAAE;QACjC,KAAK,MAAM,IAAI,IAAI,MAAM,EAAE;YACzB,IAAI,uBAAuB,CAAC,IAAI,EAAE,MAAM,CAAC,EAAE;gBACzC,SAAS,CAAC,IAAI,CAAC,IAAI,CAAC,CAAA;aACrB;YACD,IAAI,gCAAgC,CAAC,IAAI,CAAC,IAAI,WAAW,CAAC,IAAI,EAAE,UAAU,CAAC,EAAE;gBAC3E,GAAG,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAA;aACnB;SACF;IACH,CAAC,CAAA;IACD,GAAG,CAAC,KAAK,CAAC,CAAA;IAEV,OAAO,SAAS,CAAA;AAClB,CAAC;AAED,MAAM,UAAU,6BAA6B,CAAgC,IAAc,EAAE,IAAO,EAAE,KAAuB;IAC3H,IAAI,WAAW,CAAC,IAAI,EAAE,SAAS,CAAC,EAAE;QAChC,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,GAAG,KAAK,CAAA;KAC3B;AACH,CAAC;AAED,MAAM,UAAU,6BAA6B,CAAgC,IAAc,EAAE,IAAO;IAClG,OAAO,gCAAgC,CAAC,IAAI,CAAC,CAAC,OAAO,CAAC,IAAI,CAAC,CAAA;AAC7D,CAAC;AAED,MAAM,UAAU,gCAAgC,CAAC,IAAc;IAC7D,IAAI,WAAW,CAAC,IAAI,EAAE,SAAS,CAAC,EAAE;QAChC,OAAO,IAAI,CAAA;KACZ;IAED,IAAI,CAAC,OAAO,GAAG;QACb,MAAM,EAAE,KAAK;QACb,QAAQ,EAAE,KAAK;QACf,OAAO,EAAE,KAAK;KACE,CAAA;IAElB,+DAA+D;IAC/D,OAAO,IAAW,CAAA;AACpB,CAAC;AAED,MAAM,UAAU,wBAAwB,CAAC,KAA2B,EAAE,KAA2B;IAC/F,IAAI,iBAAiB,CAAC,KAAK,CAAC,IAAI,iBAAiB,CAAC,KAAK,CAAC,EAAE;QACxD,OAAO,KAAK,CAAA;KACb;IAED,IAAI,KAAK,CAAC,QAAQ,KAAK,KAAK,CAAC,QAAQ,EAAE;QACrC,OAAO,KAAK,CAAA;KACb;IAED,IAAI,uBAAuB,CAAC,KAAK,EAAE,OAAO,CAAC,IAAI,uBAAuB,CAAC,KAAK,EAAE,OAAO,CAAC,EAAE;QACtF,OAAO,KAAK,CAAC,KAAK,KAAK,KAAK,CAAC,KAAK,CAAA;KACnC;SAAM,IAAI,uBAAuB,CAAC,KAAK,EAAE,SAAS,CAAC,IAAI,uBAAuB,CAAC,KAAK,EAAE,SAAS,CAAC,EAAE;QACjG,OAAO,KAAK,CAAC,KAAK,KAAK,KAAK,CAAC,KAAK,CAAA;KACnC;SAAM,IAAI,uBAAuB,CAAC,KAAK,EAAE,OAAO,CAAC,IAAI,uBAAuB,CAAC,KAAK,EAAE,OAAO,CAAC,EAAE;QAC7F,OAAO,KAAK,CAAC,KAAK,KAAK,KAAK,CAAC,KAAK,CAAA;KACnC;SAAM,IAAI,uBAAuB,CAAC,KAAK,EAAE,MAAM,CAAC,IAAI,uBAAuB,CAAC,KAAK,EAAE,MAAM,CAAC,EAAE;QAC3F,OAAO,KAAK,CAAC,KAAK,KAAK,KAAK,CAAC,KAAK,IAAI,KAAK,CAAC,IAAI,KAAK,KAAK,CAAC,IAAI,CAAA;KAChE;SAAM,IAAI,uBAAuB,CAAC,KAAK,EAAE,QAAQ,CAAC,IAAI,uBAAuB,CAAC,KAAK,EAAE,QAAQ,CAAC,EAAE;QAC/F,OAAO,KAAK,CAAC,OAAO,KAAK,KAAK,CAAC,OAAO,CAAA;KACvC;IAED,OAAO,KAAK,CAAA;AACd,CAAC","sourcesContent":["import { hasProperty, isNullOrUndefined } from '@theseam/ui-common/utils'\n\nimport {\n  INavBasic,\n  INavButton,\n  INavDivider,\n  INavItem,\n  INavItemState,\n  INavLink,\n  INavTitle,\n  NavItemCanHaveChildren,\n  NavItemCanHaveState\n} from './nav.models'\n\nexport function isHorizontalNavItemType(item: INavItem, type: 'title'): item is INavTitle\nexport function isHorizontalNavItemType(item: INavItem, type: 'divider'): item is INavDivider\nexport function isHorizontalNavItemType(item: INavItem, type: 'basic'): item is INavBasic\nexport function isHorizontalNavItemType(item: INavItem, type: 'link'): item is INavLink\nexport function isHorizontalNavItemType(item: INavItem, type: 'button'): item is INavButton\nexport function isHorizontalNavItemType(item: INavItem, type: string): item is INavItem {\n  return item.itemType === type\n}\n\nexport function isHorizontalNavItemActive(item: INavItem): boolean {\n  return item.__state?.active ?? false\n}\n\nexport function isHorizontalNavItemExpanded(item: INavItem): boolean {\n  return item.__state?.expanded ?? false\n}\n\nexport function isHorizontalNavItemFocused(item: INavItem): boolean {\n  return item.__state?.focused ?? false\n}\n\nexport function horizontalNavItemHasChildren(item: INavItem): item is (INavBasic | INavLink) & Required<NavItemCanHaveChildren> {\n  return horizontalNavItemCanHaveChildren(item) && hasProperty(item, 'children') && item.children.length > 0\n}\n\nexport function horizontalNavItemCanHaveChildren(item: INavItem): item is (INavBasic | INavLink) {\n  return isHorizontalNavItemType(item, 'basic') || isHorizontalNavItemType(item, 'link')\n}\n\nexport function horizontalNavItemHasActiveChild(item: INavItem): boolean {\n  if (!horizontalNavItemHasChildren(item)) {\n    return false\n  }\n\n  for (const child of item.children) {\n    if (getHorizontalNavItemStateProp(child, 'active') || horizontalNavItemHasActiveChild(child)) {\n      return true\n    }\n  }\n\n  return false\n}\n\nexport function horizontalNavItemHasExpandedChild(item: INavItem): boolean {\n  if (!horizontalNavItemHasChildren(item)) {\n    return false\n  }\n\n  for (const child of item.children) {\n    if (getHorizontalNavItemStateProp(child, 'expanded')) {\n      return true\n    }\n  }\n\n  return false\n}\n\nexport function horizontalNavItemCanBeActive(item: INavItem): item is (INavBasic | INavLink) {\n  return isHorizontalNavItemType(item, 'basic') || isHorizontalNavItemType(item, 'link')\n}\n\nexport function horizontalNavItemCanExpand(item: INavItem): item is (INavBasic | INavLink) {\n  return horizontalNavItemCanHaveChildren(item)\n}\n\nexport function findHorizontalNavLinkItems(items: INavItem[]): INavLink[] {\n  const linkItems: INavLink[] = []\n\n  const _fn = (_items: INavItem[]) => {\n    for (const item of _items) {\n      if (isHorizontalNavItemType(item, 'link')) {\n        linkItems.push(item)\n      }\n      if (horizontalNavItemCanHaveChildren(item) && hasProperty(item, 'children')) {\n        _fn(item.children)\n      }\n    }\n  }\n  _fn(items)\n\n  return linkItems\n}\n\nexport function setHorizontalNavItemStateProp<K extends keyof INavItemState>(item: INavItem, prop: K, value: INavItemState[K]): void {\n  if (hasProperty(item, '__state')) {\n    item.__state[prop] = value\n  }\n}\n\nexport function getHorizontalNavItemStateProp<K extends keyof INavItemState>(item: INavItem, prop: K): INavItemState[K] {\n  return setDefaultHorizontalNavItemState(item).__state[prop]\n}\n\nexport function setDefaultHorizontalNavItemState(item: INavItem): INavItem & Required<NavItemCanHaveState> {\n  if (hasProperty(item, '__state')) {\n    return item\n  }\n\n  item.__state = {\n    active: false,\n    expanded: false,\n    focused: false\n  } as INavItemState\n\n  // TODO: See if there is a nice way to fix the typing for this.\n  return item as any\n}\n\nexport function areSameHorizontalNavItem(item1: INavItem | undefined, item2: INavItem | undefined): boolean {\n  if (isNullOrUndefined(item1) || isNullOrUndefined(item2)) {\n    return false\n  }\n\n  if (item1.itemType !== item2.itemType) {\n    return false\n  }\n\n  if (isHorizontalNavItemType(item1, 'title') && isHorizontalNavItemType(item2, 'title')) {\n    return item1.label === item2.label\n  } else if (isHorizontalNavItemType(item1, 'divider') && isHorizontalNavItemType(item2, 'divider')) {\n    return item1.label === item2.label\n  } else if (isHorizontalNavItemType(item1, 'basic') && isHorizontalNavItemType(item2, 'basic')) {\n    return item1.label === item2.label\n  } else if (isHorizontalNavItemType(item1, 'link') && isHorizontalNavItemType(item2, 'link')) {\n    return item1.label === item2.label && item1.link === item2.link\n  } else if (isHorizontalNavItemType(item1, 'button') && isHorizontalNavItemType(item2, 'button')) {\n    return item1.onClick === item2.onClick\n  }\n\n  return false\n}\n"]}

package/esm2015/framework/nav/nav.models.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/framework/nav/nav.module.js

@@ -0,0 +1,42 @@
+import { A11yModule } from '@angular/cdk/a11y';
+import { PortalModule } from '@angular/cdk/portal';
+import { CommonModule } from '@angular/common';
+import { NgModule } from '@angular/core';
+import { RouterModule } from '@angular/router';
+import { NgbTooltipModule } from '@ng-bootstrap/ng-bootstrap';
+import { TheSeamIconModule } from '@theseam/ui-common/icon';
+import { TheSeamLayoutModule } from '@theseam/ui-common/layout';
+import { TheSeamMenuModule } from '@theseam/ui-common/menu';
+import { TheSeamScrollbarModule } from '@theseam/ui-common/scrollbar';
+import { HorizontalNavComponent } from './horizontal-nav/horizontal-nav.component';
+import { NavItemComponent } from './nav-item/nav-item.component';
+import { TheSeamNavService } from './nav.service';
+export class TheSeamNavModule {
+}
+TheSeamNavModule.decorators = [
+    { type: NgModule, args: [{
+                declarations: [
+                    NavItemComponent,
+                    HorizontalNavComponent,
+                ],
+                imports: [
+                    CommonModule,
+                    RouterModule,
+                    TheSeamIconModule,
+                    A11yModule,
+                    TheSeamScrollbarModule,
+                    TheSeamLayoutModule,
+                    NgbTooltipModule,
+                    PortalModule,
+                    TheSeamMenuModule
+                ],
+                exports: [
+                    NavItemComponent,
+                    HorizontalNavComponent,
+                ],
+                providers: [
+                    TheSeamNavService,
+                ]
+            },] }
+];
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibmF2Lm1vZHVsZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL3VpLWNvbW1vbi9mcmFtZXdvcmsvbmF2L25hdi5tb2R1bGUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFVBQVUsRUFBRSxNQUFNLG1CQUFtQixDQUFBO0FBQzlDLE9BQU8sRUFBRSxZQUFZLEVBQUUsTUFBTSxxQkFBcUIsQ0FBQTtBQUNsRCxPQUFPLEVBQUUsWUFBWSxFQUFFLE1BQU0saUJBQWlCLENBQUE7QUFDOUMsT0FBTyxFQUFFLFFBQVEsRUFBRSxNQUFNLGVBQWUsQ0FBQTtBQUN4QyxPQUFPLEVBQUUsWUFBWSxFQUFFLE1BQU0saUJBQWlCLENBQUE7QUFFOUMsT0FBTyxFQUFFLGdCQUFnQixFQUFFLE1BQU0sNEJBQTRCLENBQUE7QUFFN0QsT0FBTyxFQUFFLGlCQUFpQixFQUFFLE1BQU0seUJBQXlCLENBQUE7QUFDM0QsT0FBTyxFQUFFLG1CQUFtQixFQUFFLE1BQU0sMkJBQTJCLENBQUE7QUFDL0QsT0FBTyxFQUFFLGlCQUFpQixFQUFFLE1BQU0seUJBQXlCLENBQUE7QUFDM0QsT0FBTyxFQUFFLHNCQUFzQixFQUFFLE1BQU0sOEJBQThCLENBQUE7QUFDckUsT0FBTyxFQUFFLHNCQUFzQixFQUFFLE1BQU0sMkNBQTJDLENBQUE7QUFFbEYsT0FBTyxFQUFFLGdCQUFnQixFQUFFLE1BQU0sK0JBQStCLENBQUE7QUFDaEUsT0FBTyxFQUFFLGlCQUFpQixFQUFFLE1BQU0sZUFBZSxDQUFBO0FBMEJqRCxNQUFNLE9BQU8sZ0JBQWdCOzs7WUF4QjVCLFFBQVEsU0FBQztnQkFDUixZQUFZLEVBQUU7b0JBQ1osZ0JBQWdCO29CQUNoQixzQkFBc0I7aUJBQ3ZCO2dCQUNELE9BQU8sRUFBRTtvQkFDUCxZQUFZO29CQUNaLFlBQVk7b0JBQ1osaUJBQWlCO29CQUNqQixVQUFVO29CQUNWLHNCQUFzQjtvQkFDdEIsbUJBQW1CO29CQUNuQixnQkFBZ0I7b0JBQ2hCLFlBQVk7b0JBQ1osaUJBQWlCO2lCQUNsQjtnQkFDRCxPQUFPLEVBQUU7b0JBQ1AsZ0JBQWdCO29CQUNoQixzQkFBc0I7aUJBQ3ZCO2dCQUNELFNBQVMsRUFBRTtvQkFDVCxpQkFBaUI7aUJBQ2xCO2FBQ0YiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBBMTF5TW9kdWxlIH0gZnJvbSAnQGFuZ3VsYXIvY2RrL2ExMXknXG5pbXBvcnQgeyBQb3J0YWxNb2R1bGUgfSBmcm9tICdAYW5ndWxhci9jZGsvcG9ydGFsJ1xuaW1wb3J0IHsgQ29tbW9uTW9kdWxlIH0gZnJvbSAnQGFuZ3VsYXIvY29tbW9uJ1xuaW1wb3J0IHsgTmdNb2R1bGUgfSBmcm9tICdAYW5ndWxhci9jb3JlJ1xuaW1wb3J0IHsgUm91dGVyTW9kdWxlIH0gZnJvbSAnQGFuZ3VsYXIvcm91dGVyJ1xuXG5pbXBvcnQgeyBOZ2JUb29sdGlwTW9kdWxlIH0gZnJvbSAnQG5nLWJvb3RzdHJhcC9uZy1ib290c3RyYXAnXG5cbmltcG9ydCB7IFRoZVNlYW1JY29uTW9kdWxlIH0gZnJvbSAnQHRoZXNlYW0vdWktY29tbW9uL2ljb24nXG5pbXBvcnQgeyBUaGVTZWFtTGF5b3V0TW9kdWxlIH0gZnJvbSAnQHRoZXNlYW0vdWktY29tbW9uL2xheW91dCdcbmltcG9ydCB7IFRoZVNlYW1NZW51TW9kdWxlIH0gZnJvbSAnQHRoZXNlYW0vdWktY29tbW9uL21lbnUnXG5pbXBvcnQgeyBUaGVTZWFtU2Nyb2xsYmFyTW9kdWxlIH0gZnJvbSAnQHRoZXNlYW0vdWktY29tbW9uL3Njcm9sbGJhcidcbmltcG9ydCB7IEhvcml6b250YWxOYXZDb21wb25lbnQgfSBmcm9tICcuL2hvcml6b250YWwtbmF2L2hvcml6b250YWwtbmF2LmNvbXBvbmVudCdcblxuaW1wb3J0IHsgTmF2SXRlbUNvbXBvbmVudCB9IGZyb20gJy4vbmF2LWl0ZW0vbmF2LWl0ZW0uY29tcG9uZW50J1xuaW1wb3J0IHsgVGhlU2VhbU5hdlNlcnZpY2UgfSBmcm9tICcuL25hdi5zZXJ2aWNlJ1xuXG5ATmdNb2R1bGUoe1xuICBkZWNsYXJhdGlvbnM6IFtcbiAgICBOYXZJdGVtQ29tcG9uZW50LFxuICAgIEhvcml6b250YWxOYXZDb21wb25lbnQsXG4gIF0sXG4gIGltcG9ydHM6IFtcbiAgICBDb21tb25Nb2R1bGUsXG4gICAgUm91dGVyTW9kdWxlLFxuICAgIFRoZVNlYW1JY29uTW9kdWxlLFxuICAgIEExMXlNb2R1bGUsXG4gICAgVGhlU2VhbVNjcm9sbGJhck1vZHVsZSxcbiAgICBUaGVTZWFtTGF5b3V0TW9kdWxlLFxuICAgIE5nYlRvb2x0aXBNb2R1bGUsXG4gICAgUG9ydGFsTW9kdWxlLFxuICAgIFRoZVNlYW1NZW51TW9kdWxlXG4gIF0sXG4gIGV4cG9ydHM6IFtcbiAgICBOYXZJdGVtQ29tcG9uZW50LFxuICAgIEhvcml6b250YWxOYXZDb21wb25lbnQsXG4gIF0sXG4gIHByb3ZpZGVyczogW1xuICAgIFRoZVNlYW1OYXZTZXJ2aWNlLFxuICBdXG59KVxuZXhwb3J0IGNsYXNzIFRoZVNlYW1OYXZNb2R1bGUgeyB9XG4iXX0=

package/esm2015/framework/nav/nav.service.js

@@ -0,0 +1,200 @@
+import { Injectable } from '@angular/core';
+import { NavigationEnd, Router } from '@angular/router';
+import { BehaviorSubject, defer, Observable, Subject } from 'rxjs';
+import { distinctUntilChanged, filter, map, shareReplay, startWith, switchMap } from 'rxjs/operators';
+import { hasProperty, notNullOrUndefined } from '@theseam/ui-common/utils';
+import { areSameHorizontalNavItem, getHorizontalNavItemStateProp, horizontalNavItemCanExpand, horizontalNavItemHasActiveChild, horizontalNavItemHasChildren, horizontalNavItemHasExpandedChild, isHorizontalNavItemActive, isHorizontalNavItemType, setDefaultHorizontalNavItemState, setHorizontalNavItemStateProp } from './nav-utils';
+export class TheSeamNavService {
+    constructor(_router) {
+        this._router = _router;
+        this._updatingCount = new BehaviorSubject(0);
+        this.itemChanged = new Subject();
+        this.loading$ = this._updatingCount.pipe(map(count => count > 0), distinctUntilChanged(), shareReplay({ bufferSize: 1, refCount: true }));
+    }
+    createItemsObservable(items) {
+        return defer(() => {
+            this.updateItemsStates(items);
+            this.updateRouterFocusedItem(items);
+            return new Observable((subscriber) => {
+                const stateChangeSub = this.itemChanged.pipe(switchMap(change => {
+                    if (change.prop === 'focused' && change.newValue) {
+                        this.updateFocusedItem(items, change.item);
+                    }
+                    return this.loading$.pipe(filter(loading => !loading));
+                })).subscribe(() => {
+                    subscriber.next(items);
+                });
+                try {
+                    this.updateItemsStates(items);
+                }
+                catch (err) {
+                    subscriber.error(err);
+                }
+                const routeChangeSub = this._router.events.pipe(filter(event => event instanceof NavigationEnd)).subscribe(event => {
+                    try {
+                        this.updateItemsStates(items);
+                        this.updateRouterFocusedItem(items);
+                    }
+                    catch (err) {
+                        subscriber.error(err);
+                    }
+                });
+                return () => {
+                    stateChangeSub.unsubscribe();
+                    routeChangeSub.unsubscribe();
+                };
+            }).pipe(startWith(items));
+        });
+    }
+    _incUpdatingCount() {
+        this._updatingCount.next(this._updatingCount.value + 1);
+    }
+    _decrUpdatingCount() {
+        this._updatingCount.next(this._updatingCount.value - 1);
+    }
+    updateItemsStates(items) {
+        this._incUpdatingCount();
+        try {
+            for (const item of items) {
+                if (horizontalNavItemHasChildren(item)) {
+                    this.updateItemsStates(item.children);
+                }
+                this.updateItemState(item);
+            }
+            this._decrUpdatingCount();
+        }
+        catch (err) {
+            this._decrUpdatingCount();
+            throw err;
+        }
+    }
+    updateItemState(item) {
+        this._incUpdatingCount();
+        try {
+            setDefaultHorizontalNavItemState(item);
+            this.setItemStateProp(item, 'active', this.horizontalNavLinkActive(item));
+            // TODO: Implement this in a more optimized way. Unless our apps start
+            // having large navs constantly updating their state, this shouldn't
+            // have much impact on performance.
+            this._updateItemExpandedState(item);
+            this._decrUpdatingCount();
+        }
+        catch (err) {
+            this._decrUpdatingCount();
+            throw err;
+        }
+    }
+    horizontalNavLinkActive(item) {
+        if (isHorizontalNavItemType(item, 'link')) {
+            const url = this._getUrl(item);
+            if (notNullOrUndefined(url)) {
+                const opts = this._getMatchOptions(item);
+                return this._router.isActive(url, opts);
+            }
+        }
+        return false;
+    }
+    _updateItemsExpandedState(items) {
+        for (const item of items) {
+            if (horizontalNavItemHasChildren(item)) {
+                this._updateItemsExpandedState(item.children);
+            }
+            this._updateItemExpandedState(item);
+        }
+    }
+    _updateItemExpandedState(item) {
+        if (!horizontalNavItemCanExpand(item)) {
+            if (getHorizontalNavItemStateProp(item, 'expanded')) {
+                this.setItemStateProp(item, 'expanded', false);
+            }
+            return;
+        }
+        if (horizontalNavItemHasChildren(item)) {
+            this._updateItemsExpandedState(item.children);
+        }
+        if (horizontalNavItemHasActiveChild(item) || horizontalNavItemHasExpandedChild(item)) {
+            if (!getHorizontalNavItemStateProp(item, 'expanded')) {
+                this.setItemStateProp(item, 'expanded', true);
+            }
+        }
+        else {
+            if (getHorizontalNavItemStateProp(item, 'expanded')) {
+                this.setItemStateProp(item, 'expanded', false);
+            }
+        }
+    }
+    updateRouterFocusedItem(items) {
+        const focusedItem = items.find(i => isHorizontalNavItemActive(i)) || items.find(i => horizontalNavItemHasActiveChild(i));
+        if (notNullOrUndefined(focusedItem)) {
+            this.updateFocusedItem(items, focusedItem);
+        }
+    }
+    updateFocusedItem(items, focusedItem) {
+        for (const item of items) {
+            if (areSameHorizontalNavItem(item, focusedItem)) {
+                setHorizontalNavItemStateProp(item, 'focused', true);
+            }
+            else {
+                setHorizontalNavItemStateProp(item, 'focused', false);
+            }
+        }
+    }
+    _getNavExtras(item) {
+        const navigationExtras = {};
+        if (hasProperty(item, 'queryParams')) {
+            navigationExtras.queryParams = item.queryParams;
+        }
+        if (hasProperty(item, 'fragment')) {
+            navigationExtras.fragment = item.fragment;
+        }
+        if (hasProperty(item, 'queryParamsHandling')) {
+            navigationExtras.queryParamsHandling = item.queryParamsHandling;
+        }
+        if (hasProperty(item, 'preserveFragment')) {
+            navigationExtras.preserveFragment = item.preserveFragment;
+        }
+        return navigationExtras;
+    }
+    _getUrl(item) {
+        const link = item.link;
+        if (typeof link === 'string') {
+            return this._router.createUrlTree([link], this._getNavExtras(item)).toString();
+        }
+        else if (Array.isArray(link)) {
+            return this._router.createUrlTree(link, this._getNavExtras(item)).toString();
+        }
+        return null;
+    }
+    _getMatchOptions(item) {
+        const defaultMatchOpts = {
+            paths: 'subset',
+            queryParams: 'subset',
+            fragment: 'ignored',
+            matrixParams: 'ignored'
+        };
+        if (hasProperty(item, 'matchOptions')) {
+            return Object.assign(Object.assign({}, defaultMatchOpts), item.matchOptions);
+        }
+        return defaultMatchOpts;
+    }
+    setItemStateProp(item, prop, value) {
+        const currentValue = getHorizontalNavItemStateProp(item, prop);
+        if (currentValue !== value) {
+            setHorizontalNavItemStateProp(item, prop, value);
+            const changed = {
+                item,
+                prop,
+                prevValue: currentValue,
+                newValue: value
+            };
+            this.itemChanged.next(changed);
+        }
+    }
+}
+TheSeamNavService.decorators = [
+    { type: Injectable }
+];
+TheSeamNavService.ctorParameters = () => [
+    { type: Router }
+];
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"nav.service.js","sourceRoot":"","sources":["../../../../../projects/ui-common/framework/nav/nav.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core'\nimport { IsActiveMatchOptions, NavigationEnd, Router, UrlCreationOptions } from '@angular/router'\nimport { BehaviorSubject, defer, Observable, Subject, Subscriber } from 'rxjs'\nimport { distinctUntilChanged, filter, map, shareReplay, startWith, switchMap } from 'rxjs/operators'\n\nimport { hasProperty, notNullOrUndefined } from '@theseam/ui-common/utils'\n\nimport {\n  areSameHorizontalNavItem,\n  getHorizontalNavItemStateProp,\n  horizontalNavItemCanExpand,\n  horizontalNavItemHasActiveChild,\n  horizontalNavItemHasChildren,\n  horizontalNavItemHasExpandedChild,\n  isHorizontalNavItemActive,\n  isHorizontalNavItemType,\n  setDefaultHorizontalNavItemState,\n  setHorizontalNavItemStateProp\n} from './nav-utils'\nimport { INavItem, INavItemState, INavLink, NavItemStateChanged } from './nav.models'\n\n@Injectable()\nexport class TheSeamNavService {\n\n  private readonly _updatingCount = new BehaviorSubject<number>(0)\n\n  public readonly loading$: Observable<boolean>\n\n  public readonly itemChanged = new Subject<NavItemStateChanged>()\n\n  constructor(\n    private readonly _router: Router\n  ) {\n    this.loading$ = this._updatingCount.pipe(\n      map(count => count > 0),\n      distinctUntilChanged(),\n      shareReplay({ bufferSize: 1, refCount: true })\n    )\n  }\n\n  public createItemsObservable(items: INavItem[]): Observable<INavItem[]> {\n    return defer(() => {\n      this.updateItemsStates(items)\n      this.updateRouterFocusedItem(items)\n      return new Observable((subscriber: Subscriber<INavItem[]>) => {\n        const stateChangeSub = this.itemChanged.pipe(\n          switchMap(change => {\n            if (change.prop === 'focused' && change.newValue) {\n              this.updateFocusedItem(items, change.item)\n            }\n            return this.loading$.pipe(filter(loading => !loading))\n          })\n        ).subscribe(() => {\n          subscriber.next(items)\n        })\n\n        try {\n          this.updateItemsStates(items)\n        } catch (err) {\n          subscriber.error(err)\n        }\n\n        const routeChangeSub = this._router.events.pipe(\n          filter(event => event instanceof NavigationEnd),\n        ).subscribe(event => {\n          try {\n            this.updateItemsStates(items)\n            this.updateRouterFocusedItem(items)\n          } catch (err) {\n            subscriber.error(err)\n          }\n        })\n\n        return () => {\n          stateChangeSub.unsubscribe()\n          routeChangeSub.unsubscribe()\n        }\n      }).pipe(startWith(items))\n    })\n  }\n\n  private _incUpdatingCount(): void {\n    this._updatingCount.next(this._updatingCount.value + 1)\n  }\n\n  private _decrUpdatingCount(): void {\n    this._updatingCount.next(this._updatingCount.value - 1)\n  }\n\n  public updateItemsStates(items: INavItem[]): void {\n    this._incUpdatingCount()\n\n    try {\n      for (const item of items) {\n        if (horizontalNavItemHasChildren(item)) {\n          this.updateItemsStates(item.children)\n        }\n\n        this.updateItemState(item)\n      }\n\n      this._decrUpdatingCount()\n    } catch (err) {\n      this._decrUpdatingCount()\n      throw err\n    }\n  }\n\n  public updateItemState(item: INavItem): void {\n    this._incUpdatingCount()\n\n    try {\n      setDefaultHorizontalNavItemState(item)\n\n      this.setItemStateProp(item, 'active', this.horizontalNavLinkActive(item))\n\n      // TODO: Implement this in a more optimized way. Unless our apps start\n      // having large navs constantly updating their state, this shouldn't\n      // have much impact on performance.\n      this._updateItemExpandedState(item)\n\n      this._decrUpdatingCount()\n    } catch (err) {\n      this._decrUpdatingCount()\n      throw err\n    }\n  }\n\n  public horizontalNavLinkActive(item: INavItem): boolean {\n    if (isHorizontalNavItemType(item, 'link')) {\n      const url = this._getUrl(item)\n      if (notNullOrUndefined(url)) {\n        const opts = this._getMatchOptions(item)\n        return this._router.isActive(url, opts)\n      }\n    }\n    return false\n  }\n\n  private _updateItemsExpandedState(items: INavItem[]): void {\n    for (const item of items) {\n      if (horizontalNavItemHasChildren(item)) {\n        this._updateItemsExpandedState(item.children)\n      }\n      this._updateItemExpandedState(item)\n    }\n  }\n\n  private _updateItemExpandedState(item: INavItem): void {\n    if (!horizontalNavItemCanExpand(item)) {\n      if (getHorizontalNavItemStateProp(item, 'expanded')) {\n        this.setItemStateProp(item, 'expanded', false)\n      }\n      return\n    }\n\n    if (horizontalNavItemHasChildren(item)) {\n      this._updateItemsExpandedState(item.children)\n    }\n\n    if (horizontalNavItemHasActiveChild(item) || horizontalNavItemHasExpandedChild(item)) {\n      if (!getHorizontalNavItemStateProp(item, 'expanded')) {\n        this.setItemStateProp(item, 'expanded', true)\n      }\n    } else {\n      if (getHorizontalNavItemStateProp(item, 'expanded')) {\n        this.setItemStateProp(item, 'expanded', false)\n      }\n    }\n  }\n\n  public updateRouterFocusedItem(items: INavItem[]) {\n    const focusedItem = items.find(i => isHorizontalNavItemActive(i)) || items.find(i => horizontalNavItemHasActiveChild(i))\n    if (notNullOrUndefined(focusedItem)) {\n      this.updateFocusedItem(items, focusedItem)\n    }\n  }\n\n  public updateFocusedItem(items: INavItem[], focusedItem: INavItem | undefined): void {\n    for (const item of items) {\n      if (areSameHorizontalNavItem(item, focusedItem)) {\n        setHorizontalNavItemStateProp(item, 'focused', true)\n      } else {\n        setHorizontalNavItemStateProp(item, 'focused', false)\n      }\n    }\n  }\n\n  private _getNavExtras(item: INavLink): UrlCreationOptions {\n    const navigationExtras: UrlCreationOptions = { }\n    if (hasProperty(item, 'queryParams')) {\n      navigationExtras.queryParams = item.queryParams\n    }\n    if (hasProperty(item, 'fragment')) {\n      navigationExtras.fragment = item.fragment\n    }\n    if (hasProperty(item, 'queryParamsHandling')) {\n      navigationExtras.queryParamsHandling = item.queryParamsHandling\n    }\n    if (hasProperty(item, 'preserveFragment')) {\n      navigationExtras.preserveFragment = item.preserveFragment\n    }\n    return navigationExtras\n  }\n\n  private _getUrl(item: INavLink): string | null {\n    const link = item.link\n\n    if (typeof link === 'string') {\n      return this._router.createUrlTree([ link ], this._getNavExtras(item)).toString()\n    } else if (Array.isArray(link)) {\n      return this._router.createUrlTree(link, this._getNavExtras(item)).toString()\n    }\n\n    return null\n  }\n\n  private _getMatchOptions(item: INavLink): IsActiveMatchOptions {\n    const defaultMatchOpts: IsActiveMatchOptions = {\n      paths: 'subset',\n      queryParams: 'subset',\n      fragment: 'ignored',\n      matrixParams: 'ignored'\n    }\n\n    if (hasProperty(item, 'matchOptions')) {\n      return {\n        ...defaultMatchOpts,\n        ...item.matchOptions\n      }\n    }\n\n    return defaultMatchOpts\n  }\n\n  public setItemStateProp<K extends keyof INavItemState>(item: INavItem, prop: K, value: INavItemState[K]): void {\n    const currentValue = getHorizontalNavItemStateProp(item, prop)\n    if (currentValue !== value) {\n      setHorizontalNavItemStateProp(item, prop, value)\n\n      const changed: NavItemStateChanged = {\n        item,\n        prop,\n        prevValue: currentValue,\n        newValue: value\n      }\n      this.itemChanged.next(changed)\n    }\n  }\n}\n"]}

package/esm2015/framework/public-api.js

@@ -4,4 +4,5 @@ export * from './side-nav/index';
 export * from './top-bar/index';
 export * from './dynamic-router/index';
 export * from './schema-form/index';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljLWFwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3Byb2plY3RzL3VpLWNvbW1vbi9mcmFtZXdvcmsvcHVibGljLWFwaS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLHFCQUFxQixDQUFBO0FBQ25DLGNBQWMsbUJBQW1CLENBQUE7QUFDakMsY0FBYyxrQkFBa0IsQ0FBQTtBQUNoQyxjQUFjLGlCQUFpQixDQUFBO0FBQy9CLGNBQWMsd0JBQXdCLENBQUE7QUFDdEMsY0FBYyxxQkFBcUIsQ0FBQSIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vYmFzZS1sYXlvdXQvaW5kZXgnXG5leHBvcnQgKiBmcm9tICcuL2Rhc2hib2FyZC9pbmRleCdcbmV4cG9ydCAqIGZyb20gJy4vc2lkZS1uYXYvaW5kZXgnXG5leHBvcnQgKiBmcm9tICcuL3RvcC1iYXIvaW5kZXgnXG5leHBvcnQgKiBmcm9tICcuL2R5bmFtaWMtcm91dGVyL2luZGV4J1xuZXhwb3J0ICogZnJvbSAnLi9zY2hlbWEtZm9ybS9pbmRleCdcbiJdfQ==
+export * from './nav/index';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljLWFwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3Byb2plY3RzL3VpLWNvbW1vbi9mcmFtZXdvcmsvcHVibGljLWFwaS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLHFCQUFxQixDQUFBO0FBQ25DLGNBQWMsbUJBQW1CLENBQUE7QUFDakMsY0FBYyxrQkFBa0IsQ0FBQTtBQUNoQyxjQUFjLGlCQUFpQixDQUFBO0FBQy9CLGNBQWMsd0JBQXdCLENBQUE7QUFDdEMsY0FBYyxxQkFBcUIsQ0FBQTtBQUNuQyxjQUFjLGFBQWEsQ0FBQSIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vYmFzZS1sYXlvdXQvaW5kZXgnXG5leHBvcnQgKiBmcm9tICcuL2Rhc2hib2FyZC9pbmRleCdcbmV4cG9ydCAqIGZyb20gJy4vc2lkZS1uYXYvaW5kZXgnXG5leHBvcnQgKiBmcm9tICcuL3RvcC1iYXIvaW5kZXgnXG5leHBvcnQgKiBmcm9tICcuL2R5bmFtaWMtcm91dGVyL2luZGV4J1xuZXhwb3J0ICogZnJvbSAnLi9zY2hlbWEtZm9ybS9pbmRleCdcbmV4cG9ydCAqIGZyb20gJy4vbmF2L2luZGV4J1xuIl19

package/esm2015/framework/side-nav/side-nav-item/side-nav-item.component.js

@@ -6,6 +6,7 @@ import { BehaviorSubject, Subject } from 'rxjs';
 import { map } from 'rxjs/operators';
 import { faAngleLeft } from '@fortawesome/free-solid-svg-icons';
 import { InputBoolean, InputNumber } from '@theseam/ui-common/core';
+import { notNullOrUndefined } from '@theseam/ui-common/utils';
 import { SideNavComponent } from '../side-nav.component';
 const EXPANDED_STATE = 'expanded';
 const COLLAPSED_STATE = 'collapsed';
@@ -45,13 +46,14 @@ export class SideNavItemComponent {
                 this._badgeTooltip = {
                     tooltip: value,
                     placement: 'auto',
-                    disabled: false
+                    disabled: false,
+                    container: 'body'
                 };
             }
             else {
                 this._badgeTooltip = Object.assign(Object.assign({}, value), { placement: value.placement || 'auto', disabled: typeof (value === null || value === void 0 ? void 0 : value.disabled) === 'boolean'
                         ? value.disabled
-                        : typeof value.tooltip === 'string' ? false : true });
+                        : typeof value.tooltip === 'string' ? false : true, container: value.container || 'body' });
             }
         }
         else {
@@ -76,11 +78,14 @@ export class SideNavItemComponent {
             this._sideNav.collapse();
         }
     }
+    get showIconBlock() {
+        return notNullOrUndefined(this.icon) || this.hideEmptyIcon !== true;
+    }
 }
 SideNavItemComponent.decorators = [
     { type: Component, args: [{
                 selector: 'seam-side-nav-item',
-                template: "<div class=\"d-flex flex-row\">\n  <ng-container *ngIf=\"itemType === 'basic'\">\n    <ng-template [ngTemplateOutlet]=\"itemTypeBasic\"></ng-template>\n  </ng-container>\n  <ng-container *ngIf=\"itemType === 'link'\">\n    <ng-template [ngTemplateOutlet]=\"itemTypeLink\"></ng-template>\n  </ng-container>\n  <ng-container *ngIf=\"itemType === 'divider'\">\n    <ng-template [ngTemplateOutlet]=\"itemTypeDivider\"></ng-template>\n  </ng-container>\n  <ng-container *ngIf=\"itemType === 'title'\">\n    <ng-template [ngTemplateOutlet]=\"itemTypeTitle\"></ng-template>\n  </ng-container>\n</div>\n\n<ng-container *ngIf=\"hasChildren\">\n  <div class=\"side-nav--group side-nav--group--level-{{ hierLevel + 1 }}\"\n    [@childGroupAnim]=\"childGroupAnimState$ | async\">\n    <seam-side-nav-item *ngFor=\"let child of children\"\n      [hierLevel]=\"compact ? 0 : (hierLevel + 1)\"\n      [compact]=\"compact\"\n      [itemType]=\"$any(child).itemType\"\n      [icon]=\"$any(child).icon\"\n      [label]=\"$any(child).label\"\n      [link]=\"$any(child).link\"\n      [badgeText]=\"$any(child).badge?.text\"\n      [badgeTheme]=\"$any(child).badge?.theme || 'danger'\"\n      [badgeSrContent]=\"$any(child).badge?.srContent\"\n      [badgeTooltip]=\"$any(child)?.badge?.tooltip\"\n      [queryParams]=\"$any(child).queryParams\"\n      routerLinkActive=\"active\"\n      [routerLinkActiveOptions]=\"{ exact: true }\"\n      [children]=\"$any(child)?.children\"\n      [active]=\"$any(child).__state.active\"\n      [expanded]=\"$any(child).__state.expanded\">\n    </seam-side-nav-item>\n  </div>\n</ng-container>\n\n<ng-template #itemTypeBasic>\n  <button class=\"side-nav-item btn side-nav-btn p-0 d-flex flex-row rounded-0 text-decoration-none text-nowrap w-100\"\n    cdkMonitorElementFocus\n    (click)=\"toggleChildren()\"\n    [attr.aria-expanded]=\"expanded\">\n    <div class=\"nav-link d-flex flex-row w-100\" [class.nav-link__compact]=\"compact\">\n      <div [style.padding-left.px]=\"hierLevel * indentSize\"></div>\n      <div class=\"side-nav-item--icon\">\n        <seam-icon *ngIf=\"icon\" [icon]=\"icon\"></seam-icon>\n        <ng-container *ngIf=\"compact\">\n          <ng-template [ngTemplateOutlet]=\"itemBadge\"></ng-template>\n        </ng-container>\n      </div>\n      <span *ngIf=\"!compact\" side-nav-item-label style=\"margin-left: 11px;\">\n        {{ label }}\n      </span>\n      <span *ngIf=\"compact\" class=\"sr-only\" side-nav-item-label>{{ label }}</span>\n      <ng-container *ngIf=\"!compact\">\n        <ng-template [ngTemplateOutlet]=\"itemBadge\"></ng-template>\n      </ng-container>\n    </div>\n\n    <div *ngIf=\"hasChildren && !compact\"\n      class=\"btn side-nav-btn side-nav-item--toggle-btn-container rounded-0\">\n      <seam-icon\n        class=\"side-nav-item--toggle-btn\"\n        [class.side-nav-item--toggle-btn-expanded]=\"expanded\"\n        [icon]=\"faAngleLeft\"\n        type>\n      </seam-icon>\n    </div>\n  </button>\n</ng-template>\n\n<ng-template #itemTypeLink>\n  <a *ngIf=\"link; else noLink\" class=\"side-nav-item nav-link d-flex flex-row text-nowrap w-100 align-items-center\"\n    [class.nav-link__compact]=\"compact\"\n    [routerLink]=\"link\"\n    [queryParams]=\"queryParams\"\n    routerLinkActive=\"active\"\n    [routerLinkActiveOptions]=\"{ exact: true }\"\n    (click)=\"_linkClicked()\">\n    <div [style.padding-left.px]=\"hierLevel * indentSize\"></div>\n    <div class=\"side-nav-item--icon\">\n      <seam-icon *ngIf=\"icon\" [icon]=\"icon\"></seam-icon>\n      <ng-container *ngIf=\"compact\">\n        <ng-template [ngTemplateOutlet]=\"itemBadge\"></ng-template>\n      </ng-container>\n    </div>\n    <span *ngIf=\"!compact\" style=\"margin-left: 11px;\" side-nav-item-label>\n      {{ label }}\n    </span>\n    <span *ngIf=\"compact\" class=\"sr-only\" side-nav-item-label>{{ label }}</span>\n    <ng-container *ngIf=\"!compact\">\n      <ng-template [ngTemplateOutlet]=\"itemBadge\"></ng-template>\n    </ng-container>\n  </a>\n\n  <ng-template #noLink>\n    <a class=\"side-nav-item nav-link d-flex flex-row text-nowrap w-100 align-items-center\" [class.nav-link__compact]=\"compact\">\n      <div [style.padding-left.px]=\"hierLevel * indentSize\"></div>\n      <div class=\"side-nav-item--icon\">\n        <seam-icon *ngIf=\"icon\" [icon]=\"icon\"></seam-icon>\n      </div>\n      <span *ngIf=\"!compact\" style=\"margin-left: 11px;\" side-nav-item-label>\n        {{ label }}\n      </span>\n      <span *ngIf=\"compact\" class=\"sr-only\" side-nav-item-label>{{ label }}</span>\n    </a>\n  </ng-template>\n\n  <button *ngIf=\"hasChildren && !compact\"\n    type=\"button\"\n    class=\"btn side-nav-btn side-nav-item--toggle-btn-container rounded-0\"\n    (click)=\"toggleChildren()\"\n    [attr.aria-expanded]=\"expanded\"\n    cdkMonitorElementFocus>\n    <seam-icon\n      class=\"side-nav-item--toggle-btn\"\n      [class.side-nav-item--toggle-btn-expanded]=\"expanded\"\n      [icon]=\"faAngleLeft\"\n      type>\n    </seam-icon>\n    <span class=\"sr-only\">Group Toggle</span>\n  </button>\n</ng-template>\n\n<ng-template #itemTypeDivider>\n  <div class=\"px-2 w-100\">\n    <hr class=\"side-nav-item--divider\" />\n  </div>\n</ng-template>\n\n<ng-template #itemTypeTitle>\n  <ng-container *ngIf=\"!compact\">\n    <span class=\"side-nav-item--title pt-1\" side-nav-item-label>{{ label }}</span>\n  </ng-container>\n</ng-template>\n\n<ng-template #itemBadge>\n  <ng-container *ngIf=\"badgeText\">\n    <div class=\"badge-spacer flex-grow-1\" *ngIf=\"!compact\"></div>\n    <div class=\"side-nav-item--badge\"\n      [class.side-nav-item--badge-no-icon]=\"!icon\"\n      [ngbTooltip]=\"$any(badgeTooltip)?.tooltip\"\n      [tooltipClass]=\"$any(badgeTooltip)?.class\"\n      [placement]=\"$any(badgeTooltip)?.placement\"\n      [container]=\"$any(badgeTooltip)?.container\"\n      [disableTooltip]=\"!badgeTooltip || !!$any(badgeTooltip)?.disabled\">\n      <span class=\"badge badge-pill badge-{{ badgeTheme }}\">\n        <ng-container *ngIf=\"!compact || !icon\">\n          {{ badgeText }}\n        </ng-container>\n        <span *ngIf=\"badgeSrContent\">{{ badgeSrContent }}</span>\n      </span>\n    </div>\n  </ng-container>\n</ng-template>\n",
+                template: "<div class=\"d-flex flex-row side-nav-item-wrapper\">\n  <ng-container *ngIf=\"itemType === 'basic'\">\n    <ng-template [ngTemplateOutlet]=\"itemTypeBasic\"></ng-template>\n  </ng-container>\n  <ng-container *ngIf=\"itemType === 'link'\">\n    <ng-template [ngTemplateOutlet]=\"itemTypeLink\"></ng-template>\n  </ng-container>\n  <ng-container *ngIf=\"itemType === 'divider'\">\n    <ng-template [ngTemplateOutlet]=\"itemTypeDivider\"></ng-template>\n  </ng-container>\n  <ng-container *ngIf=\"itemType === 'title'\">\n    <ng-template [ngTemplateOutlet]=\"itemTypeTitle\"></ng-template>\n  </ng-container>\n</div>\n\n<ng-container *ngIf=\"hasChildren\">\n  <div class=\"side-nav--group side-nav--group--level-{{ hierLevel + 1 }}\"\n    [@childGroupAnim]=\"childGroupAnimState$ | async\">\n    <seam-side-nav-item *ngFor=\"let child of children\"\n      [hierLevel]=\"compact ? 0 : (hierLevel + 1)\"\n      [compact]=\"compact\"\n      [itemType]=\"$any(child).itemType\"\n      [icon]=\"$any(child).icon\"\n      [label]=\"$any(child).label\"\n      [link]=\"$any(child).link\"\n      [badgeText]=\"$any(child).badge?.text\"\n      [badgeTheme]=\"$any(child).badge?.theme || 'danger'\"\n      [badgeSrContent]=\"$any(child).badge?.srContent\"\n      [badgeTooltip]=\"$any(child)?.badge?.tooltip\"\n      [queryParams]=\"$any(child).queryParams\"\n      routerLinkActive=\"active\"\n      [routerLinkActiveOptions]=\"{ exact: true }\"\n      [children]=\"$any(child)?.children\"\n      [active]=\"$any(child).__state?.active\"\n      [expanded]=\"$any(child).__state?.expanded\"\n      [hideEmptyIcon]=\"hideEmptyIcon\"\n      [indentSize]=\"indentSize\">\n    </seam-side-nav-item>\n  </div>\n</ng-container>\n\n<ng-template #itemTypeBasic>\n  <button class=\"side-nav-item btn side-nav-btn p-0 d-flex flex-row align-items-stretch rounded-0 text-decoration-none text-nowrap w-100\"\n    cdkMonitorElementFocus\n    (click)=\"toggleChildren()\"\n    [attr.aria-expanded]=\"expanded\">\n    <div class=\"nav-link d-flex flex-row align-items-center w-100\" [class.nav-link__compact]=\"compact\">\n      <div [style.padding-left.px]=\"hierLevel * indentSize\"></div>\n      <div class=\"side-nav-item--icon\" *ngIf=\"showIconBlock\">\n        <seam-icon *ngIf=\"icon\" [icon]=\"icon\"></seam-icon>\n        <ng-container *ngIf=\"compact\">\n          <ng-template [ngTemplateOutlet]=\"itemBadge\"></ng-template>\n        </ng-container>\n      </div>\n      <span *ngIf=\"!compact\" side-nav-item-label style=\"margin-left: 11px;\">\n        {{ label }}\n      </span>\n      <span *ngIf=\"compact\" class=\"sr-only\" side-nav-item-label>{{ label }}</span>\n      <ng-container *ngIf=\"!compact\">\n        <ng-template [ngTemplateOutlet]=\"itemBadge\"></ng-template>\n      </ng-container>\n    </div>\n\n    <div *ngIf=\"hasChildren && !compact\"\n      class=\"btn side-nav-btn side-nav-item--toggle-btn-container rounded-0\">\n      <seam-icon\n        class=\"side-nav-item--toggle-btn\"\n        [class.side-nav-item--toggle-btn-expanded]=\"expanded\"\n        [icon]=\"faAngleLeft\"\n        type>\n      </seam-icon>\n    </div>\n  </button>\n</ng-template>\n\n<ng-template #itemTypeLink>\n  <a *ngIf=\"link; else noLink\" class=\"side-nav-item nav-link d-flex flex-row text-nowrap w-100 align-items-center\"\n    [class.nav-link__compact]=\"compact\"\n    [routerLink]=\"link\"\n    [queryParams]=\"queryParams\"\n    routerLinkActive=\"active\"\n    [routerLinkActiveOptions]=\"{ exact: true }\"\n    (click)=\"_linkClicked()\">\n    <div [style.padding-left.px]=\"hierLevel * indentSize\"></div>\n    <div class=\"side-nav-item--icon\" *ngIf=\"showIconBlock\">\n      <seam-icon *ngIf=\"icon\" [icon]=\"icon\"></seam-icon>\n      <ng-container *ngIf=\"compact\">\n        <ng-template [ngTemplateOutlet]=\"itemBadge\"></ng-template>\n      </ng-container>\n    </div>\n    <span *ngIf=\"!compact\" style=\"margin-left: 11px;\" side-nav-item-label>\n      {{ label }}\n    </span>\n    <span *ngIf=\"compact\" class=\"sr-only\" side-nav-item-label>{{ label }}</span>\n    <ng-container *ngIf=\"!compact\">\n      <ng-template [ngTemplateOutlet]=\"itemBadge\"></ng-template>\n    </ng-container>\n  </a>\n\n  <ng-template #noLink>\n    <a class=\"side-nav-item nav-link d-flex flex-row text-nowrap w-100 align-items-center\" [class.nav-link__compact]=\"compact\">\n      <div [style.padding-left.px]=\"hierLevel * indentSize\"></div>\n      <div class=\"side-nav-item--icon\" *ngIf=\"showIconBlock\">\n        <seam-icon *ngIf=\"icon\" [icon]=\"icon\"></seam-icon>\n      </div>\n      <span *ngIf=\"!compact\" style=\"margin-left: 11px;\" side-nav-item-label>\n        {{ label }}\n      </span>\n      <span *ngIf=\"compact\" class=\"sr-only\" side-nav-item-label>{{ label }}</span>\n    </a>\n  </ng-template>\n\n  <button *ngIf=\"hasChildren && !compact\"\n    type=\"button\"\n    class=\"btn side-nav-btn side-nav-item--toggle-btn-container rounded-0\"\n    (click)=\"toggleChildren()\"\n    [attr.aria-expanded]=\"expanded\"\n    cdkMonitorElementFocus>\n    <seam-icon\n      class=\"side-nav-item--toggle-btn\"\n      [class.side-nav-item--toggle-btn-expanded]=\"expanded\"\n      [icon]=\"faAngleLeft\"\n      type>\n    </seam-icon>\n    <span class=\"sr-only\">Group Toggle</span>\n  </button>\n</ng-template>\n\n<ng-template #itemTypeDivider>\n  <div class=\"px-2 w-100\">\n    <hr class=\"side-nav-item--divider\" />\n  </div>\n</ng-template>\n\n<ng-template #itemTypeTitle>\n  <ng-container *ngIf=\"!compact\">\n    <span class=\"side-nav-item--title pt-1\" side-nav-item-label>{{ label }}</span>\n  </ng-container>\n</ng-template>\n\n<ng-template #itemBadge>\n  <ng-container *ngIf=\"badgeText\">\n    <div class=\"badge-spacer flex-grow-1\" *ngIf=\"!compact\"></div>\n    <div class=\"side-nav-item--badge\"\n      [class.side-nav-item--badge-no-icon]=\"!icon\"\n      [ngbTooltip]=\"$any(badgeTooltip)?.tooltip\"\n      [tooltipClass]=\"$any(badgeTooltip)?.class\"\n      [placement]=\"$any(badgeTooltip)?.placement\"\n      [container]=\"$any(badgeTooltip)?.container\"\n      [disableTooltip]=\"!badgeTooltip || !!$any(badgeTooltip)?.disabled\">\n      <span class=\"badge badge-pill badge-{{ badgeTheme }}\">\n        <ng-container *ngIf=\"!compact || !icon\">\n          {{ badgeText }}\n        </ng-container>\n        <span *ngIf=\"badgeSrContent\">{{ badgeSrContent }}</span>\n      </span>\n    </div>\n  </ng-container>\n</ng-template>\n",
                 exportAs: 'seamSideNavItem',
                 animations: [
                     trigger('childGroupAnim', [
@@ -113,7 +118,7 @@ SideNavItemComponent.decorators = [
                 ],
                 changeDetection: ChangeDetectionStrategy.OnPush,
                 encapsulation: ViewEncapsulation.None,
-                styles: ["seam-side-nav-item{display:block;transition:.25s ease-in-out background-color}seam-side-nav-item.seam-side-nav-item--active{background-color:#2a6395}seam-side-nav-item.seam-side-nav-item--active .active,seam-side-nav-item.seam-side-nav-item--active:active,seam-side-nav-item.seam-side-nav-item--active .side-nav-item.active:hover{background-color:#2a6395}seam-side-nav-item.seam-side-nav-item--active .side-nav-item:hover{background-color:#2f71a9}seam-side-nav-item.seam-side-nav-item--active .nav-link{color:#fff}seam-side-nav-item .badge{vertical-align:middle}seam-side-nav-item:not(.side-nav-item--icon) .side-nav-item--badge{pointer-events:all;margin-left:5px;margin-right:3px}seam-side-nav-item .side-nav-item--icon{position:relative;width:24px;max-width:24px;min-width:24px;height:24px;max-height:24px;min-height:24px;text-align:center}seam-side-nav-item .side-nav-item--icon .side-nav-item--badge{top:-4px;right:-4px;position:absolute}seam-side-nav-item .side-nav-item--icon .side-nav-item--badge .badge:empty{display:block;width:8px;height:8px;padding:0}seam-side-nav-item .side-nav-item--icon .side-nav-item--badge.side-nav-item--badge-no-icon{top:0px;right:0px}seam-side-nav-item .side-nav-item{min-height:45px;transition:.25s ease-in-out background-color}seam-side-nav-item .side-nav-item:hover{background-color:#2f71a9}seam-side-nav-item .side-nav-item.active{pointer-events:none;cursor:default}seam-side-nav-item a.side-nav-item:not([href]):not([tabindex]){color:#ccc}seam-side-nav-item a.side-nav-item:not([href]):not([tabindex]):hover{background-color:transparent}seam-side-nav-item .nav-link{color:#fff;padding-right:2px}seam-side-nav-item .nav-link__compact{padding-right:0;padding-left:12px}seam-side-nav-item .nav-link:last-child{padding-right:8px}seam-side-nav-item .side-nav-btn{font-weight:400;color:#fff;text-decoration:none}seam-side-nav-item .side-nav-btn:hover{color:#2f71a9;text-decoration:underline}seam-side-nav-item .side-nav-btn:focus,seam-side-nav-item .side-nav-btn.focus{text-decoration:underline;box-shadow:none}seam-side-nav-item .side-nav-btn:disabled,seam-side-nav-item .side-nav-btn.disabled{color:#ccc;pointer-events:none}seam-side-nav-item .cdk-keyboard-focused{outline:1px dotted;outline:5px auto -webkit-focus-ring-color}seam-side-nav-item .side-nav-item--toggle-btn-container{transition:.25s ease-in-out background-color;padding:.5rem 1rem}seam-side-nav-item button.side-nav-item--toggle-btn-container:hover{background-color:#2f71a9}seam-side-nav-item .side-nav-item--toggle-btn{color:#fff}seam-side-nav-item .side-nav-item--toggle-btn .svg-inline--fa{transition:.1s ease-in-out transform}seam-side-nav-item .side-nav-item--toggle-btn.side-nav-item--toggle-btn-expanded .svg-inline--fa{transform:rotate(-90deg)}seam-side-nav-item .side-nav--group{will-change:height;overflow:hidden}seam-side-nav-item .side-nav--group--level-1{background-color:#3276b1}seam-side-nav-item .side-nav--group--level-2{background-color:#2e6ea5}seam-side-nav-item .side-nav--group--level-3{background-color:#2b6699}seam-side-nav-item .side-nav--group--level-4{background-color:#285e8d}seam-side-nav-item .side-nav--group--level-5{background-color:#245681}seam-side-nav-item .side-nav--group--level-6{background-color:#214e75}seam-side-nav-item .side-nav--group--level-7{background-color:#1e4669}seam-side-nav-item .side-nav--group--level-8{background-color:#1a3e5d}seam-side-nav-item .side-nav--group--level-9{background-color:#173651}seam-side-nav-item .side-nav-item--divider{display:block;border-top:1px solid #2a6395;width:100%}seam-side-nav-item .side-nav-item--title{color:#fff;font-size:24px;padding-left:10px}seam-side-nav-item .sr-only{top:0;left:0}\n"]
+                styles: ["seam-side-nav-item{display:block;transition:.25s ease-in-out background-color}seam-side-nav-item.seam-side-nav-item--active{background-color:#2a6395}seam-side-nav-item.seam-side-nav-item--active .active,seam-side-nav-item.seam-side-nav-item--active:active,seam-side-nav-item.seam-side-nav-item--active .side-nav-item.active:hover{background-color:#2a6395}seam-side-nav-item.seam-side-nav-item--active .side-nav-item:hover{background-color:#2f71a9}seam-side-nav-item.seam-side-nav-item--active .nav-link{color:#fff}seam-side-nav-item.seam-side-nav-item--active .side-nav-btn{color:#fff}seam-side-nav-item .badge{vertical-align:middle}seam-side-nav-item:not(.side-nav-item--icon) .side-nav-item--badge{pointer-events:all;margin-left:5px;margin-right:3px}seam-side-nav-item .side-nav-item--icon{position:relative;width:24px;max-width:24px;min-width:24px;height:24px;max-height:24px;min-height:24px;text-align:center}seam-side-nav-item .side-nav-item--icon .side-nav-item--badge{top:-4px;right:-4px;position:absolute}seam-side-nav-item .side-nav-item--icon .side-nav-item--badge .badge:empty{display:block;width:8px;height:8px;padding:0}seam-side-nav-item .side-nav-item--icon .side-nav-item--badge.side-nav-item--badge-no-icon{top:0px;right:0px}seam-side-nav-item .side-nav-item{min-height:45px;transition:.25s ease-in-out background-color}seam-side-nav-item .side-nav-item:hover{background-color:#2f71a9}seam-side-nav-item .side-nav-item.active{pointer-events:none;cursor:default}seam-side-nav-item a.side-nav-item:not([href]):not([tabindex]){color:#ccc}seam-side-nav-item a.side-nav-item:not([href]):not([tabindex]):hover{background-color:transparent}seam-side-nav-item .nav-link{color:#fff;padding-right:2px}seam-side-nav-item .nav-link__compact{padding-right:0;padding-left:12px}seam-side-nav-item .nav-link:last-child{padding-right:8px}seam-side-nav-item .side-nav-btn{font-weight:400;color:#fff;text-decoration:none}seam-side-nav-item .side-nav-btn:hover{color:#fff;text-decoration:underline}seam-side-nav-item .side-nav-btn:focus,seam-side-nav-item .side-nav-btn.focus{text-decoration:underline;box-shadow:none}seam-side-nav-item .side-nav-btn:disabled,seam-side-nav-item .side-nav-btn.disabled{color:#ccc;pointer-events:none}seam-side-nav-item .cdk-keyboard-focused{outline:1px dotted;outline:5px auto -webkit-focus-ring-color}seam-side-nav-item .side-nav-item--toggle-btn-container{transition:.25s ease-in-out background-color;padding:.5rem 1rem}seam-side-nav-item button.side-nav-item--toggle-btn-container:hover{background-color:#2f71a9}seam-side-nav-item .side-nav-item--toggle-btn .svg-inline--fa{transition:.1s ease-in-out transform}seam-side-nav-item .side-nav-item--toggle-btn.side-nav-item--toggle-btn-expanded .svg-inline--fa{transform:rotate(-90deg)}seam-side-nav-item .side-nav--group{will-change:height;overflow:hidden}seam-side-nav-item .side-nav--group--level-1{background-color:#3276b1}seam-side-nav-item .side-nav--group--level-2{background-color:#2e6ea5}seam-side-nav-item .side-nav--group--level-3{background-color:#2b6699}seam-side-nav-item .side-nav--group--level-4{background-color:#285e8d}seam-side-nav-item .side-nav--group--level-5{background-color:#245681}seam-side-nav-item .side-nav--group--level-6{background-color:#214e75}seam-side-nav-item .side-nav--group--level-7{background-color:#1e4669}seam-side-nav-item .side-nav--group--level-8{background-color:#1a3e5d}seam-side-nav-item .side-nav--group--level-9{background-color:#173651}seam-side-nav-item .side-nav-item--divider{display:block;border-top:1px solid #2a6395;width:100%}seam-side-nav-item .side-nav-item--title{color:#fff;font-size:24px;padding-left:10px}seam-side-nav-item .sr-only{top:0;left:0}\n"]
             },] }
 ];
 SideNavItemComponent.ctorParameters = () => [
@@ -123,6 +128,7 @@ SideNavItemComponent.ctorParameters = () => [
 SideNavItemComponent.propDecorators = {
     itemType: [{ type: Input }],
     icon: [{ type: Input }],
+    hideEmptyIcon: [{ type: Input }],
     label: [{ type: Input }],
     active: [{ type: Input }],
     link: [{ type: Input }],
@@ -148,4 +154,4 @@ __decorate([
 __decorate([
     InputNumber(10)
 ], SideNavItemComponent.prototype, "indentSize", void 0);
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"side-nav-item.component.js","sourceRoot":"","sources":["../../../../../../projects/ui-common/framework/side-nav/side-nav-item/side-nav-item.component.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  animate,\n  query,\n  state,\n  style,\n  transition,\n  trigger,\n} from '@angular/animations'\nimport { BooleanInput, coerceBooleanProperty, NumberInput } from '@angular/cdk/coercion'\nimport {\n  ChangeDetectionStrategy,\n  Component,\n  Host,\n  HostBinding,\n  Input,\n  OnDestroy,\n  Optional,\n  SkipSelf,\n  ViewEncapsulation\n} from '@angular/core'\nimport { BehaviorSubject, Observable, Subject } from 'rxjs'\nimport { map } from 'rxjs/operators'\n\nimport { faAngleLeft } from '@fortawesome/free-solid-svg-icons'\n\nimport { InputBoolean, InputNumber } from '@theseam/ui-common/core'\nimport type { SeamIcon } from '@theseam/ui-common/icon'\nimport type { ThemeTypes } from '@theseam/ui-common/models'\n\nimport { SideNavComponent } from '../side-nav.component'\nimport { ISideNavItem } from '../side-nav.models'\n\nexport interface SideNavItemBadgeTooltip {\n  tooltip?: string\n  class?: string\n  placement?: string\n  container?: string\n  disabled?: boolean\n}\n\nconst EXPANDED_STATE = 'expanded'\nconst COLLAPSED_STATE = 'collapsed'\n\nconst FULL_STATE = 'full'\nconst COMPACT_STATE = 'compact'\n\n@Component({\n  selector: 'seam-side-nav-item',\n  templateUrl: './side-nav-item.component.html',\n  styleUrls: ['./side-nav-item.component.scss'],\n  exportAs: 'seamSideNavItem',\n  animations: [\n    trigger('childGroupAnim', [\n      state(EXPANDED_STATE, style({ height: '*' })),\n      state(COLLAPSED_STATE, style({ height: 0, 'overflow-y': 'hidden', visibility: 'hidden' })),\n      transition(`${EXPANDED_STATE} <=> ${COLLAPSED_STATE}`, animate('0.2s ease-in-out')),\n    ]),\n\n\n    trigger('compactAnim', [\n      // transition('* <=> *', [\n      //   query(':enter', [\n      //     style({ opacity: '0' }),\n      //     animate('5.2s ease-in-out', style({ opacity: '1' }))\n      //   ], { optional: true }),\n      //   query(':leave', [\n      //     style({ opacity: '1' }),\n      //     animate('5.2s ease-in-out', style({ opacity: '0' }))\n      //   ], { optional: true })\n      // ])\n\n      // state(FULL_STATE, style({ opacity: '1' })),\n      // state(COMPACT_STATE, style({ opacity: '0' })),\n      // transition(`${FULL_STATE} <=> ${COMPACT_STATE}`, animate('5.2s ease-in-out')),\n      // transition(`${FULL_STATE} <=> ${COMPACT_STATE}`, [\n      // transition('* <=> *', [\n      //   query(':leave', [\n      //     style({ opacity: '1' }),\n      //     animate('5.2s ease-in-out', style({ opacity: '0' }))\n      //   ], { optional: true })\n      // ]),\n\n\n    ])\n  ],\n  changeDetection: ChangeDetectionStrategy.OnPush,\n  encapsulation: ViewEncapsulation.None\n})\nexport class SideNavItemComponent implements OnDestroy {\n  static ngAcceptInputType_hierLevel: NumberInput\n  static ngAcceptInputType_indentSize: NumberInput\n  static ngAcceptInputType_expanded: BooleanInput\n  static ngAcceptInputType_compact: BooleanInput\n  static ngAcceptInputType_active: BooleanInput\n\n  private readonly _ngUnsubscribe = new Subject()\n\n  readonly faAngleLeft = faAngleLeft\n\n  @Input() itemType: 'divider' | 'basic' | 'link' | 'button' | 'title' | undefined | null\n\n  @Input() icon: SeamIcon | undefined | null\n\n  @Input() label: string | undefined | null\n\n  @Input() @InputBoolean() active: boolean = false\n\n  @Input()\n  set link(value: string | undefined | null) { this._link.next(value) }\n  get link() { return this._link.value }\n  private readonly _link = new BehaviorSubject<string | undefined | null>(undefined)\n  public readonly link$ = this._link.asObservable()\n\n  @Input() queryParams: { [k: string]: any } | undefined | null\n\n  @Input() children: ISideNavItem[] | undefined | null\n\n  @Input() @InputNumber(0) hierLevel: number = 0\n\n  @Input() @InputNumber(10) indentSize: number = 10\n\n  @Input()\n  set expanded(value: boolean) { this._expanded.next(coerceBooleanProperty(value)) }\n  get expanded() { return this._expanded.value }\n  private readonly _expanded = new BehaviorSubject<boolean>(false)\n  public readonly expanded$ = this._expanded.asObservable()\n\n  @Input()\n  set compact(value: boolean) { this._compact.next(coerceBooleanProperty(value)) }\n  get compact() { return this._compact.value }\n  private readonly _compact = new BehaviorSubject<boolean>(false)\n  public readonly compact$ = this._compact.asObservable()\n\n  @Input() badgeText: string | undefined | null\n  @Input() badgeTheme: ThemeTypes | undefined | null = 'danger'\n\n  /**\n   * Content to provide to assistive technology, such as screen readers.\n   */\n  @Input() badgeSrContent: string | undefined | null\n\n  @Input()\n  get badgeTooltip() { return this._badgeTooltip }\n  set badgeTooltip(value: string | SideNavItemBadgeTooltip | undefined | null) {\n    if (value !== null && value !== undefined) {\n      if (typeof value === 'string') {\n        this._badgeTooltip = {\n          tooltip: value,\n          placement: 'auto',\n          disabled: false\n        }\n      } else {\n        this._badgeTooltip = {\n          ...value,\n          placement: value.placement || 'auto',\n          disabled: typeof value?.disabled === 'boolean'\n            ? value.disabled\n            : typeof value.tooltip === 'string' ? false : true\n        }\n      }\n    } else {\n      this._badgeTooltip = undefined\n    }\n  }\n  private _badgeTooltip: SideNavItemBadgeTooltip | undefined | null\n\n  @HostBinding('class.seam-side-nav-item--active') get _isActiveCssClass() { return this.active }\n\n  @HostBinding('attr.data-hier-level') get _attrDataHierLevel() { return this.hierLevel }\n\n  public readonly childGroupAnimState$: Observable<string>\n  public readonly compactAnimState$: Observable<string>\n\n  constructor(\n    private readonly _sideNav: SideNavComponent,\n    @Optional() @SkipSelf() @Host() private readonly _parent?: SideNavItemComponent\n  ) {\n    this.childGroupAnimState$ = this.expanded$\n      .pipe(map(expanded => expanded ? EXPANDED_STATE : COLLAPSED_STATE))\n\n    this.compactAnimState$ = this.compact$\n      .pipe(map(compact => compact ? COMPACT_STATE : FULL_STATE))\n  }\n\n  ngOnDestroy() {\n    this._ngUnsubscribe.next()\n    this._ngUnsubscribe.complete()\n  }\n\n  get hasChildren() {\n    return Array.isArray(this.children) && this.children.length > 0\n  }\n\n  public toggleChildren(): void {\n    this.expanded = !this.expanded\n  }\n\n  _linkClicked() {\n    // Close nav when link is clicked while in overlay state\n    if (this._sideNav.overlay) {\n      this._sideNav.collapse()\n    }\n  }\n\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"side-nav-item.component.js","sourceRoot":"","sources":["../../../../../../projects/ui-common/framework/side-nav/side-nav-item/side-nav-item.component.ts"],"names":[],"mappings":";AAAA,OAAO,EACL,OAAO,EAEP,KAAK,EACL,KAAK,EACL,UAAU,EACV,OAAO,GACR,MAAM,qBAAqB,CAAA;AAC5B,OAAO,EAAgB,qBAAqB,EAAe,MAAM,uBAAuB,CAAA;AACxF,OAAO,EACL,uBAAuB,EACvB,SAAS,EACT,IAAI,EACJ,WAAW,EACX,KAAK,EAEL,QAAQ,EACR,QAAQ,EACR,iBAAiB,EAClB,MAAM,eAAe,CAAA;AACtB,OAAO,EAAE,eAAe,EAAc,OAAO,EAAE,MAAM,MAAM,CAAA;AAC3D,OAAO,EAAE,GAAG,EAAE,MAAM,gBAAgB,CAAA;AAEpC,OAAO,EAAE,WAAW,EAAE,MAAM,mCAAmC,CAAA;AAE/D,OAAO,EAAE,YAAY,EAAE,WAAW,EAAE,MAAM,yBAAyB,CAAA;AAInE,OAAO,EAAE,kBAAkB,EAAE,MAAM,0BAA0B,CAAA;AAC7D,OAAO,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAA;AAWxD,MAAM,cAAc,GAAG,UAAU,CAAA;AACjC,MAAM,eAAe,GAAG,WAAW,CAAA;AAEnC,MAAM,UAAU,GAAG,MAAM,CAAA;AACzB,MAAM,aAAa,GAAG,SAAS,CAAA;AA4C/B,MAAM,OAAO,oBAAoB;IAyF/B,YACmB,QAA0B,EACM,OAA8B;QAD9D,aAAQ,GAAR,QAAQ,CAAkB;QACM,YAAO,GAAP,OAAO,CAAuB;QApFhE,mBAAc,GAAG,IAAI,OAAO,EAAE,CAAA;QAEtC,gBAAW,GAAG,WAAW,CAAA;QAUT,WAAM,GAAY,KAAK,CAAA;QAK/B,UAAK,GAAG,IAAI,eAAe,CAA4B,SAAS,CAAC,CAAA;QAClE,UAAK,GAAG,IAAI,CAAC,KAAK,CAAC,YAAY,EAAE,CAAA;QAMxB,cAAS,GAAW,CAAC,CAAA;QAEpB,eAAU,GAAW,EAAE,CAAA;QAKhC,cAAS,GAAG,IAAI,eAAe,CAAU,KAAK,CAAC,CAAA;QAChD,cAAS,GAAG,IAAI,CAAC,SAAS,CAAC,YAAY,EAAE,CAAA;QAKxC,aAAQ,GAAG,IAAI,eAAe,CAAU,KAAK,CAAC,CAAA;QAC/C,aAAQ,GAAG,IAAI,CAAC,QAAQ,CAAC,YAAY,EAAE,CAAA;QAG9C,eAAU,GAAkC,QAAQ,CAAA;QA6C3D,IAAI,CAAC,oBAAoB,GAAG,IAAI,CAAC,SAAS;aACvC,IAAI,CAAC,GAAG,CAAC,QAAQ,CAAC,EAAE,CAAC,QAAQ,CAAC,CAAC,CAAC,cAAc,CAAC,CAAC,CAAC,eAAe,CAAC,CAAC,CAAA;QAErE,IAAI,CAAC,iBAAiB,GAAG,IAAI,CAAC,QAAQ;aACnC,IAAI,CAAC,GAAG,CAAC,OAAO,CAAC,EAAE,CAAC,OAAO,CAAC,CAAC,CAAC,aAAa,CAAC,CAAC,CAAC,UAAU,CAAC,CAAC,CAAA;IAC/D,CAAC;IA7ED,IACI,IAAI,CAAC,KAAgC,IAAI,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,KAAK,CAAC,CAAA,CAAC,CAAC;IACrE,IAAI,IAAI,KAAK,OAAO,IAAI,CAAC,KAAK,CAAC,KAAK,CAAA,CAAC,CAAC;IAYtC,IACI,QAAQ,CAAC,KAAc,IAAI,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,qBAAqB,CAAC,KAAK,CAAC,CAAC,CAAA,CAAC,CAAC;IAClF,IAAI,QAAQ,KAAK,OAAO,IAAI,CAAC,SAAS,CAAC,KAAK,CAAA,CAAC,CAAC;IAI9C,IACI,OAAO,CAAC,KAAc,IAAI,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,qBAAqB,CAAC,KAAK,CAAC,CAAC,CAAA,CAAC,CAAC;IAChF,IAAI,OAAO,KAAK,OAAO,IAAI,CAAC,QAAQ,CAAC,KAAK,CAAA,CAAC,CAAC;IAY5C,IACI,YAAY,KAAK,OAAO,IAAI,CAAC,aAAa,CAAA,CAAC,CAAC;IAChD,IAAI,YAAY,CAAC,KAA0D;QACzE,IAAI,KAAK,KAAK,IAAI,IAAI,KAAK,KAAK,SAAS,EAAE;YACzC,IAAI,OAAO,KAAK,KAAK,QAAQ,EAAE;gBAC7B,IAAI,CAAC,aAAa,GAAG;oBACnB,OAAO,EAAE,KAAK;oBACd,SAAS,EAAE,MAAM;oBACjB,QAAQ,EAAE,KAAK;oBACf,SAAS,EAAE,MAAM;iBAClB,CAAA;aACF;iBAAM;gBACL,IAAI,CAAC,aAAa,mCACb,KAAK,KACR,SAAS,EAAE,KAAK,CAAC,SAAS,IAAI,MAAM,EACpC,QAAQ,EAAE,OAAO,CAAA,KAAK,aAAL,KAAK,uBAAL,KAAK,CAAE,QAAQ,CAAA,KAAK,SAAS;wBAC5C,CAAC,CAAC,KAAK,CAAC,QAAQ;wBAChB,CAAC,CAAC,OAAO,KAAK,CAAC,OAAO,KAAK,QAAQ,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,IAAI,EACpD,SAAS,EAAE,KAAK,CAAC,SAAS,IAAI,MAAM,GACrC,CAAA;aACF;SACF;aAAM;YACL,IAAI,CAAC,aAAa,GAAG,SAAS,CAAA;SAC/B;IACH,CAAC;IAGD,IAAqD,iBAAiB,KAAK,OAAO,IAAI,CAAC,MAAM,CAAA,CAAC,CAAC;IAE/F,IAAyC,kBAAkB,KAAK,OAAO,IAAI,CAAC,SAAS,CAAA,CAAC,CAAC;IAgBvF,WAAW;QACT,IAAI,CAAC,cAAc,CAAC,IAAI,EAAE,CAAA;QAC1B,IAAI,CAAC,cAAc,CAAC,QAAQ,EAAE,CAAA;IAChC,CAAC;IAED,IAAI,WAAW;QACb,OAAO,KAAK,CAAC,OAAO,CAAC,IAAI,CAAC,QAAQ,CAAC,IAAI,IAAI,CAAC,QAAQ,CAAC,MAAM,GAAG,CAAC,CAAA;IACjE,CAAC;IAEM,cAAc;QACnB,IAAI,CAAC,QAAQ,GAAG,CAAC,IAAI,CAAC,QAAQ,CAAA;IAChC,CAAC;IAED,YAAY;QACV,wDAAwD;QACxD,IAAI,IAAI,CAAC,QAAQ,CAAC,OAAO,EAAE;YACzB,IAAI,CAAC,QAAQ,CAAC,QAAQ,EAAE,CAAA;SACzB;IACH,CAAC;IAED,IAAI,aAAa;QACf,OAAO,kBAAkB,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,IAAI,CAAC,aAAa,KAAK,IAAI,CAAA;IACrE,CAAC;;;YApKF,SAAS,SAAC;gBACT,QAAQ,EAAE,oBAAoB;gBAC9B,o1MAA6C;gBAE7C,QAAQ,EAAE,iBAAiB;gBAC3B,UAAU,EAAE;oBACV,OAAO,CAAC,gBAAgB,EAAE;wBACxB,KAAK,CAAC,cAAc,EAAE,KAAK,CAAC,EAAE,MAAM,EAAE,GAAG,EAAE,CAAC,CAAC;wBAC7C,KAAK,CAAC,eAAe,EAAE,KAAK,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,YAAY,EAAE,QAAQ,EAAE,UAAU,EAAE,QAAQ,EAAE,CAAC,CAAC;wBAC1F,UAAU,CAAC,GAAG,cAAc,QAAQ,eAAe,EAAE,EAAE,OAAO,CAAC,kBAAkB,CAAC,CAAC;qBACpF,CAAC;oBAGF,OAAO,CAAC,aAAa,EAAE;oBACrB,0BAA0B;oBAC1B,sBAAsB;oBACtB,+BAA+B;oBAC/B,2DAA2D;oBAC3D,4BAA4B;oBAC5B,sBAAsB;oBACtB,+BAA+B;oBAC/B,2DAA2D;oBAC3D,2BAA2B;oBAC3B,KAAK;oBAEL,8CAA8C;oBAC9C,iDAAiD;oBACjD,iFAAiF;oBACjF,qDAAqD;oBACrD,0BAA0B;oBAC1B,sBAAsB;oBACtB,+BAA+B;oBAC/B,2DAA2D;oBAC3D,2BAA2B;oBAC3B,MAAM;qBAGP,CAAC;iBACH;gBACD,eAAe,EAAE,uBAAuB,CAAC,MAAM;gBAC/C,aAAa,EAAE,iBAAiB,CAAC,IAAI;;aACtC;;;YA1DQ,gBAAgB;YAsJsC,oBAAoB,uBAA9E,QAAQ,YAAI,QAAQ,YAAI,IAAI;;;uBAhF9B,KAAK;mBAEL,KAAK;4BAEL,KAAK;oBAEL,KAAK;qBAEL,KAAK;mBAEL,KAAK;0BAML,KAAK;uBAEL,KAAK;wBAEL,KAAK;yBAEL,KAAK;uBAEL,KAAK;sBAML,KAAK;wBAML,KAAK;yBACL,KAAK;6BAKL,KAAK;2BAEL,KAAK;gCA2BL,WAAW,SAAC,kCAAkC;iCAE9C,WAAW,SAAC,sBAAsB;;AAjEV;IAAf,YAAY,EAAE;oDAAwB;AAYvB;IAAf,WAAW,CAAC,CAAC,CAAC;uDAAsB;AAEpB;IAAhB,WAAW,CAAC,EAAE,CAAC;wDAAwB","sourcesContent":["import {\n  animate,\n  query,\n  state,\n  style,\n  transition,\n  trigger,\n} from '@angular/animations'\nimport { BooleanInput, coerceBooleanProperty, NumberInput } from '@angular/cdk/coercion'\nimport {\n  ChangeDetectionStrategy,\n  Component,\n  Host,\n  HostBinding,\n  Input,\n  OnDestroy,\n  Optional,\n  SkipSelf,\n  ViewEncapsulation\n} from '@angular/core'\nimport { BehaviorSubject, Observable, Subject } from 'rxjs'\nimport { map } from 'rxjs/operators'\n\nimport { faAngleLeft } from '@fortawesome/free-solid-svg-icons'\n\nimport { InputBoolean, InputNumber } from '@theseam/ui-common/core'\nimport type { SeamIcon } from '@theseam/ui-common/icon'\nimport type { ThemeTypes } from '@theseam/ui-common/models'\n\nimport { notNullOrUndefined } from '@theseam/ui-common/utils'\nimport { SideNavComponent } from '../side-nav.component'\nimport { ISideNavItem } from '../side-nav.models'\n\nexport interface SideNavItemBadgeTooltip {\n  tooltip?: string\n  class?: string\n  placement?: string\n  container?: string\n  disabled?: boolean\n}\n\nconst EXPANDED_STATE = 'expanded'\nconst COLLAPSED_STATE = 'collapsed'\n\nconst FULL_STATE = 'full'\nconst COMPACT_STATE = 'compact'\n\n@Component({\n  selector: 'seam-side-nav-item',\n  templateUrl: './side-nav-item.component.html',\n  styleUrls: ['./side-nav-item.component.scss'],\n  exportAs: 'seamSideNavItem',\n  animations: [\n    trigger('childGroupAnim', [\n      state(EXPANDED_STATE, style({ height: '*' })),\n      state(COLLAPSED_STATE, style({ height: 0, 'overflow-y': 'hidden', visibility: 'hidden' })),\n      transition(`${EXPANDED_STATE} <=> ${COLLAPSED_STATE}`, animate('0.2s ease-in-out')),\n    ]),\n\n\n    trigger('compactAnim', [\n      // transition('* <=> *', [\n      //   query(':enter', [\n      //     style({ opacity: '0' }),\n      //     animate('5.2s ease-in-out', style({ opacity: '1' }))\n      //   ], { optional: true }),\n      //   query(':leave', [\n      //     style({ opacity: '1' }),\n      //     animate('5.2s ease-in-out', style({ opacity: '0' }))\n      //   ], { optional: true })\n      // ])\n\n      // state(FULL_STATE, style({ opacity: '1' })),\n      // state(COMPACT_STATE, style({ opacity: '0' })),\n      // transition(`${FULL_STATE} <=> ${COMPACT_STATE}`, animate('5.2s ease-in-out')),\n      // transition(`${FULL_STATE} <=> ${COMPACT_STATE}`, [\n      // transition('* <=> *', [\n      //   query(':leave', [\n      //     style({ opacity: '1' }),\n      //     animate('5.2s ease-in-out', style({ opacity: '0' }))\n      //   ], { optional: true })\n      // ]),\n\n\n    ])\n  ],\n  changeDetection: ChangeDetectionStrategy.OnPush,\n  encapsulation: ViewEncapsulation.None\n})\nexport class SideNavItemComponent implements OnDestroy {\n  static ngAcceptInputType_hierLevel: NumberInput\n  static ngAcceptInputType_indentSize: NumberInput\n  static ngAcceptInputType_expanded: BooleanInput\n  static ngAcceptInputType_compact: BooleanInput\n  static ngAcceptInputType_active: BooleanInput\n\n  private readonly _ngUnsubscribe = new Subject()\n\n  readonly faAngleLeft = faAngleLeft\n\n  @Input() itemType: 'divider' | 'basic' | 'link' | 'button' | 'title' | undefined | null\n\n  @Input() icon: SeamIcon | undefined | null\n\n  @Input() hideEmptyIcon: boolean | undefined | null\n\n  @Input() label: string | undefined | null\n\n  @Input() @InputBoolean() active: boolean = false\n\n  @Input()\n  set link(value: string | undefined | null) { this._link.next(value) }\n  get link() { return this._link.value }\n  private readonly _link = new BehaviorSubject<string | undefined | null>(undefined)\n  public readonly link$ = this._link.asObservable()\n\n  @Input() queryParams: { [k: string]: any } | undefined | null\n\n  @Input() children: ISideNavItem[] | undefined | null\n\n  @Input() @InputNumber(0) hierLevel: number = 0\n\n  @Input() @InputNumber(10) indentSize: number = 10\n\n  @Input()\n  set expanded(value: boolean) { this._expanded.next(coerceBooleanProperty(value)) }\n  get expanded() { return this._expanded.value }\n  private readonly _expanded = new BehaviorSubject<boolean>(false)\n  public readonly expanded$ = this._expanded.asObservable()\n\n  @Input()\n  set compact(value: boolean) { this._compact.next(coerceBooleanProperty(value)) }\n  get compact() { return this._compact.value }\n  private readonly _compact = new BehaviorSubject<boolean>(false)\n  public readonly compact$ = this._compact.asObservable()\n\n  @Input() badgeText: string | undefined | null\n  @Input() badgeTheme: ThemeTypes | undefined | null = 'danger'\n\n  /**\n   * Content to provide to assistive technology, such as screen readers.\n   */\n  @Input() badgeSrContent: string | undefined | null\n\n  @Input()\n  get badgeTooltip() { return this._badgeTooltip }\n  set badgeTooltip(value: string | SideNavItemBadgeTooltip | undefined | null) {\n    if (value !== null && value !== undefined) {\n      if (typeof value === 'string') {\n        this._badgeTooltip = {\n          tooltip: value,\n          placement: 'auto',\n          disabled: false,\n          container: 'body'\n        }\n      } else {\n        this._badgeTooltip = {\n          ...value,\n          placement: value.placement || 'auto',\n          disabled: typeof value?.disabled === 'boolean'\n            ? value.disabled\n            : typeof value.tooltip === 'string' ? false : true,\n          container: value.container || 'body'\n        }\n      }\n    } else {\n      this._badgeTooltip = undefined\n    }\n  }\n  private _badgeTooltip: SideNavItemBadgeTooltip | undefined | null\n\n  @HostBinding('class.seam-side-nav-item--active') get _isActiveCssClass() { return this.active }\n\n  @HostBinding('attr.data-hier-level') get _attrDataHierLevel() { return this.hierLevel }\n\n  public readonly childGroupAnimState$: Observable<string>\n  public readonly compactAnimState$: Observable<string>\n\n  constructor(\n    private readonly _sideNav: SideNavComponent,\n    @Optional() @SkipSelf() @Host() private readonly _parent?: SideNavItemComponent\n  ) {\n    this.childGroupAnimState$ = this.expanded$\n      .pipe(map(expanded => expanded ? EXPANDED_STATE : COLLAPSED_STATE))\n\n    this.compactAnimState$ = this.compact$\n      .pipe(map(compact => compact ? COMPACT_STATE : FULL_STATE))\n  }\n\n  ngOnDestroy() {\n    this._ngUnsubscribe.next()\n    this._ngUnsubscribe.complete()\n  }\n\n  get hasChildren() {\n    return Array.isArray(this.children) && this.children.length > 0\n  }\n\n  public toggleChildren(): void {\n    this.expanded = !this.expanded\n  }\n\n  _linkClicked() {\n    // Close nav when link is clicked while in overlay state\n    if (this._sideNav.overlay) {\n      this._sideNav.collapse()\n    }\n  }\n\n  get showIconBlock(): boolean {\n    return notNullOrUndefined(this.icon) || this.hideEmptyIcon !== true\n  }\n\n}\n"]}