@fundamental-ngx/cx 0.38.3-rc.2 → 0.38.3-rc.4

package/README.md

@@ -43,7 +43,7 @@ Check the [Breaking Changes](https://github.com/SAP/fundamental-ngx/wiki#breakin
 For an existing Angular CLI application,
 
 0. **Video tutorial**
-   [How to use the Fundamental Core Library](https://www.youtube.com/watch?v=i4VIiuzD2Fg)
+   [How to use the Fundamental Cx Library](https://www.youtube.com/watch?v=i4VIiuzD2Fg)
 
 1. **Install Fundamental-NGX.**
    `ng add @fundamental-ngx/cx`

package/esm2020/fundamental-ngx-cx.module.mjs

@@ -0,0 +1,19 @@
+import { NgModule } from '@angular/core';
+import { CommonModule } from '@angular/common';
+import { CxNestedListModule } from '@fundamental-ngx/cx/nested-list';
+import { CxSideNavigationModule } from '@fundamental-ngx/cx/side-navigation';
+import * as i0 from "@angular/core";
+export class FundamentalNgxCxModule {
+}
+FundamentalNgxCxModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.0.2", ngImport: i0, type: FundamentalNgxCxModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+FundamentalNgxCxModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "15.0.2", ngImport: i0, type: FundamentalNgxCxModule, imports: [CommonModule], exports: [CxNestedListModule, CxSideNavigationModule] });
+FundamentalNgxCxModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "15.0.2", ngImport: i0, type: FundamentalNgxCxModule, imports: [CommonModule, CxNestedListModule, CxSideNavigationModule] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.0.2", ngImport: i0, type: FundamentalNgxCxModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [CommonModule],
+                    declarations: [],
+                    exports: [CxNestedListModule, CxSideNavigationModule]
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZnVuZGFtZW50YWwtbmd4LWN4Lm1vZHVsZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL2xpYnMvY3gvc3JjL2xpYi9mdW5kYW1lbnRhbC1uZ3gtY3gubW9kdWxlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxRQUFRLEVBQUUsTUFBTSxlQUFlLENBQUM7QUFDekMsT0FBTyxFQUFFLFlBQVksRUFBRSxNQUFNLGlCQUFpQixDQUFDO0FBQy9DLE9BQU8sRUFBRSxrQkFBa0IsRUFBRSxNQUFNLGlDQUFpQyxDQUFDO0FBQ3JFLE9BQU8sRUFBRSxzQkFBc0IsRUFBRSxNQUFNLHFDQUFxQyxDQUFDOztBQU83RSxNQUFNLE9BQU8sc0JBQXNCOzttSEFBdEIsc0JBQXNCO29IQUF0QixzQkFBc0IsWUFKckIsWUFBWSxhQUVaLGtCQUFrQixFQUFFLHNCQUFzQjtvSEFFM0Msc0JBQXNCLFlBSnJCLFlBQVksRUFFWixrQkFBa0IsRUFBRSxzQkFBc0I7MkZBRTNDLHNCQUFzQjtrQkFMbEMsUUFBUTttQkFBQztvQkFDTixPQUFPLEVBQUUsQ0FBQyxZQUFZLENBQUM7b0JBQ3ZCLFlBQVksRUFBRSxFQUFFO29CQUNoQixPQUFPLEVBQUUsQ0FBQyxrQkFBa0IsRUFBRSxzQkFBc0IsQ0FBQztpQkFDeEQiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBOZ01vZHVsZSB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuaW1wb3J0IHsgQ29tbW9uTW9kdWxlIH0gZnJvbSAnQGFuZ3VsYXIvY29tbW9uJztcbmltcG9ydCB7IEN4TmVzdGVkTGlzdE1vZHVsZSB9IGZyb20gJ0BmdW5kYW1lbnRhbC1uZ3gvY3gvbmVzdGVkLWxpc3QnO1xuaW1wb3J0IHsgQ3hTaWRlTmF2aWdhdGlvbk1vZHVsZSB9IGZyb20gJ0BmdW5kYW1lbnRhbC1uZ3gvY3gvc2lkZS1uYXZpZ2F0aW9uJztcblxuQE5nTW9kdWxlKHtcbiAgICBpbXBvcnRzOiBbQ29tbW9uTW9kdWxlXSxcbiAgICBkZWNsYXJhdGlvbnM6IFtdLFxuICAgIGV4cG9ydHM6IFtDeE5lc3RlZExpc3RNb2R1bGUsIEN4U2lkZU5hdmlnYXRpb25Nb2R1bGVdXG59KVxuZXhwb3J0IGNsYXNzIEZ1bmRhbWVudGFsTmd4Q3hNb2R1bGUge31cbiJdfQ==

package/esm2020/nested-list/fundamental-ngx-cx-nested-list.mjs

@@ -0,0 +1,5 @@
+/**
+ * Generated bundle index. Do not edit.
+ */
+export * from './public_api';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZnVuZGFtZW50YWwtbmd4LWN4LW5lc3RlZC1saXN0LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vbGlicy9jeC9zcmMvbGliL25lc3RlZC1saXN0L2Z1bmRhbWVudGFsLW5neC1jeC1uZXN0ZWQtbGlzdC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7R0FFRztBQUVILGNBQWMsY0FBYyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBHZW5lcmF0ZWQgYnVuZGxlIGluZGV4LiBEbyBub3QgZWRpdC5cbiAqL1xuXG5leHBvcnQgKiBmcm9tICcuL3B1YmxpY19hcGknO1xuIl19

package/esm2020/nested-list/nested-content/nested-list-content.directive.mjs

@@ -0,0 +1,131 @@
+import { ChangeDetectorRef, ContentChild, Directive, ElementRef, EventEmitter, HostBinding, HostListener, Input, Output, Renderer2 } from '@angular/core';
+import { NestedLinkComponent } from '../nested-link/nested-link.component';
+import { NestedListExpandIconComponent } from '../nested-list-directives';
+import { NestedItemService } from '../nested-item/nested-item.service';
+import { Subject } from 'rxjs';
+import { takeUntil } from 'rxjs/operators';
+import * as i0 from "@angular/core";
+import * as i1 from "../nested-item/nested-item.service";
+export class NestedListContentDirective {
+    /** @hidden */
+    constructor(changeDetRef, _renderer, _elementRef, _itemService) {
+        this.changeDetRef = changeDetRef;
+        this._renderer = _renderer;
+        this._elementRef = _elementRef;
+        this._itemService = _itemService;
+        /** Whether this element is selected*/
+        this.selected = false;
+        /** @hidden */
+        this.role = 'treeitem';
+        /** @hidden */
+        this.ariaExpanded = false;
+        /** Event thrown, when selected state is changed */
+        this.selectedChange = new EventEmitter();
+        /** Event that is thrown, when any keyboard event is dispatched on this element */
+        this.keyboardTriggered = new EventEmitter();
+        /** Event that is thrown, when this element is clicked */
+        this.clicked = new EventEmitter();
+        /** @hidden */
+        this.cxNestedListContentClass = true;
+        /**
+         * @hidden
+         * Attribute controlled by the parent `NestedItemComponent`
+         */
+        this.hasChildren = false;
+        /** An RxJS Subject that will kill the data stream upon component’s destruction (for unsubscribing)  */
+        this.onDestroy$ = new Subject();
+    }
+    /** @hidden */
+    ngAfterContentInit() {
+        this._makeLinkUnFocusable();
+        this._setFocusSubscription();
+    }
+    /** @hidden */
+    ngOnDestroy() {
+        this.onDestroy$.next();
+        this.onDestroy$.complete();
+    }
+    /** Keyboard Event Handler */
+    onKeyDown(event) {
+        this.keyboardTriggered.emit(event);
+        this._itemService.keyDown.next(event);
+    }
+    /** Handler for mouse events */
+    onClick() {
+        this._itemService.click.next();
+    }
+    /** Method to trigger selected state change */
+    changeSelected(selected) {
+        this.selected = selected;
+        this.selectedChange.emit(selected);
+    }
+    /** Set focus on the element. */
+    focus() {
+        this._elementRef.nativeElement.focus();
+    }
+    /** Dispatches the click event on the element */
+    click() {
+        this.focus();
+        if (this.nestedLink) {
+            this.nestedLink.click();
+        }
+    }
+    /** Add subscription for child focusing */
+    _setFocusSubscription() {
+        this._itemService.focus.pipe(takeUntil(this.onDestroy$)).subscribe(() => this.focus());
+    }
+    /** Hide link child element from tab key */
+    _makeLinkUnFocusable() {
+        if (this.nestedLink) {
+            this.nestedLink.elementRef.nativeElement.tabIndex = -1;
+            this.changeDetRef.detectChanges();
+        }
+    }
+}
+NestedListContentDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.0.2", ngImport: i0, type: NestedListContentDirective, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.Renderer2 }, { token: i0.ElementRef }, { token: i1.NestedItemService }], target: i0.ɵɵFactoryTarget.Directive });
+NestedListContentDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "15.0.2", type: NestedListContentDirective, selector: "[cxNestedListContent], [fdx-nested-list-content]", inputs: { selected: "selected" }, outputs: { selectedChange: "selectedChange", keyboardTriggered: "keyboardTriggered", clicked: "clicked" }, host: { attributes: { "tabindex": "0" }, listeners: { "keydown": "onKeyDown($event)", "click": "onClick($event)" }, properties: { "class.is-selected": "this.selected", "attr.role": "this.role", "attr.aria-expanded": "this.ariaExpanded", "class.fdx-nested-list__content": "this.cxNestedListContentClass", "class.has-child": "this.hasChildren" } }, queries: [{ propertyName: "nestedLink", first: true, predicate: NestedLinkComponent, descendants: true }, { propertyName: "nestedExpandIcon", first: true, predicate: NestedListExpandIconComponent, descendants: true }], ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.0.2", ngImport: i0, type: NestedListContentDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[cxNestedListContent], [fdx-nested-list-content]',
+                    host: {
+                        tabindex: '0'
+                    }
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ChangeDetectorRef }, { type: i0.Renderer2 }, { type: i0.ElementRef }, { type: i1.NestedItemService }]; }, propDecorators: { selected: [{
+                type: Input
+            }, {
+                type: HostBinding,
+                args: ['class.is-selected']
+            }], role: [{
+                type: HostBinding,
+                args: ['attr.role']
+            }], ariaExpanded: [{
+                type: HostBinding,
+                args: ['attr.aria-expanded']
+            }], selectedChange: [{
+                type: Output
+            }], keyboardTriggered: [{
+                type: Output
+            }], clicked: [{
+                type: Output
+            }], cxNestedListContentClass: [{
+                type: HostBinding,
+                args: ['class.fdx-nested-list__content']
+            }], hasChildren: [{
+                type: HostBinding,
+                args: ['class.has-child']
+            }], nestedLink: [{
+                type: ContentChild,
+                args: [NestedLinkComponent]
+            }], nestedExpandIcon: [{
+                type: ContentChild,
+                args: [NestedListExpandIconComponent]
+            }], onKeyDown: [{
+                type: HostListener,
+                args: ['keydown', ['$event']]
+            }], onClick: [{
+                type: HostListener,
+                args: ['click', ['$event']]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"nested-list-content.directive.js","sourceRoot":"","sources":["../../../../../../libs/cx/src/lib/nested-list/nested-content/nested-list-content.directive.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n    AfterContentInit,\n    ChangeDetectorRef,\n    ContentChild,\n    Directive,\n    ElementRef,\n    EventEmitter,\n    HostBinding,\n    HostListener,\n    Input,\n    OnDestroy,\n    Output,\n    Renderer2\n} from '@angular/core';\nimport { NestedLinkComponent } from '../nested-link/nested-link.component';\nimport { NestedListExpandIconComponent } from '../nested-list-directives';\nimport { NestedItemService } from '../nested-item/nested-item.service';\nimport { Subject } from 'rxjs';\nimport { takeUntil } from 'rxjs/operators';\n\n@Directive({\n    selector: '[cxNestedListContent], [fdx-nested-list-content]',\n    host: {\n        tabindex: '0'\n    }\n})\nexport class NestedListContentDirective implements AfterContentInit, OnDestroy {\n    /** Whether this element is selected*/\n    @Input()\n    @HostBinding('class.is-selected')\n    selected = false;\n\n    /** @hidden */\n    @HostBinding('attr.role')\n    role = 'treeitem';\n\n    /** @hidden */\n    @HostBinding('attr.aria-expanded')\n    ariaExpanded = false;\n\n    /** Event thrown, when selected state is changed */\n    @Output()\n    selectedChange: EventEmitter<boolean> = new EventEmitter<boolean>();\n\n    /** Event that is thrown, when any keyboard event is dispatched on this element */\n    @Output()\n    readonly keyboardTriggered: EventEmitter<KeyboardEvent> = new EventEmitter<KeyboardEvent>();\n\n    /** Event that is thrown, when this element is clicked */\n    @Output()\n    readonly clicked: EventEmitter<MouseEvent> = new EventEmitter<MouseEvent>();\n\n    /** @hidden */\n    @HostBinding('class.fdx-nested-list__content')\n    cxNestedListContentClass = true;\n\n    /**\n     * @hidden\n     * Attribute controlled by the parent `NestedItemComponent`\n     */\n    @HostBinding('class.has-child')\n    hasChildren = false;\n\n    /** @hidden */\n    @ContentChild(NestedLinkComponent)\n    nestedLink: NestedLinkComponent;\n\n    /** @hidden */\n    @ContentChild(NestedListExpandIconComponent)\n    nestedExpandIcon: NestedListExpandIconComponent;\n\n    /** An RxJS Subject that will kill the data stream upon component’s destruction (for unsubscribing)  */\n    private readonly onDestroy$: Subject<void> = new Subject<void>();\n\n    /** @hidden */\n    constructor(\n        public changeDetRef: ChangeDetectorRef,\n        private _renderer: Renderer2,\n        private _elementRef: ElementRef,\n        private _itemService: NestedItemService\n    ) {}\n\n    /** @hidden */\n    ngAfterContentInit(): void {\n        this._makeLinkUnFocusable();\n        this._setFocusSubscription();\n    }\n\n    /** @hidden */\n    ngOnDestroy(): void {\n        this.onDestroy$.next();\n        this.onDestroy$.complete();\n    }\n\n    /** Keyboard Event Handler */\n    @HostListener('keydown', ['$event'])\n    onKeyDown(event: KeyboardEvent): void {\n        this.keyboardTriggered.emit(event);\n        this._itemService.keyDown.next(event);\n    }\n\n    /** Handler for mouse events */\n    @HostListener('click', ['$event'])\n    onClick(): void {\n        this._itemService.click.next();\n    }\n\n    /** Method to trigger selected state change */\n    changeSelected(selected: boolean): void {\n        this.selected = selected;\n        this.selectedChange.emit(selected);\n    }\n\n    /** Set focus on the element. */\n    focus(): void {\n        this._elementRef.nativeElement.focus();\n    }\n\n    /** Dispatches the click event on the element */\n    click(): void {\n        this.focus();\n        if (this.nestedLink) {\n            this.nestedLink.click();\n        }\n    }\n\n    /** Add subscription for child focusing */\n    private _setFocusSubscription(): void {\n        this._itemService.focus.pipe(takeUntil(this.onDestroy$)).subscribe(() => this.focus());\n    }\n\n    /** Hide link child element from tab key */\n    private _makeLinkUnFocusable(): void {\n        if (this.nestedLink) {\n            this.nestedLink.elementRef.nativeElement.tabIndex = -1;\n            this.changeDetRef.detectChanges();\n        }\n    }\n}\n"]}

package/esm2020/nested-list/nested-item/nested-item.component.mjs

@@ -0,0 +1,290 @@
+import { ContentChild, Component, ElementRef, EventEmitter, HostBinding, Input, Output, forwardRef } from '@angular/core';
+import { Subject } from 'rxjs';
+import { filter, takeUntil } from 'rxjs/operators';
+import { NestedLinkComponent } from '../nested-link/nested-link.component';
+import { NestedListKeyboardService } from '../nested-list-keyboard.service';
+import { NestedListContentDirective } from '../nested-content/nested-list-content.directive';
+import { NestedListStateService } from '../nested-list-state.service';
+import { NestedItemService } from './nested-item.service';
+import { NestedListComponent } from '../nested-list/nested-list.component';
+import { NestedListExpandIconComponent } from '../nested-list-directives';
+import * as i0 from "@angular/core";
+import * as i1 from "./nested-item.service";
+import * as i2 from "../nested-list-keyboard.service";
+import * as i3 from "../nested-list-state.service";
+let sideNavigationItemUniqueId = 0;
+export class NestedItemComponent {
+    /** @hidden */
+    constructor(_itemService, _keyboardService, _stateService, elementRef) {
+        this._itemService = _itemService;
+        this._keyboardService = _keyboardService;
+        this._stateService = _stateService;
+        this.elementRef = elementRef;
+        /** Event thrown, when expanded state is changed */
+        this.expandedChange = new EventEmitter();
+        /** Event thrown, when any keyboard event is dispatched on this, or link element */
+        this.keyboardTriggered = new EventEmitter();
+        /** @hidden */
+        this.fdNestedListItemClass = true;
+        /** Whether this item is a header item. */
+        this.header = false;
+        /** Whether this item is only meant for display purposes, meaning it cannot be used for navigation or shown as selected. */
+        this.display = false;
+        /** @hidden */
+        this._ariaLevel = null;
+        /** @hidden */
+        this._display = 'block';
+        /** @hidden */
+        this._narrow = false;
+        /** @hidden */
+        this._expanded = false;
+        /** @hidden */
+        this._ariaExpanded = null;
+        /** @hidden */
+        this._ariaSelected = null;
+        /** @hidden */
+        this._ariaDisabled = false;
+        /** @hidden */
+        this._ariaHidden = true;
+        /** An RxJS Subject that will kill the data stream upon component’s destruction (for unsubscribing)  */
+        this._onDestroy$ = new Subject();
+        /** Unique element ID */
+        this._elementId = 'fdNestedItem' + sideNavigationItemUniqueId++;
+    }
+    /** Whether item should be expanded */
+    set expanded(expanded) {
+        if (expanded !== this._expanded) {
+            this.propagateOpenChange(expanded);
+        }
+    }
+    /** @hidden */
+    get expanded() {
+        return this._expanded;
+    }
+    /** @hidden */
+    ngAfterContentInit() {
+        this._setUpSubscriptions();
+        this._propagateHasChildrenProperty();
+        this._passItemReferences();
+        /** Propagate initial open state to children */
+        this.propagateOpenChange(this._expanded);
+        if (this.linkItem) {
+            this._ariaSelected = this.linkItem.selected;
+            this._ariaDisabled = !this._stateService.selectable && !this.linkItem.selected;
+            this._title = this.linkItem.getTitle();
+        }
+    }
+    /** @hidden */
+    ngOnDestroy() {
+        this._onDestroy$.next();
+        this._onDestroy$.complete();
+    }
+    /** Check if the item element has any child */
+    get hasChildren() {
+        return !!this._itemService?.list;
+    }
+    /** Get all of the children item elements */
+    get allChildrenItems() {
+        if (this._itemService?.list) {
+            return this._itemService.list.nestedItems.toArray();
+        }
+        return [];
+    }
+    /** Method that expand the item and propagate it to children */
+    triggerOpen() {
+        if (!this.expanded) {
+            /** Propagate initial open state to children */
+            this.propagateOpenChange(true);
+        }
+    }
+    /** Method that close the item and propagate it to children */
+    triggerClose() {
+        if (this.expanded) {
+            /** Propagate initial open state to children */
+            this.propagateOpenChange(false);
+        }
+    }
+    /** Method that toggle the item and propagate it to children */
+    toggle() {
+        /** Propagate initial open state to children */
+        this.propagateOpenChange(!this._expanded);
+    }
+    /** Method that dispatches `click` event on link item*/
+    click() {
+        if (!this.display) {
+            if (this.contentItem) {
+                this.contentItem.click();
+            }
+            else if (this.linkItem) {
+                this.linkItem.click();
+            }
+        }
+    }
+    /** Method that focuses link item*/
+    focus() {
+        if (this.contentItem) {
+            this.contentItem.focus();
+        }
+        else if (this.linkItem) {
+            this.linkItem.focus();
+        }
+    }
+    /** Method that provides information if element, or children of this element has passed id */
+    containsId(id) {
+        if (this._elementId === id) {
+            return true;
+        }
+        if (this._itemService.list) {
+            return !!this._itemService.list.nestedItems.find((item) => item.containsId(id));
+        }
+        return false;
+    }
+    /**
+     * @hidden
+     * Propagate open state to all of the children
+     */
+    propagateOpenChange(open) {
+        this._expanded = open;
+        if (this.hasChildren) {
+            this._ariaExpanded = this._expanded;
+        }
+        this.expandIcon?.changeExpandedState(open);
+        /** Propagate hidden flag to list component, that is passed from child */
+        if (this._itemService.list) {
+            this._itemService.list.hidden = !open;
+            this._itemService.list.detectChanges();
+        }
+        /** Propagate open flag to popover list component, that is passed from child */
+        if (this._itemService.popover) {
+            this._itemService.popover.open = open;
+        }
+        /**
+         * If there are any list below
+         * Trigger event to provide keyboard support to new list of opened item element.
+         * */
+        if (this._shouldRefreshKeyboardService()) {
+            this._keyboardService.refresh$.next();
+        }
+        this.expandedChange.emit(open);
+    }
+    /** @hidden */
+    _shouldRefreshKeyboardService() {
+        return !!(this._itemService.popover || this._itemService.list || this.contentItem);
+    }
+    /** @hidden */
+    _setUpSubscriptions() {
+        if (this._stateService.condensed) {
+            this._role = 'menuitemradio';
+        }
+        if (!this.display) {
+            /** Subscribe to mouse click event, thrown by link item */
+            this._itemService.toggle.pipe(takeUntil(this._onDestroy$)).subscribe(() => this.toggle());
+            /** Subscribe to mouse click event, thrown by link item */
+            this._itemService.click
+                .pipe(takeUntil(this._onDestroy$))
+                .subscribe(() => this._stateService.onSelected.next(this._elementId));
+        }
+        /** Subscribe to keyboard event and throw it farther */
+        this._itemService.keyDown
+            .pipe(takeUntil(this._onDestroy$))
+            .subscribe((keyboardEvent) => this.keyboardTriggered.emit(keyboardEvent));
+        /** Subscribe to selected state change, it's not triggered, when selectable flag is disabled*/
+        this._stateService.onSelected
+            .pipe(takeUntil(this._onDestroy$), filter(() => this._stateService.selectable))
+            .subscribe((id) => this._selectedChange(id));
+    }
+    /** @hidden */
+    _propagateHasChildrenProperty() {
+        if (this.contentItem && this.hasChildren) {
+            this._ariaExpanded = false;
+            this.contentItem.hasChildren = true;
+            this.contentItem.changeDetRef.detectChanges();
+        }
+    }
+    /** Pass this element to popover child item, to allow control `expanded` value */
+    _passItemReferences() {
+        if (this._itemService.popover) {
+            this._itemService.popover.parentItemElement = this;
+        }
+    }
+    /** Change of selected state of content or link, if there is any children with I */
+    _selectedChange(id) {
+        const selected = this.containsId(id);
+        this._ariaSelected = selected;
+        if (this.contentItem) {
+            this.contentItem.changeSelected(selected);
+        }
+        else if (this.linkItem) {
+            this.linkItem.changeSelected(selected);
+        }
+    }
+}
+NestedItemComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.0.2", ngImport: i0, type: NestedItemComponent, deps: [{ token: i1.NestedItemService }, { token: i2.NestedListKeyboardService }, { token: i3.NestedListStateService }, { token: i0.ElementRef }], target: i0.ɵɵFactoryTarget.Component });
+NestedItemComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "15.0.2", type: NestedItemComponent, selector: "[cxNestedItem], [fdx-nested-list-item], li[fdx-nested-list-item]", inputs: { expanded: "expanded", fdNestedListItemClass: "fdNestedListItemClass", header: "header", display: "display" }, outputs: { expandedChange: "expandedChange", keyboardTriggered: "keyboardTriggered" }, host: { properties: { "class.fdx-nested-list__item": "this.fdNestedListItemClass", "class.fdx-nested-list__item--header": "this.header", "attr.aria-level": "this._ariaLevel", "attr.title": "this._title", "style.display": "this._display", "attr.role": "this._role", "attr.aria-expanded": "this._ariaExpanded", "attr.aria-selected": "this._ariaSelected", "attr.aria-disabled": "this._ariaDisabled", "attr.aria-label": "this._ariaLabel", "attr.aria-hidden": "this._ariaHidden" } }, providers: [NestedItemService], queries: [{ propertyName: "linkItem", first: true, predicate: NestedLinkComponent, descendants: true }, { propertyName: "contentItem", first: true, predicate: NestedListContentDirective, descendants: true }, { propertyName: "expandIcon", first: true, predicate: NestedListExpandIconComponent, descendants: true }, { propertyName: "_nestedList", first: true, predicate: i0.forwardRef(function () { return NestedListComponent; }), descendants: true }], ngImport: i0, template: ` <ng-content></ng-content> `, isInline: true });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.0.2", ngImport: i0, type: NestedItemComponent, decorators: [{
+            type: Component,
+            args: [{
+                    // eslint-disable-next-line @angular-eslint/component-selector
+                    selector: '[cxNestedItem], [fdx-nested-list-item], li[fdx-nested-list-item]',
+                    template: ` <ng-content></ng-content> `,
+                    providers: [NestedItemService]
+                }]
+        }], ctorParameters: function () { return [{ type: i1.NestedItemService }, { type: i2.NestedListKeyboardService }, { type: i3.NestedListStateService }, { type: i0.ElementRef }]; }, propDecorators: { expanded: [{
+                type: Input
+            }], expandedChange: [{
+                type: Output
+            }], keyboardTriggered: [{
+                type: Output
+            }], fdNestedListItemClass: [{
+                type: Input
+            }, {
+                type: HostBinding,
+                args: ['class.fdx-nested-list__item']
+            }], header: [{
+                type: Input
+            }, {
+                type: HostBinding,
+                args: ['class.fdx-nested-list__item--header']
+            }], display: [{
+                type: Input
+            }], linkItem: [{
+                type: ContentChild,
+                args: [NestedLinkComponent]
+            }], contentItem: [{
+                type: ContentChild,
+                args: [NestedListContentDirective]
+            }], expandIcon: [{
+                type: ContentChild,
+                args: [NestedListExpandIconComponent, { descendants: true }]
+            }], _nestedList: [{
+                type: ContentChild,
+                args: [forwardRef(() => NestedListComponent)]
+            }], _ariaLevel: [{
+                type: HostBinding,
+                args: ['attr.aria-level']
+            }], _title: [{
+                type: HostBinding,
+                args: ['attr.title']
+            }], _display: [{
+                type: HostBinding,
+                args: ['style.display']
+            }], _role: [{
+                type: HostBinding,
+                args: ['attr.role']
+            }], _ariaExpanded: [{
+                type: HostBinding,
+                args: ['attr.aria-expanded']
+            }], _ariaSelected: [{
+                type: HostBinding,
+                args: ['attr.aria-selected']
+            }], _ariaDisabled: [{
+                type: HostBinding,
+                args: ['attr.aria-disabled']
+            }], _ariaLabel: [{
+                type: HostBinding,
+                args: ['attr.aria-label']
+            }], _ariaHidden: [{
+                type: HostBinding,
+                args: ['attr.aria-hidden']
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"nested-item.component.js","sourceRoot":"","sources":["../../../../../../libs/cx/src/lib/nested-list/nested-item/nested-item.component.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n    AfterContentInit,\n    ContentChild,\n    Component,\n    ElementRef,\n    EventEmitter,\n    HostBinding,\n    Input,\n    OnDestroy,\n    Output,\n    forwardRef\n} from '@angular/core';\nimport { Subject } from 'rxjs';\nimport { filter, takeUntil } from 'rxjs/operators';\n\nimport { NestedLinkComponent } from '../nested-link/nested-link.component';\nimport { NestedListKeyboardService } from '../nested-list-keyboard.service';\nimport { NestedListContentDirective } from '../nested-content/nested-list-content.directive';\nimport { NestedListStateService } from '../nested-list-state.service';\nimport { NestedItemInterface } from './nested-item.interface';\nimport { NestedItemService } from './nested-item.service';\nimport { Nullable } from '@fundamental-ngx/core/shared';\nimport { NestedListComponent } from '../nested-list/nested-list.component';\nimport { NestedListExpandIconComponent } from '../nested-list-directives';\n\nlet sideNavigationItemUniqueId = 0;\n\n@Component({\n    // eslint-disable-next-line @angular-eslint/component-selector\n    selector: '[cxNestedItem], [fdx-nested-list-item], li[fdx-nested-list-item]',\n    template: ` <ng-content></ng-content> `,\n    providers: [NestedItemService]\n})\nexport class NestedItemComponent implements AfterContentInit, NestedItemInterface, OnDestroy {\n    /** Whether item should be expanded */\n    @Input() set expanded(expanded: boolean) {\n        if (expanded !== this._expanded) {\n            this.propagateOpenChange(expanded);\n        }\n    }\n\n    /** @hidden */\n    get expanded(): boolean {\n        return this._expanded;\n    }\n\n    /** Event thrown, when expanded state is changed */\n    @Output()\n    readonly expandedChange: EventEmitter<boolean> = new EventEmitter<boolean>();\n\n    /** Event thrown, when any keyboard event is dispatched on this, or link element */\n    @Output()\n    readonly keyboardTriggered: EventEmitter<KeyboardEvent> = new EventEmitter<KeyboardEvent>();\n\n    /** @hidden */\n    @Input()\n    @HostBinding('class.fdx-nested-list__item')\n    fdNestedListItemClass = true;\n\n    /** Whether this item is a header item. */\n    @Input()\n    @HostBinding('class.fdx-nested-list__item--header')\n    header = false;\n\n    /** Whether this item is only meant for display purposes, meaning it cannot be used for navigation or shown as selected. */\n    @Input()\n    display = false;\n\n    /**\n     * @hidden\n     * Reference to the link directive, to allow manipulating the properties of this element.\n     */\n    @ContentChild(NestedLinkComponent)\n    linkItem: NestedLinkComponent;\n\n    /**\n     * @hidden\n     * Mostly used, when this item has list\n     * Reference to the content directive, to allow manipulating the properties of this element.\n     */\n    @ContentChild(NestedListContentDirective)\n    contentItem: NestedListContentDirective;\n\n    /** @hidden */\n    @ContentChild(NestedListExpandIconComponent, { descendants: true })\n    expandIcon: NestedListExpandIconComponent;\n\n    /** @hidden */\n    @ContentChild(forwardRef(() => NestedListComponent))\n    _nestedList: NestedListComponent;\n\n    /** @hidden */\n    @HostBinding('attr.aria-level')\n    _ariaLevel: Nullable<number> = null;\n\n    /** @hidden */\n    @HostBinding('attr.title')\n    _title: string;\n\n    /** @hidden */\n    @HostBinding('style.display')\n    _display = 'block';\n\n    /** @hidden */\n    _narrow = false;\n\n    /** @hidden */\n    @HostBinding('attr.role')\n    private _role: string;\n\n    /** @hidden */\n    private _expanded = false;\n\n    /** @hidden */\n    @HostBinding('attr.aria-expanded')\n    private _ariaExpanded: Nullable<boolean> = null;\n\n    /** @hidden */\n    @HostBinding('attr.aria-selected')\n    private _ariaSelected: Nullable<boolean> = null;\n\n    /** @hidden */\n    @HostBinding('attr.aria-disabled')\n    private _ariaDisabled = false;\n\n    /** @hidden */\n    @HostBinding('attr.aria-label')\n    private _ariaLabel: string;\n\n    /** @hidden */\n    @HostBinding('attr.aria-hidden')\n    private _ariaHidden = true;\n\n    /** An RxJS Subject that will kill the data stream upon component’s destruction (for unsubscribing)  */\n    private readonly _onDestroy$: Subject<void> = new Subject<void>();\n\n    /** Unique element ID */\n    private readonly _elementId: string = 'fdNestedItem' + sideNavigationItemUniqueId++;\n\n    /** @hidden */\n    constructor(\n        private _itemService: NestedItemService,\n        private _keyboardService: NestedListKeyboardService,\n        private _stateService: NestedListStateService,\n        public elementRef: ElementRef\n    ) {}\n\n    /** @hidden */\n    ngAfterContentInit(): void {\n        this._setUpSubscriptions();\n        this._propagateHasChildrenProperty();\n        this._passItemReferences();\n        /** Propagate initial open state to children */\n        this.propagateOpenChange(this._expanded);\n\n        if (this.linkItem) {\n            this._ariaSelected = this.linkItem.selected;\n            this._ariaDisabled = !this._stateService.selectable && !this.linkItem.selected;\n            this._title = this.linkItem.getTitle();\n        }\n    }\n\n    /** @hidden */\n    ngOnDestroy(): void {\n        this._onDestroy$.next();\n        this._onDestroy$.complete();\n    }\n\n    /** Check if the item element has any child */\n    get hasChildren(): boolean {\n        return !!this._itemService?.list;\n    }\n\n    /** Get all of the children item elements */\n    get allChildrenItems(): NestedItemInterface[] {\n        if (this._itemService?.list) {\n            return this._itemService.list.nestedItems.toArray();\n        }\n\n        return [];\n    }\n\n    /** Method that expand the item and propagate it to children */\n    triggerOpen(): void {\n        if (!this.expanded) {\n            /** Propagate initial open state to children */\n            this.propagateOpenChange(true);\n        }\n    }\n\n    /** Method that close the item and propagate it to children */\n    triggerClose(): void {\n        if (this.expanded) {\n            /** Propagate initial open state to children */\n            this.propagateOpenChange(false);\n        }\n    }\n\n    /** Method that toggle the item and propagate it to children */\n    toggle(): void {\n        /** Propagate initial open state to children */\n        this.propagateOpenChange(!this._expanded);\n    }\n\n    /** Method that dispatches `click` event on link item*/\n    click(): void {\n        if (!this.display) {\n            if (this.contentItem) {\n                this.contentItem.click();\n            } else if (this.linkItem) {\n                this.linkItem.click();\n            }\n        }\n    }\n\n    /** Method that focuses link item*/\n    focus(): void {\n        if (this.contentItem) {\n            this.contentItem.focus();\n        } else if (this.linkItem) {\n            this.linkItem.focus();\n        }\n    }\n\n    /** Method that provides information if element, or children of this element has passed id */\n    containsId(id: string): boolean {\n        if (this._elementId === id) {\n            return true;\n        }\n\n        if (this._itemService.list) {\n            return !!this._itemService.list.nestedItems.find((item) => item.containsId(id));\n        }\n\n        return false;\n    }\n\n    /**\n     * @hidden\n     * Propagate open state to all of the children\n     */\n    private propagateOpenChange(open: boolean): void {\n        this._expanded = open;\n\n        if (this.hasChildren) {\n            this._ariaExpanded = this._expanded;\n        }\n\n        this.expandIcon?.changeExpandedState(open);\n\n        /** Propagate hidden flag to list component, that is passed from child */\n        if (this._itemService.list) {\n            this._itemService.list.hidden = !open;\n            this._itemService.list.detectChanges();\n        }\n\n        /** Propagate open flag to popover list component, that is passed from child */\n        if (this._itemService.popover) {\n            this._itemService.popover.open = open;\n        }\n\n        /**\n         * If there are any list below\n         * Trigger event to provide keyboard support to new list of opened item element.\n         * */\n        if (this._shouldRefreshKeyboardService()) {\n            this._keyboardService.refresh$.next();\n        }\n\n        this.expandedChange.emit(open);\n    }\n\n    /** @hidden */\n    private _shouldRefreshKeyboardService(): boolean {\n        return !!(this._itemService.popover || this._itemService.list || this.contentItem);\n    }\n\n    /** @hidden */\n    private _setUpSubscriptions(): void {\n        if (this._stateService.condensed) {\n            this._role = 'menuitemradio';\n        }\n\n        if (!this.display) {\n            /** Subscribe to mouse click event, thrown by link item */\n            this._itemService.toggle.pipe(takeUntil(this._onDestroy$)).subscribe(() => this.toggle());\n\n            /** Subscribe to mouse click event, thrown by link item */\n            this._itemService.click\n                .pipe(takeUntil(this._onDestroy$))\n                .subscribe(() => this._stateService.onSelected.next(this._elementId));\n        }\n\n        /** Subscribe to keyboard event and throw it farther */\n        this._itemService.keyDown\n            .pipe(takeUntil(this._onDestroy$))\n            .subscribe((keyboardEvent) => this.keyboardTriggered.emit(keyboardEvent));\n\n        /** Subscribe to selected state change, it's not triggered, when selectable flag is disabled*/\n        this._stateService.onSelected\n            .pipe(\n                takeUntil(this._onDestroy$),\n                filter(() => this._stateService.selectable)\n            )\n            .subscribe((id) => this._selectedChange(id));\n    }\n\n    /** @hidden */\n    private _propagateHasChildrenProperty(): void {\n        if (this.contentItem && this.hasChildren) {\n            this._ariaExpanded = false;\n            this.contentItem.hasChildren = true;\n            this.contentItem.changeDetRef.detectChanges();\n        }\n    }\n\n    /** Pass this element to popover child item, to allow control `expanded` value */\n    private _passItemReferences(): void {\n        if (this._itemService.popover) {\n            this._itemService.popover.parentItemElement = this;\n        }\n    }\n\n    /** Change of selected state of content or link, if there is any children with I */\n    private _selectedChange(id: string): void {\n        const selected = this.containsId(id);\n        this._ariaSelected = selected;\n\n        if (this.contentItem) {\n            this.contentItem.changeSelected(selected);\n        } else if (this.linkItem) {\n            this.linkItem.changeSelected(selected);\n        }\n    }\n}\n"]}

package/esm2020/nested-list/nested-item/nested-item.interface.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibmVzdGVkLWl0ZW0uaW50ZXJmYWNlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vbGlicy9jeC9zcmMvbGliL25lc3RlZC1saXN0L25lc3RlZC1pdGVtL25lc3RlZC1pdGVtLmludGVyZmFjZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgRXZlbnRFbWl0dGVyIH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5pbXBvcnQgeyBEZWZhdWx0TWVudUl0ZW0gfSBmcm9tICdAZnVuZGFtZW50YWwtbmd4L2NvcmUvbWVudSc7XG5pbXBvcnQgeyBOZXN0ZWRMaW5rQ29tcG9uZW50IH0gZnJvbSAnLi4vbmVzdGVkLWxpbmsvbmVzdGVkLWxpbmsuY29tcG9uZW50JztcblxuLyoqIEludGVyZmFjZSwgdG8gcmVkdWNlIGFtb3VudCBvZiBjaXJjdWxhciBkZXBlbmRlbmN5IHdhcm5pbmdzICovXG5leHBvcnQgaW50ZXJmYWNlIE5lc3RlZEl0ZW1JbnRlcmZhY2UgZXh0ZW5kcyBEZWZhdWx0TWVudUl0ZW0ge1xuICAgIGV4cGFuZGVkOiBib29sZWFuO1xuICAgIGtleWJvYXJkVHJpZ2dlcmVkOiBFdmVudEVtaXR0ZXI8S2V5Ym9hcmRFdmVudD47XG4gICAgdHJpZ2dlck9wZW46ICgpID0+IHZvaWQ7XG4gICAgdHJpZ2dlckNsb3NlOiAoKSA9PiB2b2lkO1xuICAgIGxpbmtJdGVtOiBOZXN0ZWRMaW5rQ29tcG9uZW50O1xuICAgIGFsbENoaWxkcmVuSXRlbXM6IE5lc3RlZEl0ZW1JbnRlcmZhY2VbXTtcbiAgICBoYXNDaGlsZHJlbjogYm9vbGVhbjtcbiAgICBjb250YWluc0lkOiAoaWQ6IHN0cmluZykgPT4gYm9vbGVhbjtcbiAgICBjbGljazogKCkgPT4gdm9pZDtcbiAgICBmb2N1czogKCkgPT4gdm9pZDtcbn1cbiJdfQ==

package/esm2020/nested-list/nested-item/nested-item.service.mjs

@@ -0,0 +1,15 @@
+import { Subject } from 'rxjs';
+/** Contains references to popover or list nested components, that are placed as direct children of item component */
+export class NestedItemService {
+    constructor() {
+        /** Subject fired when expand icon is clicked */
+        this.toggle = new Subject();
+        /** Subject fired, when child elements are focused */
+        this.focus = new Subject();
+        /** Subject fired, when content or link is clicked */
+        this.click = new Subject();
+        /** KeyDown handler, it is triggered from link, content and item elements */
+        this.keyDown = new Subject();
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibmVzdGVkLWl0ZW0uc2VydmljZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL2xpYnMvY3gvc3JjL2xpYi9uZXN0ZWQtbGlzdC9uZXN0ZWQtaXRlbS9uZXN0ZWQtaXRlbS5zZXJ2aWNlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUVBLE9BQU8sRUFBRSxPQUFPLEVBQUUsTUFBTSxNQUFNLENBQUM7QUFFL0IscUhBQXFIO0FBQ3JILE1BQU0sT0FBTyxpQkFBaUI7SUFBOUI7UUFNSSxnREFBZ0Q7UUFDaEQsV0FBTSxHQUFxQixJQUFJLE9BQU8sRUFBVyxDQUFDO1FBRWxELHFEQUFxRDtRQUNyRCxVQUFLLEdBQWtCLElBQUksT0FBTyxFQUFRLENBQUM7UUFFM0MscURBQXFEO1FBQ3JELFVBQUssR0FBa0IsSUFBSSxPQUFPLEVBQVEsQ0FBQztRQUUzQyw0RUFBNEU7UUFDNUUsWUFBTyxHQUEyQixJQUFJLE9BQU8sRUFBaUIsQ0FBQztJQUNuRSxDQUFDO0NBQUEiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBOZXN0ZWRMaXN0SW50ZXJmYWNlIH0gZnJvbSAnLi4vbmVzdGVkLWxpc3QvbmVzdGVkLWxpc3QuaW50ZXJmYWNlJztcbmltcG9ydCB7IE5lc3RlZExpc3RQb3BvdmVySW50ZXJmYWNlIH0gZnJvbSAnLi4vbmVzdGVkLWxpc3QtcG9wb3Zlci9uZXN0ZWQtbGlzdC1wb3BvdmVyLmludGVyZmFjZSc7XG5pbXBvcnQgeyBTdWJqZWN0IH0gZnJvbSAncnhqcyc7XG5cbi8qKiBDb250YWlucyByZWZlcmVuY2VzIHRvIHBvcG92ZXIgb3IgbGlzdCBuZXN0ZWQgY29tcG9uZW50cywgdGhhdCBhcmUgcGxhY2VkIGFzIGRpcmVjdCBjaGlsZHJlbiBvZiBpdGVtIGNvbXBvbmVudCAqL1xuZXhwb3J0IGNsYXNzIE5lc3RlZEl0ZW1TZXJ2aWNlIHtcbiAgICAvKiogQGhpZGRlbiAqL1xuICAgIGxpc3Q6IE5lc3RlZExpc3RJbnRlcmZhY2U7XG4gICAgLyoqIEBoaWRkZW4gKi9cbiAgICBwb3BvdmVyPzogTmVzdGVkTGlzdFBvcG92ZXJJbnRlcmZhY2U7XG5cbiAgICAvKiogU3ViamVjdCBmaXJlZCB3aGVuIGV4cGFuZCBpY29uIGlzIGNsaWNrZWQgKi9cbiAgICB0b2dnbGU6IFN1YmplY3Q8Ym9vbGVhbj4gPSBuZXcgU3ViamVjdDxib29sZWFuPigpO1xuXG4gICAgLyoqIFN1YmplY3QgZmlyZWQsIHdoZW4gY2hpbGQgZWxlbWVudHMgYXJlIGZvY3VzZWQgKi9cbiAgICBmb2N1czogU3ViamVjdDx2b2lkPiA9IG5ldyBTdWJqZWN0PHZvaWQ+KCk7XG5cbiAgICAvKiogU3ViamVjdCBmaXJlZCwgd2hlbiBjb250ZW50IG9yIGxpbmsgaXMgY2xpY2tlZCAqL1xuICAgIGNsaWNrOiBTdWJqZWN0PHZvaWQ+ID0gbmV3IFN1YmplY3Q8dm9pZD4oKTtcblxuICAgIC8qKiBLZXlEb3duIGhhbmRsZXIsIGl0IGlzIHRyaWdnZXJlZCBmcm9tIGxpbmssIGNvbnRlbnQgYW5kIGl0ZW0gZWxlbWVudHMgKi9cbiAgICBrZXlEb3duOiBTdWJqZWN0PEtleWJvYXJkRXZlbnQ+ID0gbmV3IFN1YmplY3Q8S2V5Ym9hcmRFdmVudD4oKTtcbn1cbiJdfQ==