primeng 11.0.0-rc.1 → 11.1.0

package/esm2015/cascadeselect/cascadeselect.js

@@ -0,0 +1,579 @@
+import { NgModule, Component, ChangeDetectionStrategy, ViewEncapsulation, Input, ContentChildren, ElementRef, Output, EventEmitter, ViewChild, forwardRef, ChangeDetectorRef } from '@angular/core';
+import { CommonModule } from '@angular/common';
+import { SharedModule, PrimeTemplate } from 'primeng/api';
+import { ObjectUtils } from 'primeng/utils';
+import { DomHandler } from 'primeng/dom';
+import { trigger, style, transition, animate } from '@angular/animations';
+import { ConnectedOverlayScrollHandler } from 'primeng/dom';
+import { NG_VALUE_ACCESSOR } from '@angular/forms';
+import { RippleModule } from 'primeng/ripple';
+export const CASCADESELECT_VALUE_ACCESSOR = {
+    provide: NG_VALUE_ACCESSOR,
+    useExisting: forwardRef(() => CascadeSelect),
+    multi: true
+};
+export class CascadeSelectSub {
+    constructor(el) {
+        this.el = el;
+        this.level = 0;
+        this.onSelect = new EventEmitter();
+        this.onGroupSelect = new EventEmitter();
+        this.activeOption = null;
+    }
+    get parentActive() {
+        return this._parentActive;
+    }
+    ;
+    set parentActive(val) {
+        if (!val) {
+            this.activeOption = null;
+        }
+        this._parentActive = val;
+    }
+    ngOnInit() {
+        if (this.selectionPath && this.options && !this.dirty) {
+            for (let option of this.options) {
+                if (this.selectionPath.includes(option)) {
+                    this.activeOption = option;
+                    break;
+                }
+            }
+        }
+        if (!this.root) {
+            this.position();
+        }
+    }
+    onOptionClick(event, option) {
+        if (this.isOptionGroup(option)) {
+            this.activeOption = (this.activeOption === option) ? null : option;
+            this.onGroupSelect.emit({
+                originalEvent: event,
+                value: option
+            });
+        }
+        else {
+            this.onSelect.emit({
+                originalEvent: event,
+                value: this.getOptionValue(option)
+            });
+        }
+    }
+    onOptionSelect(event) {
+        this.onSelect.emit(event);
+    }
+    onOptionGroupSelect(event) {
+        this.onGroupSelect.emit(event);
+    }
+    getOptionLabel(option) {
+        return this.optionLabel ? ObjectUtils.resolveFieldData(option, this.optionLabel) : option;
+    }
+    getOptionValue(option) {
+        return this.optionValue ? ObjectUtils.resolveFieldData(option, this.optionValue) : option;
+    }
+    getOptionGroupLabel(optionGroup) {
+        return this.optionGroupLabel ? ObjectUtils.resolveFieldData(optionGroup, this.optionGroupLabel) : null;
+    }
+    getOptionGroupChildren(optionGroup) {
+        return ObjectUtils.resolveFieldData(optionGroup, this.optionGroupChildren[this.level]);
+    }
+    isOptionGroup(option) {
+        return Object.prototype.hasOwnProperty.call(option, this.optionGroupChildren[this.level]);
+    }
+    getOptionLabelToRender(option) {
+        return this.isOptionGroup(option) ? this.getOptionGroupLabel(option) : this.getOptionLabel(option);
+    }
+    getItemClass(option) {
+        return {
+            'p-cascadeselect-item': true,
+            'p-cascadeselect-item-group': this.isOptionGroup(option),
+            'p-cascadeselect-item-active p-highlight': this.isOptionActive(option)
+        };
+    }
+    isOptionActive(option) {
+        return this.activeOption === option;
+    }
+    onKeyDown(event, option, index) {
+        let listItem = event.currentTarget.parentElement;
+        switch (event.key) {
+            case 'Down':
+            case 'ArrowDown':
+                var nextItem = this.el.nativeElement.children[0].children[index + 1];
+                if (nextItem) {
+                    nextItem.children[0].focus();
+                }
+                break;
+            case 'Up':
+            case 'ArrowUp':
+                var prevItem = this.el.nativeElement.children[0].children[index - 1];
+                if (prevItem) {
+                    prevItem.children[0].focus();
+                }
+                break;
+            case 'Right':
+            case 'ArrowRight':
+                if (this.isOptionGroup(option)) {
+                    if (this.isOptionActive(option)) {
+                        listItem.children[1].children[0].children[0].children[0].focus();
+                    }
+                    else {
+                        this.activeOption = option;
+                    }
+                }
+                break;
+            case 'Left':
+            case 'ArrowLeft':
+                this.activeOption = null;
+                var parentList = listItem.parentElement.parentElement.parentElement;
+                if (parentList) {
+                    parentList.children[0].focus();
+                }
+                break;
+            case 'Enter':
+                this.onOptionClick(event, option);
+                break;
+        }
+        event.preventDefault();
+    }
+    position() {
+        const parentItem = this.el.nativeElement.parentElement;
+        const containerOffset = DomHandler.getOffset(parentItem);
+        const viewport = DomHandler.getViewport();
+        const sublistWidth = this.el.nativeElement.children[0].offsetParent ? this.el.nativeElement.children[0].offsetWidth : DomHandler.getHiddenElementOuterWidth(this.el.nativeElement.children[0]);
+        const itemOuterWidth = DomHandler.getOuterWidth(parentItem.children[0]);
+        if ((parseInt(containerOffset.left, 10) + itemOuterWidth + sublistWidth) > (viewport.width - DomHandler.calculateScrollbarWidth())) {
+            this.el.nativeElement.children[0].style.left = '-200%';
+        }
+    }
+}
+CascadeSelectSub.decorators = [
+    { type: Component, args: [{
+                selector: 'p-cascadeSelectSub',
+                template: `
+        <ul class="p-cascadeselect-panel p-cascadeselect-items" role="listbox" aria-orientation="horizontal">
+            <ng-template ngFor let-option [ngForOf]="options" let-i="index">
+                <li [ngClass]="getItemClass(option)" role="none">
+                    <div class="p-cascadeselect-item-content" (click)="onOptionClick($event, option)" tabindex="0" (keydown)="onKeyDown($event, option, i)" pRipple>
+                        <ng-container *ngIf="optionTemplate;else defaultOptionTemplate">
+                            <ng-container *ngTemplateOutlet="optionTemplate; context: {$implicit: option}"></ng-container>
+                        </ng-container>
+                        <ng-template #defaultOptionTemplate>
+                            <span class="p-cascadeselect-item-text">{{getOptionLabelToRender(option)}}</span>
+                        </ng-template>
+                        <span class="p-cascadeselect-group-icon pi pi-angle-right" *ngIf="isOptionGroup(option)"></span>
+                    </div>
+                    <p-cascadeSelectSub *ngIf="isOptionGroup(option) && isOptionActive(option)" class="p-cascadeselect-sublist" [selectionPath]="selectionPath" [options]="getOptionGroupChildren(option)"
+                        [optionLabel]="optionLabel" [optionValue]="optionValue" [level]="level + 1" (onSelect)="onOptionSelect($event)" (onOptionGroupSelect)="onOptionGroupSelect()"
+                        [optionGroupLabel]="optionGroupLabel" [optionGroupChildren]="optionGroupChildren" [parentActive]="isOptionActive(option)" [dirty]="dirty" [optionTemplate]="optionTemplate">
+                    </p-cascadeSelectSub>
+                </li>
+            </ng-template>
+        </ul>
+    `,
+                encapsulation: ViewEncapsulation.None,
+                changeDetection: ChangeDetectionStrategy.OnPush
+            },] }
+];
+CascadeSelectSub.ctorParameters = () => [
+    { type: ElementRef }
+];
+CascadeSelectSub.propDecorators = {
+    selectionPath: [{ type: Input }],
+    options: [{ type: Input }],
+    optionGroupChildren: [{ type: Input }],
+    optionTemplate: [{ type: Input }],
+    level: [{ type: Input }],
+    optionLabel: [{ type: Input }],
+    optionValue: [{ type: Input }],
+    optionGroupLabel: [{ type: Input }],
+    dirty: [{ type: Input }],
+    root: [{ type: Input }],
+    onSelect: [{ type: Output }],
+    onGroupSelect: [{ type: Output }],
+    parentActive: [{ type: Input }]
+};
+export class CascadeSelect {
+    constructor(el, cd) {
+        this.el = el;
+        this.cd = cd;
+        this.showTransitionOptions = '.12s cubic-bezier(0, 0, 0.2, 1)';
+        this.hideTransitionOptions = '.1s linear';
+        this.onChange = new EventEmitter();
+        this.onGroupChange = new EventEmitter();
+        this.onShow = new EventEmitter();
+        this.onHide = new EventEmitter();
+        this.onBeforeShow = new EventEmitter();
+        this.onBeforeHide = new EventEmitter();
+        this.selectionPath = null;
+        this.focused = false;
+        this.overlayVisible = false;
+        this.dirty = false;
+        this.onModelChange = () => { };
+        this.onModelTouched = () => { };
+    }
+    ngOnInit() {
+        this.updateSelectionPath();
+    }
+    ngAfterContentInit() {
+        this.templates.forEach((item) => {
+            switch (item.getType()) {
+                case 'value':
+                    this.valueTemplate = item.template;
+                    break;
+                case 'option':
+                    this.optionTemplate = item.template;
+                    break;
+            }
+        });
+    }
+    onOptionSelect(event) {
+        this.value = event.value;
+        this.updateSelectionPath();
+        this.onModelChange(this.value);
+        this.onChange.emit(event);
+        this.hide();
+        this.focusInputEl.nativeElement.focus();
+    }
+    onOptionGroupSelect(event) {
+        this.dirty = true;
+        this.onGroupChange.emit(event);
+    }
+    getOptionLabel(option) {
+        return this.optionLabel ? ObjectUtils.resolveFieldData(option, this.optionLabel) : option;
+    }
+    getOptionValue(option) {
+        return this.optionValue ? ObjectUtils.resolveFieldData(option, this.optionValue) : option;
+    }
+    getOptionGroupChildren(optionGroup, level) {
+        return ObjectUtils.resolveFieldData(optionGroup, this.optionGroupChildren[level]);
+    }
+    isOptionGroup(option, level) {
+        return Object.prototype.hasOwnProperty.call(option, this.optionGroupChildren[level]);
+    }
+    updateSelectionPath() {
+        let path;
+        if (this.value != null && this.options) {
+            for (let option of this.options) {
+                path = this.findModelOptionInGroup(option, 0);
+                if (path) {
+                    break;
+                }
+            }
+        }
+        this.selectionPath = path;
+    }
+    findModelOptionInGroup(option, level) {
+        if (this.isOptionGroup(option, level)) {
+            let selectedOption;
+            for (let childOption of this.getOptionGroupChildren(option, level)) {
+                selectedOption = this.findModelOptionInGroup(childOption, level + 1);
+                if (selectedOption) {
+                    selectedOption.unshift(option);
+                    return selectedOption;
+                }
+            }
+        }
+        else if ((ObjectUtils.equals(this.value, this.getOptionValue(option), this.dataKey))) {
+            return [option];
+        }
+        return null;
+    }
+    show() {
+        this.onBeforeShow.emit();
+        this.overlayVisible = true;
+    }
+    hide() {
+        this.onBeforeHide.emit();
+        this.overlayVisible = false;
+        this.cd.markForCheck();
+    }
+    onClick(event) {
+        if (this.disabled) {
+            return;
+        }
+        if (!this.overlayEl || !this.overlayEl || !this.overlayEl.contains(event.target)) {
+            if (this.overlayVisible) {
+                this.hide();
+            }
+            else {
+                this.show();
+            }
+            this.focusInputEl.nativeElement.focus();
+        }
+    }
+    onFocus() {
+        this.focused = true;
+    }
+    onBlur() {
+        this.focused = false;
+    }
+    onOverlayAnimationStart(event) {
+        switch (event.toState) {
+            case 'visible':
+                this.overlayEl = event.element;
+                this.onOverlayEnter();
+                break;
+        }
+    }
+    onOverlayAnimationDone(event) {
+        switch (event.toState) {
+            case 'void':
+                this.onOverlayLeave();
+                break;
+        }
+    }
+    onOverlayEnter() {
+        this.overlayEl.style.zIndex = String(DomHandler.generateZIndex());
+        this.appendContainer();
+        this.alignOverlay();
+        this.bindOutsideClickListener();
+        this.bindScrollListener();
+        this.bindResizeListener();
+        this.onShow.emit();
+    }
+    onOverlayLeave() {
+        this.unbindOutsideClickListener();
+        this.unbindScrollListener();
+        this.unbindResizeListener();
+        this.onHide.emit();
+        this.overlayEl = null;
+        this.dirty = false;
+    }
+    writeValue(value) {
+        this.value = value;
+        this.updateSelectionPath();
+        this.cd.markForCheck();
+    }
+    registerOnChange(fn) {
+        this.onModelChange = fn;
+    }
+    registerOnTouched(fn) {
+        this.onModelTouched = fn;
+    }
+    setDisabledState(val) {
+        this.disabled = val;
+        this.cd.markForCheck();
+    }
+    alignOverlay() {
+        if (this.appendTo) {
+            DomHandler.absolutePosition(this.overlayEl, this.containerEl.nativeElement);
+            this.overlayEl.style.minWidth = DomHandler.getOuterWidth(this.containerEl.nativeElement) + 'px';
+        }
+        else {
+            DomHandler.relativePosition(this.overlayEl, this.containerEl.nativeElement);
+        }
+    }
+    bindOutsideClickListener() {
+        if (!this.outsideClickListener) {
+            this.outsideClickListener = (event) => {
+                if (this.overlayVisible && this.overlayEl && !this.containerEl.nativeElement.contains(event.target) && !this.overlayEl.contains(event.target)) {
+                    this.hide();
+                }
+            };
+            document.addEventListener('click', this.outsideClickListener);
+        }
+    }
+    unbindOutsideClickListener() {
+        if (this.outsideClickListener) {
+            document.removeEventListener('click', this.outsideClickListener);
+            this.outsideClickListener = null;
+        }
+    }
+    bindScrollListener() {
+        if (!this.scrollHandler) {
+            this.scrollHandler = new ConnectedOverlayScrollHandler(this.containerEl.nativeElement, () => {
+                if (this.overlayVisible) {
+                    this.hide();
+                }
+            });
+        }
+        this.scrollHandler.bindScrollListener();
+    }
+    unbindScrollListener() {
+        if (this.scrollHandler) {
+            this.scrollHandler.unbindScrollListener();
+        }
+    }
+    bindResizeListener() {
+        if (!this.resizeListener) {
+            this.resizeListener = () => {
+                if (this.overlayVisible) {
+                    this.hide();
+                }
+            };
+            window.addEventListener('resize', this.resizeListener);
+        }
+    }
+    unbindResizeListener() {
+        if (this.resizeListener) {
+            window.removeEventListener('resize', this.resizeListener);
+            this.resizeListener = null;
+        }
+    }
+    appendContainer() {
+        if (this.appendTo) {
+            if (this.appendTo === 'body')
+                document.body.appendChild(this.overlayEl);
+            else
+                document.getElementById(this.appendTo).appendChild(this.overlayEl);
+        }
+    }
+    restoreAppend() {
+        if (this.overlayEl && this.appendTo) {
+            if (this.appendTo === 'body')
+                document.body.removeChild(this.overlayEl);
+            else
+                document.getElementById(this.appendTo).removeChild(this.overlayEl);
+        }
+    }
+    label() {
+        if (this.selectionPath)
+            return this.getOptionLabel(this.selectionPath[this.selectionPath.length - 1]);
+        else
+            return this.placeholder || 'p-emptylabel';
+    }
+    onKeyDown(event) {
+        switch (event.key) {
+            case 'Down':
+            case 'ArrowDown':
+                if (this.overlayVisible) {
+                    DomHandler.findSingle(this.overlayEl, '.p-cascadeselect-item').children[0].focus();
+                }
+                else if (event.altKey && this.options && this.options.length) {
+                    this.show();
+                }
+                event.preventDefault();
+                break;
+            case 'Escape':
+                if (this.overlayVisible) {
+                    this.hide();
+                    event.preventDefault();
+                }
+                break;
+            case 'Tab':
+                this.hide();
+                break;
+        }
+    }
+    containerClass() {
+        return {
+            'p-cascadeselect p-component p-inputwrapper': true,
+            'p-disabled': this.disabled,
+            'p-focus': this.focused,
+            'p-inputwrapper-filled': this.value,
+            'p-inputwrapper-focus': this.focused
+        };
+    }
+    labelClass() {
+        return {
+            'p-cascadeselect-label': true,
+            'p-placeholder': this.label() === this.placeholder,
+            'p-cascadeselect-label-empty': !this.value && (this.label() === 'p-emptylabel' || this.label().length === 0)
+        };
+    }
+    ngOnDestroy() {
+        this.restoreAppend();
+        this.unbindOutsideClickListener();
+        this.unbindResizeListener();
+        if (this.scrollHandler) {
+            this.scrollHandler.destroy();
+            this.scrollHandler = null;
+        }
+        this.overlayEl = null;
+    }
+}
+CascadeSelect.decorators = [
+    { type: Component, args: [{
+                selector: 'p-cascadeSelect',
+                template: `
+        <div #container [ngClass]="containerClass()" [class]="styleClass" [ngStyle]="style" (click)="onClick($event)">
+            <div class="p-hidden-accessible">
+                <input #focusInput type="text" [attr.id]="inputId" readonly [disabled]="disabled" (focus)="onFocus()" (blur)="onBlur()"  (keydown)="onKeyDown($event)" [attr.tabindex]="tabindex"
+                    aria-haspopup="listbox" [attr.aria-expanded]="overlayVisible" [attr.aria-labelledby]="ariaLabelledBy">
+            </div>
+            <span [ngClass]="labelClass()">
+                <ng-container *ngIf="valueTemplate;else defaultValueTemplate">
+                        <ng-container *ngTemplateOutlet="valueTemplate; context: {$implicit: value, placeholder: placeholder}"></ng-container>
+                </ng-container>
+                <ng-template #defaultValueTemplate>
+                    {{label()}}
+                </ng-template>
+            </span>
+            <div class="p-cascadeselect-trigger" role="button" aria-haspopup="listbox" [attr.aria-expanded]="overlayVisible">
+                <span class="p-cascadeselect-trigger-icon pi pi-chevron-down"></span>
+            </div>
+            <div class="p-cascadeselect-panel p-component" *ngIf="overlayVisible" 
+                [@overlayAnimation]="{value: 'visible', params: {showTransitionParams: showTransitionOptions, hideTransitionParams: hideTransitionOptions}}" (@overlayAnimation.start)="onOverlayAnimationStart($event)" (@overlayAnimation.done)="onOverlayAnimationDone($event)">
+                <div class="p-cascadeselect-items-wrapper">
+                    <p-cascadeSelectSub [options]="options" [selectionPath]="selectionPath" class="p-cascadeselect-items" 
+                        [optionLabel]="optionLabel" [optionValue]="optionValue" [level]="0" [optionTemplate]="optionTemplate"
+                        [optionGroupLabel]="optionGroupLabel" [optionGroupChildren]="optionGroupChildren" 
+                        (onSelect)="onOptionSelect($event)" (onGroupSelect)="onOptionGroupSelect()" [dirty]="dirty" [root]="true">
+                    </p-cascadeSelectSub>
+                </div>
+            </div>
+        </div>
+    `,
+                animations: [
+                    trigger('overlayAnimation', [
+                        transition(':enter', [
+                            style({ opacity: 0, transform: 'scaleY(0.8)' }),
+                            animate('{{showTransitionParams}}')
+                        ]),
+                        transition(':leave', [
+                            animate('{{hideTransitionParams}}', style({ opacity: 0 }))
+                        ])
+                    ])
+                ],
+                host: {
+                    '[class.p-inputwrapper-filled]': 'filled',
+                    '[class.p-inputwrapper-focus]': 'focus'
+                },
+                providers: [CASCADESELECT_VALUE_ACCESSOR],
+                changeDetection: ChangeDetectionStrategy.OnPush,
+                encapsulation: ViewEncapsulation.None,
+                styles: [".p-cascadeselect{-ms-user-select:none;-webkit-user-select:none;cursor:pointer;display:inline-flex;position:relative;user-select:none}.p-cascadeselect-trigger{align-items:center;display:flex;flex-shrink:0;justify-content:center}.p-cascadeselect-label{cursor:pointer;display:block;flex:1 1 auto;overflow:hidden;text-overflow:ellipsis;white-space:nowrap;width:1%}.p-cascadeselect-label-empty{overflow:hidden;visibility:hidden}.p-cascadeselect .p-cascadeselect-panel{min-width:100%}.p-cascadeselect-panel{position:absolute}.p-cascadeselect-item{cursor:pointer;font-weight:400;white-space:nowrap}.p-cascadeselect-item-content{align-items:center;display:flex;overflow:hidden;position:relative}.p-cascadeselect-group-icon{margin-left:auto}.p-cascadeselect-items{list-style-type:none;margin:0;padding:0}.p-fluid .p-cascadeselect{display:flex}.p-fluid .p-cascadeselect .p-cascadeselect-label{width:1%}.p-cascadeselect-sublist{display:none;min-width:100%;position:absolute;z-index:1}.p-cascadeselect-item-active{overflow:visible!important}.p-cascadeselect-item-active>.p-cascadeselect-sublist{display:block;left:100%;top:0}"]
+            },] }
+];
+CascadeSelect.ctorParameters = () => [
+    { type: ElementRef },
+    { type: ChangeDetectorRef }
+];
+CascadeSelect.propDecorators = {
+    styleClass: [{ type: Input }],
+    style: [{ type: Input }],
+    options: [{ type: Input }],
+    optionLabel: [{ type: Input }],
+    optionValue: [{ type: Input }],
+    optionGroupLabel: [{ type: Input }],
+    optionGroupChildren: [{ type: Input }],
+    placeholder: [{ type: Input }],
+    value: [{ type: Input }],
+    dataKey: [{ type: Input }],
+    inputId: [{ type: Input }],
+    tabindex: [{ type: Input }],
+    ariaLabelledBy: [{ type: Input }],
+    appendTo: [{ type: Input }],
+    disabled: [{ type: Input }],
+    rounded: [{ type: Input }],
+    showTransitionOptions: [{ type: Input }],
+    hideTransitionOptions: [{ type: Input }],
+    focusInputEl: [{ type: ViewChild, args: ['focusInput',] }],
+    containerEl: [{ type: ViewChild, args: ['container',] }],
+    onChange: [{ type: Output }],
+    onGroupChange: [{ type: Output }],
+    onShow: [{ type: Output }],
+    onHide: [{ type: Output }],
+    onBeforeShow: [{ type: Output }],
+    onBeforeHide: [{ type: Output }],
+    templates: [{ type: ContentChildren, args: [PrimeTemplate,] }]
+};
+export class CascadeSelectModule {
+}
+CascadeSelectModule.decorators = [
+    { type: NgModule, args: [{
+                imports: [CommonModule, SharedModule, RippleModule],
+                exports: [CascadeSelect, CascadeSelectSub, SharedModule],
+                declarations: [CascadeSelect, CascadeSelectSub]
+            },] }
+];
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"cascadeselect.js","sourceRoot":"../../../src/app/components/cascadeselect/","sources":["cascadeselect.ts"],"names":[],"mappings":"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","sourcesContent":["import { NgModule, Component, ChangeDetectionStrategy, ViewEncapsulation, Input, TemplateRef, ContentChildren, QueryList, ElementRef, Output, EventEmitter, ViewChild, forwardRef, ChangeDetectorRef, Renderer2, OnDestroy, OnInit, AfterContentInit} from '@angular/core';\nimport { CommonModule } from '@angular/common';\nimport { SharedModule, PrimeTemplate } from 'primeng/api';\nimport { ObjectUtils } from 'primeng/utils';\nimport { DomHandler } from 'primeng/dom';\nimport { trigger,style,transition,animate,AnimationEvent} from '@angular/animations';\nimport { ConnectedOverlayScrollHandler } from 'primeng/dom';\nimport { NG_VALUE_ACCESSOR } from '@angular/forms';\nimport { RippleModule } from 'primeng/ripple';\n\nexport const CASCADESELECT_VALUE_ACCESSOR: any = {\n    provide: NG_VALUE_ACCESSOR,\n    useExisting: forwardRef(() => CascadeSelect),\n    multi: true\n};\n\n@Component({\n    selector: 'p-cascadeSelectSub',\n    template: `\n        <ul class=\"p-cascadeselect-panel p-cascadeselect-items\" role=\"listbox\" aria-orientation=\"horizontal\">\n            <ng-template ngFor let-option [ngForOf]=\"options\" let-i=\"index\">\n                <li [ngClass]=\"getItemClass(option)\" role=\"none\">\n                    <div class=\"p-cascadeselect-item-content\" (click)=\"onOptionClick($event, option)\" tabindex=\"0\" (keydown)=\"onKeyDown($event, option, i)\" pRipple>\n                        <ng-container *ngIf=\"optionTemplate;else defaultOptionTemplate\">\n                            <ng-container *ngTemplateOutlet=\"optionTemplate; context: {$implicit: option}\"></ng-container>\n                        </ng-container>\n                        <ng-template #defaultOptionTemplate>\n                            <span class=\"p-cascadeselect-item-text\">{{getOptionLabelToRender(option)}}</span>\n                        </ng-template>\n                        <span class=\"p-cascadeselect-group-icon pi pi-angle-right\" *ngIf=\"isOptionGroup(option)\"></span>\n                    </div>\n                    <p-cascadeSelectSub *ngIf=\"isOptionGroup(option) && isOptionActive(option)\" class=\"p-cascadeselect-sublist\" [selectionPath]=\"selectionPath\" [options]=\"getOptionGroupChildren(option)\"\n                        [optionLabel]=\"optionLabel\" [optionValue]=\"optionValue\" [level]=\"level + 1\" (onSelect)=\"onOptionSelect($event)\" (onOptionGroupSelect)=\"onOptionGroupSelect()\"\n                        [optionGroupLabel]=\"optionGroupLabel\" [optionGroupChildren]=\"optionGroupChildren\" [parentActive]=\"isOptionActive(option)\" [dirty]=\"dirty\" [optionTemplate]=\"optionTemplate\">\n                    </p-cascadeSelectSub>\n                </li>\n            </ng-template>\n        </ul>\n    `,\n    encapsulation: ViewEncapsulation.None,\n    changeDetection: ChangeDetectionStrategy.OnPush\n})\nexport class CascadeSelectSub implements OnInit {\n\n    @Input() selectionPath: any[];\n\n    @Input() options: any[];\n\n    @Input() optionGroupChildren: any[];\n\n    @Input() optionTemplate: TemplateRef<any>;\n\n    @Input() level: number = 0;\n\n    @Input() optionLabel: string;\n\n    @Input() optionValue: string;\n\n    @Input() optionGroupLabel: string;\n\n    @Input() dirty: boolean;\n\n    @Input() root: boolean;\n\n    @Output() onSelect: EventEmitter<any> = new EventEmitter();\n\n    @Output() onGroupSelect: EventEmitter<any> = new EventEmitter();\n\n    @Input() get parentActive(): boolean {\n        return this._parentActive;\n    };\n    set parentActive(val) {\n        if (!val) {\n            this.activeOption = null;\n        }\n\n        this._parentActive = val;\n    }\n\n    activeOption: any = null;\n\n    _parentActive: boolean;\n\n    constructor(private el: ElementRef) { }\n\n    ngOnInit() {\n        if (this.selectionPath && this.options && !this.dirty) {\n            for (let option of this.options) {\n                if (this.selectionPath.includes(option)) {\n                    this.activeOption = option;\n                    break;\n                }\n            }\n        }\n\n        if (!this.root) {\n            this.position();\n        }\n    }\n\n    onOptionClick(event, option) {\n        if (this.isOptionGroup(option)) {\n            this.activeOption = (this.activeOption === option) ? null : option;\n\n            this.onGroupSelect.emit({\n                originalEvent: event,\n                value: option\n            });\n        }\n        else {\n            this.onSelect.emit({\n                originalEvent: event,\n                value: this.getOptionValue(option)\n            });\n        }\n    }\n\n    onOptionSelect(event) {\n        this.onSelect.emit(event);\n    }\n\n    onOptionGroupSelect(event) {\n        this.onGroupSelect.emit(event);\n    }\n\n    getOptionLabel(option) {\n        return this.optionLabel ? ObjectUtils.resolveFieldData(option, this.optionLabel) : option;\n    }\n\n    getOptionValue(option) {\n        return this.optionValue ? ObjectUtils.resolveFieldData(option, this.optionValue) : option;\n    }\n\n    getOptionGroupLabel(optionGroup) {\n        return this.optionGroupLabel ? ObjectUtils.resolveFieldData(optionGroup, this.optionGroupLabel) : null;\n    }\n\n    getOptionGroupChildren(optionGroup) {\n        return ObjectUtils.resolveFieldData(optionGroup, this.optionGroupChildren[this.level]);\n    }\n\n    isOptionGroup(option) {\n        return Object.prototype.hasOwnProperty.call(option, this.optionGroupChildren[this.level]);\n    }\n\n    getOptionLabelToRender(option) {\n        return this.isOptionGroup(option) ? this.getOptionGroupLabel(option) : this.getOptionLabel(option);\n    }\n\n    getItemClass(option) {\n        return {\n            'p-cascadeselect-item': true, \n            'p-cascadeselect-item-group': this.isOptionGroup(option),\n            'p-cascadeselect-item-active p-highlight': this.isOptionActive(option)\n        }\n    }\n\n    isOptionActive(option) {\n        return this.activeOption === option;\n    }\n\n    onKeyDown(event, option, index) {\n        let listItem = event.currentTarget.parentElement;\n\n        switch (event.key) {\n            case 'Down':\n            case 'ArrowDown':\n                var nextItem = this.el.nativeElement.children[0].children[index + 1];\n                if (nextItem) {\n                    nextItem.children[0].focus();\n                }\n            break;\n\n            case 'Up':\n            case 'ArrowUp':\n                var prevItem = this.el.nativeElement.children[0].children[index - 1];\n                if (prevItem) {\n                    prevItem.children[0].focus();\n                }\n            break;\n\n            case 'Right':\n            case 'ArrowRight':\n                if (this.isOptionGroup(option)) {\n                    if (this.isOptionActive(option)) {\n                        listItem.children[1].children[0].children[0].children[0].focus();\n                    }\n                    else {\n                        this.activeOption = option;\n                    }\n                }\n            break;\n\n            case 'Left':\n            case 'ArrowLeft':\n                this.activeOption = null;\n\n                var parentList = listItem.parentElement.parentElement.parentElement;\n                if (parentList) {\n                    parentList.children[0].focus();\n                }\n            break;\n\n            case 'Enter':\n                this.onOptionClick(event, option);\n            break;\n        }\n\n        event.preventDefault();\n    }\n\n    position() {\n        const parentItem = this.el.nativeElement.parentElement;\n        const containerOffset = DomHandler.getOffset(parentItem);\n        const viewport = DomHandler.getViewport();\n        const sublistWidth = this.el.nativeElement.children[0].offsetParent ? this.el.nativeElement.children[0].offsetWidth : DomHandler.getHiddenElementOuterWidth(this.el.nativeElement.children[0]);\n        const itemOuterWidth = DomHandler.getOuterWidth(parentItem.children[0]);\n\n        if ((parseInt(containerOffset.left, 10) + itemOuterWidth + sublistWidth) > (viewport.width - DomHandler.calculateScrollbarWidth())) {\n            this.el.nativeElement.children[0].style.left = '-200%';\n        }\n    }\n}\n\n@Component({\n    selector: 'p-cascadeSelect',\n    template: `\n        <div #container [ngClass]=\"containerClass()\" [class]=\"styleClass\" [ngStyle]=\"style\" (click)=\"onClick($event)\">\n            <div class=\"p-hidden-accessible\">\n                <input #focusInput type=\"text\" [attr.id]=\"inputId\" readonly [disabled]=\"disabled\" (focus)=\"onFocus()\" (blur)=\"onBlur()\"  (keydown)=\"onKeyDown($event)\" [attr.tabindex]=\"tabindex\"\n                    aria-haspopup=\"listbox\" [attr.aria-expanded]=\"overlayVisible\" [attr.aria-labelledby]=\"ariaLabelledBy\">\n            </div>\n            <span [ngClass]=\"labelClass()\">\n                <ng-container *ngIf=\"valueTemplate;else defaultValueTemplate\">\n                        <ng-container *ngTemplateOutlet=\"valueTemplate; context: {$implicit: value, placeholder: placeholder}\"></ng-container>\n                </ng-container>\n                <ng-template #defaultValueTemplate>\n                    {{label()}}\n                </ng-template>\n            </span>\n            <div class=\"p-cascadeselect-trigger\" role=\"button\" aria-haspopup=\"listbox\" [attr.aria-expanded]=\"overlayVisible\">\n                <span class=\"p-cascadeselect-trigger-icon pi pi-chevron-down\"></span>\n            </div>\n            <div class=\"p-cascadeselect-panel p-component\" *ngIf=\"overlayVisible\" \n                [@overlayAnimation]=\"{value: 'visible', params: {showTransitionParams: showTransitionOptions, hideTransitionParams: hideTransitionOptions}}\" (@overlayAnimation.start)=\"onOverlayAnimationStart($event)\" (@overlayAnimation.done)=\"onOverlayAnimationDone($event)\">\n                <div class=\"p-cascadeselect-items-wrapper\">\n                    <p-cascadeSelectSub [options]=\"options\" [selectionPath]=\"selectionPath\" class=\"p-cascadeselect-items\" \n                        [optionLabel]=\"optionLabel\" [optionValue]=\"optionValue\" [level]=\"0\" [optionTemplate]=\"optionTemplate\"\n                        [optionGroupLabel]=\"optionGroupLabel\" [optionGroupChildren]=\"optionGroupChildren\" \n                        (onSelect)=\"onOptionSelect($event)\" (onGroupSelect)=\"onOptionGroupSelect()\" [dirty]=\"dirty\" [root]=\"true\">\n                    </p-cascadeSelectSub>\n                </div>\n            </div>\n        </div>\n    `,\n    animations: [\n        trigger('overlayAnimation', [\n            transition(':enter', [\n                style({opacity: 0, transform: 'scaleY(0.8)'}),\n                animate('{{showTransitionParams}}')\n              ]),\n              transition(':leave', [\n                animate('{{hideTransitionParams}}', style({ opacity: 0 }))\n              ])\n        ])\n    ],\n    host: {\n        '[class.p-inputwrapper-filled]': 'filled',\n        '[class.p-inputwrapper-focus]': 'focus'\n    },\n    providers: [CASCADESELECT_VALUE_ACCESSOR],\n    changeDetection: ChangeDetectionStrategy.OnPush,\n    encapsulation: ViewEncapsulation.None,\n    styleUrls: ['./cascadeselect.css']\n})\nexport class CascadeSelect implements OnInit, AfterContentInit, OnDestroy {\n\n    @Input() styleClass: string;\n\n    @Input() style: any;\n\n    @Input() options: any[];\n\n    @Input() optionLabel: string;\n\n    @Input() optionValue: string;\n\n    @Input() optionGroupLabel: string;\n\n    @Input() optionGroupChildren: string;\n\n    @Input() placeholder: string;\n    \n    @Input() value: string;\n\n    @Input() dataKey: string;\n\n    @Input() inputId: string;\n\n    @Input() tabindex: string;\n    \n    @Input() ariaLabelledBy: string;\n\n    @Input() appendTo: string;\n\n    @Input() disabled: boolean;\n\n    @Input() rounded: boolean;\n\n    @Input() showTransitionOptions: string = '.12s cubic-bezier(0, 0, 0.2, 1)';\n\n    @Input() hideTransitionOptions: string = '.1s linear';\n\n    @ViewChild('focusInput') focusInputEl: ElementRef;\n\n    @ViewChild('container') containerEl: ElementRef;\n\n    @Output() onChange: EventEmitter<any> = new EventEmitter();\n\n    @Output() onGroupChange: EventEmitter<any> = new EventEmitter();\n\n    @Output() onShow: EventEmitter<any> = new EventEmitter();\n\n    @Output() onHide: EventEmitter<any> = new EventEmitter();\n\n    @Output() onBeforeShow: EventEmitter<any> = new EventEmitter();\n\n    @Output() onBeforeHide: EventEmitter<any> = new EventEmitter();\n\n    @ContentChildren(PrimeTemplate) templates: QueryList<any>;\n\n    selectionPath: any = null;\n\n    focused: boolean = false;\n\n    overlayVisible: boolean = false;\n\n    dirty: boolean = false;\n\n    valueTemplate: TemplateRef<any>;\n\n    optionTemplate: TemplateRef<any>;\n\n    outsideClickListener: any;\n    \n    scrollHandler: any;\n    \n    resizeListener: any;\n\n    overlayEl: any;\n\n    onModelChange: Function = () => {};\n\n    onModelTouched: Function = () => {};\n\n    constructor(private el: ElementRef, private cd: ChangeDetectorRef) { }\n\n    ngOnInit() {\n        this.updateSelectionPath();\n    }\n\n    ngAfterContentInit() {\n        this.templates.forEach((item) => {\n            switch(item.getType()) {\n                case 'value':\n                    this.valueTemplate = item.template;\n                break;\n                case 'option':\n                    this.optionTemplate = item.template;\n                break;\n            }\n        });\n    }\n\n    onOptionSelect(event) {\n        this.value = event.value;\n        this.updateSelectionPath();\n        this.onModelChange(this.value);\n        this.onChange.emit(event);\n        this.hide();\n        this.focusInputEl.nativeElement.focus();\n    }\n\n    onOptionGroupSelect(event) {\n        this.dirty = true;\n        this.onGroupChange.emit(event);\n    }\n\n    getOptionLabel(option) {\n        return this.optionLabel ? ObjectUtils.resolveFieldData(option, this.optionLabel) : option;\n    }\n\n    getOptionValue(option) {\n        return this.optionValue ? ObjectUtils.resolveFieldData(option, this.optionValue) : option;\n    }\n\n    getOptionGroupChildren(optionGroup, level) {\n        return ObjectUtils.resolveFieldData(optionGroup, this.optionGroupChildren[level]);\n    }\n\n    isOptionGroup(option, level) {\n        return Object.prototype.hasOwnProperty.call(option, this.optionGroupChildren[level]);\n    }\n\n    updateSelectionPath() {\n        let path;\n        if (this.value != null && this.options) {\n            for (let option of this.options) {\n                path = this.findModelOptionInGroup(option, 0);\n                if (path) {\n                    break;\n                }\n            }\n        }\n\n        this.selectionPath = path;            \n    }\n\n    findModelOptionInGroup(option, level) {\n        if (this.isOptionGroup(option, level)) {\n            let selectedOption;\n            for (let childOption of this.getOptionGroupChildren(option, level)) {\n                selectedOption = this.findModelOptionInGroup(childOption, level + 1);\n                if (selectedOption) {\n                    selectedOption.unshift(option);\n                    return selectedOption;\n                }\n            }\n        }\n        else if ((ObjectUtils.equals(this.value, this.getOptionValue(option), this.dataKey))) {\n            return [option];\n        }\n        \n        return null;\n    }\n\n    show() {\n        this.onBeforeShow.emit();\n        this.overlayVisible = true;\n    }\n\n    hide() {\n        this.onBeforeHide.emit();\n        this.overlayVisible = false;\n        this.cd.markForCheck();\n    }\n\n    onClick(event) {\n        if (this.disabled) {\n            return;\n        }\n\n        if (!this.overlayEl || !this.overlayEl || !this.overlayEl.contains(event.target)) {\n            if (this.overlayVisible){\n                this.hide();\n            }\n            else{\n                this.show();\n            }\n\n            this.focusInputEl.nativeElement.focus();\n        }\n    }\n\n    onFocus() {\n        this.focused = true;\n    }\n\n    onBlur() {\n        this.focused = false;\n    }\n\n    onOverlayAnimationStart(event: AnimationEvent) {\n        switch (event.toState) {\n            case 'visible':\n                this.overlayEl = event.element;\n                this.onOverlayEnter();\n            break;\n        }\n    }\n\n    onOverlayAnimationDone(event: AnimationEvent) {\n        switch (event.toState) {\n            case 'void':\n                this.onOverlayLeave();\n            break;\n        }\n    }\n\n    onOverlayEnter() {\n        this.overlayEl.style.zIndex = String(DomHandler.generateZIndex());\n        this.appendContainer();\n        this.alignOverlay();\n        this.bindOutsideClickListener();\n        this.bindScrollListener();\n        this.bindResizeListener();\n        this.onShow.emit();\n    }\n\n    onOverlayLeave() {\n        this.unbindOutsideClickListener();\n        this.unbindScrollListener();\n        this.unbindResizeListener();\n        this.onHide.emit();\n        this.overlayEl = null;\n        this.dirty = false;\n    }\n\n    writeValue(value: any) : void {\n        this.value = value;\n        this.updateSelectionPath();\n        this.cd.markForCheck();\n    }\n\n    registerOnChange(fn: Function): void {\n        this.onModelChange = fn;\n    }\n\n    registerOnTouched(fn: Function): void {\n        this.onModelTouched = fn;\n    }\n\n    setDisabledState(val: boolean): void {\n        this.disabled = val;\n        this.cd.markForCheck();\n    }\n\n    alignOverlay() {\n        if (this.appendTo) {\n            DomHandler.absolutePosition(this.overlayEl, this.containerEl.nativeElement);\n            this.overlayEl.style.minWidth = DomHandler.getOuterWidth(this.containerEl.nativeElement) + 'px';\n        } else {\n            DomHandler.relativePosition(this.overlayEl, this.containerEl.nativeElement);\n        }\n    }\n\n    bindOutsideClickListener() {\n        if (!this.outsideClickListener) {\n            this.outsideClickListener = (event) => {\n                if (this.overlayVisible && this.overlayEl && !this.containerEl.nativeElement.contains(event.target) && !this.overlayEl.contains(event.target)) {\n                    this.hide();\n                }\n            };\n            document.addEventListener('click', this.outsideClickListener);\n        }\n    }\n\n    unbindOutsideClickListener() {\n        if (this.outsideClickListener) {\n            document.removeEventListener('click', this.outsideClickListener);\n            this.outsideClickListener = null;\n        }\n    }\n\n    bindScrollListener() {\n        if (!this.scrollHandler) {\n            this.scrollHandler = new ConnectedOverlayScrollHandler(this.containerEl.nativeElement, () => {\n                if (this.overlayVisible) {\n                    this.hide();\n                }\n            });\n        }\n\n        this.scrollHandler.bindScrollListener();\n    }\n\n    unbindScrollListener() {\n        if (this.scrollHandler) {\n            this.scrollHandler.unbindScrollListener();\n        }\n    }\n\n    bindResizeListener() {\n        if (!this.resizeListener) {\n            this.resizeListener = () => {\n                if (this.overlayVisible) {\n                    this.hide();\n                }\n            };\n            window.addEventListener('resize', this.resizeListener);\n        }\n    }\n\n    unbindResizeListener() {\n        if (this.resizeListener) {\n            window.removeEventListener('resize', this.resizeListener);\n            this.resizeListener = null;\n        }\n    }\n\n    appendContainer() {\n        if (this.appendTo) {\n            if (this.appendTo === 'body')\n                document.body.appendChild(this.overlayEl);\n            else\n                document.getElementById(this.appendTo).appendChild(this.overlayEl);\n        }\n    }\n\n    restoreAppend() {\n        if (this.overlayEl && this.appendTo) {\n            if (this.appendTo === 'body')\n                document.body.removeChild(this.overlayEl);\n            else\n                document.getElementById(this.appendTo).removeChild(this.overlayEl);\n        }\n    }\n\n    label() {\n        if (this.selectionPath)\n            return this.getOptionLabel(this.selectionPath[this.selectionPath.length - 1]);\n        else\n            return this.placeholder||'p-emptylabel';\n    }\n\n    onKeyDown(event) {\n        switch(event.key) {\n            case 'Down':\n            case 'ArrowDown':\n                if (this.overlayVisible) {\n                    DomHandler.findSingle(this.overlayEl, '.p-cascadeselect-item').children[0].focus();\n                }\n                else if (event.altKey && this.options && this.options.length) {\n                    this.show();\n                }\n                event.preventDefault();\n            break;\n\n            case 'Escape':\n                if (this.overlayVisible) {\n                    this.hide();\n                    event.preventDefault();\n                }\n            break;\n\n            case 'Tab':\n                this.hide();\n            break;\n        }\n    }\n\n    containerClass() {\n        return {\n            'p-cascadeselect p-component p-inputwrapper': true,\n            'p-disabled': this.disabled,\n            'p-focus': this.focused,\n            'p-inputwrapper-filled': this.value,\n            'p-inputwrapper-focus': this.focused\n        };\n    }\n\n    labelClass() {\n        return {\n            'p-cascadeselect-label': true,\n            'p-placeholder': this.label() === this.placeholder,\n            'p-cascadeselect-label-empty': !this.value && (this.label() === 'p-emptylabel' || this.label().length === 0)\n        };\n    }\n\n    ngOnDestroy() {\n        this.restoreAppend();\n        this.unbindOutsideClickListener();\n        this.unbindResizeListener();\n\n        if (this.scrollHandler) {\n            this.scrollHandler.destroy();\n            this.scrollHandler = null;\n        }\n        this.overlayEl = null;\n    }\n}\n\n@NgModule({\n    imports: [CommonModule, SharedModule, RippleModule],\n    exports: [CascadeSelect, CascadeSelectSub, SharedModule],\n    declarations: [CascadeSelect, CascadeSelectSub]\n})\nexport class CascadeSelectModule { }\n"]}