novo-elements 5.1.1 → 5.2.3

package/esm2015/elements/picker/extras/mixed-multi-picker-results/MixedMultiPickerResults.js

@@ -1,193 +1,193 @@
-import { ChangeDetectorRef, Component, ElementRef, Renderer2, ViewChild } from '@angular/core';
-import { debounceTime, distinctUntilChanged } from 'rxjs/operators';
-import { BasePickerResults } from '../base-picker-results/BasePickerResults';
-import { Helpers } from '../../../../utils/Helpers';
-import { NovoLabelService } from '../../../../services/novo-label-service';
-import { NovoListElement } from '../../../list/List';
-import { fromEvent } from 'rxjs';
-export class MixedMultiPickerResults extends BasePickerResults {
-    constructor(element, renderer, labels, ref) {
-        super(element, ref);
-        this.renderer = renderer;
-        this.labels = labels;
-        this.placeholder = '';
-        this.internalMap = new Map();
-    }
-    set term(value) {
-        if (this.config.placeholder) {
-            this.placeholder = this.config.placeholder;
-        }
-        // Focus
-        setTimeout(() => {
-            this.inputElement.nativeElement.focus();
-        });
-    }
-    get options() {
-        return this.config.options || [];
-    }
-    ngOnDestroy() {
-        // Cleanup
-        if (this.keyboardSubscription) {
-            this.keyboardSubscription.unsubscribe();
-        }
-    }
-    selectPrimaryOption(primaryOption, event) {
-        if (this.keyboardSubscription) {
-            this.keyboardSubscription.unsubscribe();
-        }
-        // Scroll to top
-        this.renderer.setProperty(this.listElement.element.nativeElement, 'scrollTop', 0);
-        // Set focus
-        this.inputElement.nativeElement.focus();
-        // Find new items
-        const key = primaryOption.value;
-        this.selectedPrimaryOption = primaryOption;
-        // Clear
-        this.matches = [];
-        this.ref.markForCheck();
-        // New matches
-        if (this.optionHasSecondaryOptions(primaryOption)) {
-            // Subscribe to keyboard events and debounce
-            this.keyboardSubscription = fromEvent(this.inputElement.nativeElement, 'keyup')
-                .pipe(debounceTime(350), distinctUntilChanged()).subscribe((keyEvent) => {
-                this.searchTerm = keyEvent.target['value'];
-                this.matches = this.filterData();
-                this.ref.markForCheck();
-            });
-            this.getNewMatches(primaryOption);
-        }
-        else {
-            this.selectActive(primaryOption);
-            this.selectMatch(event);
-        }
-    }
-    selectMatch(event) {
-        // Set focus
-        this.inputElement.nativeElement.focus();
-        return super.selectMatch(event);
-    }
-    clearSearchTerm(event) {
-        Helpers.swallowEvent(event);
-        this.searchTerm = '';
-        this.selectPrimaryOption({ value: this.selectedPrimaryOption.value, label: this.selectedPrimaryOption.label });
-        this.ref.markForCheck();
-    }
-    optionHasSecondaryOptions(primaryOption) {
-        return !!(primaryOption && (primaryOption.secondaryOptions || primaryOption.getSecondaryOptionsAsync));
-    }
-    shouldShowSearchBox(primaryOption) {
-        return !!(primaryOption && primaryOption.showSearchOnSecondaryOptions);
-    }
-    filterData() {
-        if (this.selectedPrimaryOption) {
-            if (this.selectedPrimaryOption.secondaryOptions) {
-                return this.filter(this.selectedPrimaryOption.secondaryOptions);
-            }
-            else {
-                return this.filter(this.internalMap.get(this.selectedPrimaryOption.value).items);
-            }
-        }
-        return [];
-    }
-    filter(array) {
-        let matches = array;
-        if (this.searchTerm && this.searchTerm.length !== 0 && this.selectedPrimaryOption) {
-            matches = matches.filter((match) => {
-                const searchTerm = this.searchTerm.toLowerCase();
-                return match.label.toLowerCase().indexOf(searchTerm) > -1 || match.value.toLowerCase().indexOf(searchTerm) > -1;
-            });
-        }
-        return matches;
-    }
-    getNewMatches(primaryOption) {
-        // Get new matches
-        if (primaryOption.secondaryOptions) {
-            this.matches = this.filter(primaryOption.secondaryOptions);
-            this.ref.markForCheck();
-        }
-        else {
-            if (!primaryOption.getSecondaryOptionsAsync) {
-                throw new Error('An option needs to have either an array of secondaryOptions or a function getSecondaryOptionsAsync');
-            }
-            if (!this.internalMap.get(primaryOption.value)) {
-                this.isLoading = true;
-                primaryOption.getSecondaryOptionsAsync().then((items) => {
-                    this.internalMap.set(primaryOption.value, { value: primaryOption.value, label: primaryOption.label, items });
-                    this.matches = this.filter(items);
-                    this.isLoading = false;
-                    this.ref.markForCheck();
-                    setTimeout(() => {
-                        this.inputElement.nativeElement.focus();
-                    });
-                });
-            }
-            else {
-                this.matches = this.filter(this.internalMap.get(primaryOption.value).items);
-                this.ref.markForCheck();
-            }
-        }
-    }
-}
-MixedMultiPickerResults.decorators = [
-    { type: Component, args: [{
-                selector: 'mixed-multi-picker-results',
-                template: `
-    <div class="mixed-multi-picker-groups">
-        <novo-list direction="vertical">
-            <novo-list-item
-                *ngFor="let option of options"
-                (click)="selectPrimaryOption(option, $event)"
-                [class.active]="selectedPrimaryOption?.value === option.value"
-                [attr.data-automation-id]="option.label"
-                [class.disabled]="isLoading">
-                <item-content>
-                    <i *ngIf="option.iconClass" [class]="option.iconClass"></i>
-                    <span data-automation-id="label">{{ option.label }}</span>
-                </item-content>
-                <item-end *ngIf="optionHasSecondaryOptions(option)">
-                    <i class="bhi-next"></i>
-                </item-end>
-            </novo-list-item>
-        </novo-list>
-    </div>
-    <div class="mixed-multi-picker-matches" [hidden]="!optionHasSecondaryOptions(selectedPrimaryOption)">
-        <div class="mixed-multi-picker-input-container" [hidden]="!shouldShowSearchBox(selectedPrimaryOption)" data-automation-id="input-container">
-            <input autofocus #input [(ngModel)]="searchTerm" [disabled]="isLoading" data-automation-id="input" [placeholder]="placeholder"/>
-            <i class="bhi-search" *ngIf="!searchTerm" [class.disabled]="isLoading" data-automation-id="seach-icon"></i>
-            <i class="bhi-times" *ngIf="searchTerm" (click)="clearSearchTerm($event)" [class.disabled]="isLoading" data-automation-id="remove-icon"></i>
-        </div>
-        <div class="mixed-multi-picker-list-container">
-            <novo-list direction="vertical" #list>
-                <novo-list-item
-                    *ngFor="let match of matches"
-                    (click)="selectMatch($event)"
-                    [class.active]="match === activeMatch"
-                    (mouseenter)="selectActive(match)"
-                    [class.disabled]="preselected(match) || isLoading"
-                    [attr.data-automation-id]="match.label">
-                    <item-content>
-                        <span>{{ match.label }}</span>
-                    </item-content>
-                </novo-list-item>
-            </novo-list>
-            <div class="mixed-multi-picker-no-results" *ngIf="matches.length === 0 && !isLoading && selectedPrimaryOption" data-automation-id="empty-message">
-                {{ labels.groupedMultiPickerEmpty }}
-            </div>
-            <div class="mixed-multi-picker-loading" *ngIf="isLoading" data-automation-id="loading-message">
-                <novo-loading theme="line"></novo-loading>
-            </div>
-        </div>
-    </div>`
-            },] }
-];
-MixedMultiPickerResults.ctorParameters = () => [
-    { type: ElementRef },
-    { type: Renderer2 },
-    { type: NovoLabelService },
-    { type: ChangeDetectorRef }
-];
-MixedMultiPickerResults.propDecorators = {
-    inputElement: [{ type: ViewChild, args: ['input', { static: true },] }],
-    listElement: [{ type: ViewChild, args: ['list',] }]
-};
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"MixedMultiPickerResults.js","sourceRoot":"C:/Users/charles.barnes/Documents/dev/novo-elements/projects/novo-elements/src/","sources":["elements/picker/extras/mixed-multi-picker-results/MixedMultiPickerResults.ts"],"names":[],"mappings":"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","sourcesContent":["import { ChangeDetectorRef, Component, ElementRef, OnDestroy, Renderer2, ViewChild } from '@angular/core';\r\nimport { debounceTime, distinctUntilChanged } from 'rxjs/operators';\r\n\r\nimport { BasePickerResults } from '../base-picker-results/BasePickerResults';\r\nimport { Helpers } from '../../../../utils/Helpers';\r\nimport { NovoLabelService } from '../../../../services/novo-label-service';\r\nimport { NovoListElement } from '../../../list/List';\r\nimport { fromEvent, Subscription } from 'rxjs';\r\n\r\n\r\nexport interface IMixedMultiPickerOption {\r\n    value: string;\r\n    label: string;\r\n    secondaryOptions?: {\r\n        value: string,\r\n        label: string,\r\n        filterValue?: any,\r\n    }[];\r\n    getSecondaryOptionsAsync?(): Promise<{value: string, label: string}[]>;\r\n    showSearchOnSecondaryOptions?: boolean;\r\n}\r\n\r\n@Component({\r\n    selector: 'mixed-multi-picker-results',\r\n    template: `\r\n    <div class=\"mixed-multi-picker-groups\">\r\n        <novo-list direction=\"vertical\">\r\n            <novo-list-item\r\n                *ngFor=\"let option of options\"\r\n                (click)=\"selectPrimaryOption(option, $event)\"\r\n                [class.active]=\"selectedPrimaryOption?.value === option.value\"\r\n                [attr.data-automation-id]=\"option.label\"\r\n                [class.disabled]=\"isLoading\">\r\n                <item-content>\r\n                    <i *ngIf=\"option.iconClass\" [class]=\"option.iconClass\"></i>\r\n                    <span data-automation-id=\"label\">{{ option.label }}</span>\r\n                </item-content>\r\n                <item-end *ngIf=\"optionHasSecondaryOptions(option)\">\r\n                    <i class=\"bhi-next\"></i>\r\n                </item-end>\r\n            </novo-list-item>\r\n        </novo-list>\r\n    </div>\r\n    <div class=\"mixed-multi-picker-matches\" [hidden]=\"!optionHasSecondaryOptions(selectedPrimaryOption)\">\r\n        <div class=\"mixed-multi-picker-input-container\" [hidden]=\"!shouldShowSearchBox(selectedPrimaryOption)\" data-automation-id=\"input-container\">\r\n            <input autofocus #input [(ngModel)]=\"searchTerm\" [disabled]=\"isLoading\" data-automation-id=\"input\" [placeholder]=\"placeholder\"/>\r\n            <i class=\"bhi-search\" *ngIf=\"!searchTerm\" [class.disabled]=\"isLoading\" data-automation-id=\"seach-icon\"></i>\r\n            <i class=\"bhi-times\" *ngIf=\"searchTerm\" (click)=\"clearSearchTerm($event)\" [class.disabled]=\"isLoading\" data-automation-id=\"remove-icon\"></i>\r\n        </div>\r\n        <div class=\"mixed-multi-picker-list-container\">\r\n            <novo-list direction=\"vertical\" #list>\r\n                <novo-list-item\r\n                    *ngFor=\"let match of matches\"\r\n                    (click)=\"selectMatch($event)\"\r\n                    [class.active]=\"match === activeMatch\"\r\n                    (mouseenter)=\"selectActive(match)\"\r\n                    [class.disabled]=\"preselected(match) || isLoading\"\r\n                    [attr.data-automation-id]=\"match.label\">\r\n                    <item-content>\r\n                        <span>{{ match.label }}</span>\r\n                    </item-content>\r\n                </novo-list-item>\r\n            </novo-list>\r\n            <div class=\"mixed-multi-picker-no-results\" *ngIf=\"matches.length === 0 && !isLoading && selectedPrimaryOption\" data-automation-id=\"empty-message\">\r\n                {{ labels.groupedMultiPickerEmpty }}\r\n            </div>\r\n            <div class=\"mixed-multi-picker-loading\" *ngIf=\"isLoading\" data-automation-id=\"loading-message\">\r\n                <novo-loading theme=\"line\"></novo-loading>\r\n            </div>\r\n        </div>\r\n    </div>`,\r\n})\r\nexport class MixedMultiPickerResults extends BasePickerResults implements OnDestroy {\r\n    @ViewChild('input', { static: true })\r\n    private inputElement: ElementRef;\r\n    @ViewChild('list')\r\n    private listElement: NovoListElement;\r\n\r\n    public selectedPrimaryOption: IMixedMultiPickerOption;\r\n    public searchTerm: string;\r\n    public placeholder: string = '';\r\n\r\n    private keyboardSubscription: Subscription;\r\n\r\n    private internalMap: Map<string, { value: string; label: string; items: { value: string; label: string }[] }> = new Map<\r\n        string,\r\n        { value: string; label: string; items: { value: string; label: string }[] }\r\n    >();\r\n\r\n    set term(value) {\r\n        if (this.config.placeholder) {\r\n          this.placeholder = this.config.placeholder;\r\n        }\r\n        // Focus\r\n        setTimeout(() => {\r\n          this.inputElement.nativeElement.focus();\r\n        });\r\n    }\r\n\r\n    get options() {\r\n        return this.config.options || [];\r\n    }\r\n\r\n    constructor(element: ElementRef, private renderer: Renderer2, public labels: NovoLabelService, ref: ChangeDetectorRef) {\r\n        super(element, ref);\r\n    }\r\n\r\n    public ngOnDestroy() {\r\n        // Cleanup\r\n        if (this.keyboardSubscription) {\r\n            this.keyboardSubscription.unsubscribe();\r\n        }\r\n    }\r\n\r\n    public selectPrimaryOption(primaryOption: IMixedMultiPickerOption, event?: MouseEvent): void {\r\n        if (this.keyboardSubscription) {\r\n            this.keyboardSubscription.unsubscribe();\r\n        }\r\n        // Scroll to top\r\n        this.renderer.setProperty(this.listElement.element.nativeElement, 'scrollTop', 0);\r\n        // Set focus\r\n        this.inputElement.nativeElement.focus();\r\n        // Find new items\r\n        const key: string = primaryOption.value;\r\n        this.selectedPrimaryOption = primaryOption;\r\n        // Clear\r\n        this.matches = [];\r\n        this.ref.markForCheck();\r\n        // New matches\r\n        if (this.optionHasSecondaryOptions(primaryOption)) {\r\n            // Subscribe to keyboard events and debounce\r\n            this.keyboardSubscription = fromEvent(this.inputElement.nativeElement, 'keyup')\r\n            .pipe(\r\n                debounceTime(350),\r\n                distinctUntilChanged(),\r\n            ).subscribe((keyEvent: KeyboardEvent) => {\r\n                this.searchTerm = keyEvent.target['value'];\r\n                this.matches = this.filterData();\r\n                this.ref.markForCheck();\r\n            });\r\n            this.getNewMatches(primaryOption);\r\n        } else {\r\n            this.selectActive(primaryOption);\r\n            this.selectMatch(event);\r\n        }\r\n    }\r\n\r\n    public selectMatch(event?: MouseEvent): boolean {\r\n        // Set focus\r\n        this.inputElement.nativeElement.focus();\r\n        return super.selectMatch(event);\r\n    }\r\n\r\n    public clearSearchTerm(event: MouseEvent) {\r\n        Helpers.swallowEvent(event);\r\n        this.searchTerm = '';\r\n        this.selectPrimaryOption({ value: this.selectedPrimaryOption.value, label: this.selectedPrimaryOption.label });\r\n        this.ref.markForCheck();\r\n    }\r\n\r\n    public optionHasSecondaryOptions(primaryOption: IMixedMultiPickerOption) {\r\n        return !!(primaryOption && (primaryOption.secondaryOptions || primaryOption.getSecondaryOptionsAsync));\r\n    }\r\n\r\n    public shouldShowSearchBox(primaryOption: IMixedMultiPickerOption) {\r\n        return !!(primaryOption && primaryOption.showSearchOnSecondaryOptions);\r\n    }\r\n\r\n    filterData(): { value: string; label: string }[] {\r\n        if (this.selectedPrimaryOption) {\r\n            if (this.selectedPrimaryOption.secondaryOptions) {\r\n                return this.filter(this.selectedPrimaryOption.secondaryOptions);\r\n            } else {\r\n                return this.filter(this.internalMap.get(this.selectedPrimaryOption.value).items);\r\n            }\r\n        }\r\n        return [];\r\n    }\r\n\r\n    private filter(\r\n        array: { value: string; label: string; filterValue?: any }[]\r\n    ): { value: string; label: string }[] {\r\n        let matches: { value: string; label: string; filterValue?: any }[] = array;\r\n        if (this.searchTerm && this.searchTerm.length !== 0 && this.selectedPrimaryOption) {\r\n            matches = matches.filter((match) => {\r\n                const searchTerm = this.searchTerm.toLowerCase();\r\n                return match.label.toLowerCase().indexOf(searchTerm) > -1 || match.value.toLowerCase().indexOf(searchTerm) > -1;\r\n            });\r\n        }\r\n        return matches;\r\n    }\r\n\r\n    private getNewMatches(primaryOption: IMixedMultiPickerOption): void {\r\n        // Get new matches\r\n        if (primaryOption.secondaryOptions) {\r\n          this.matches = this.filter(primaryOption.secondaryOptions);\r\n          this.ref.markForCheck();\r\n        } else {\r\n            if (!primaryOption.getSecondaryOptionsAsync) {\r\n                throw new Error(\r\n                    'An option needs to have either an array of secondaryOptions or a function getSecondaryOptionsAsync',\r\n                );\r\n            }\r\n            if (!this.internalMap.get(primaryOption.value)) {\r\n                this.isLoading = true;\r\n                primaryOption.getSecondaryOptionsAsync().then((items: { value: string; label: string }[]) => {\r\n                    this.internalMap.set(primaryOption.value, { value: primaryOption.value, label: primaryOption.label, items });\r\n                    this.matches = this.filter(items);\r\n                    this.isLoading = false;\r\n                    this.ref.markForCheck();\r\n                    setTimeout(() => {\r\n                        this.inputElement.nativeElement.focus();\r\n                    });\r\n                });\r\n            } else {\r\n                this.matches = this.filter(this.internalMap.get(primaryOption.value).items);\r\n                this.ref.markForCheck();\r\n            }\r\n        }\r\n    }\r\n}\r\n"]}
+import { ChangeDetectorRef, Component, ElementRef, Renderer2, ViewChild } from '@angular/core';
+import { debounceTime, distinctUntilChanged } from 'rxjs/operators';
+import { BasePickerResults } from '../base-picker-results/BasePickerResults';
+import { Helpers } from '../../../../utils/Helpers';
+import { NovoLabelService } from '../../../../services/novo-label-service';
+import { NovoListElement } from '../../../list/List';
+import { fromEvent } from 'rxjs';
+export class MixedMultiPickerResults extends BasePickerResults {
+    constructor(element, renderer, labels, ref) {
+        super(element, ref);
+        this.renderer = renderer;
+        this.labels = labels;
+        this.placeholder = '';
+        this.internalMap = new Map();
+    }
+    set term(value) {
+        if (this.config.placeholder) {
+            this.placeholder = this.config.placeholder;
+        }
+        // Focus
+        setTimeout(() => {
+            this.inputElement.nativeElement.focus();
+        });
+    }
+    get options() {
+        return this.config.options || [];
+    }
+    ngOnDestroy() {
+        // Cleanup
+        if (this.keyboardSubscription) {
+            this.keyboardSubscription.unsubscribe();
+        }
+    }
+    selectPrimaryOption(primaryOption, event) {
+        if (this.keyboardSubscription) {
+            this.keyboardSubscription.unsubscribe();
+        }
+        // Scroll to top
+        this.renderer.setProperty(this.listElement.element.nativeElement, 'scrollTop', 0);
+        // Set focus
+        this.inputElement.nativeElement.focus();
+        // Find new items
+        const key = primaryOption.value;
+        this.selectedPrimaryOption = primaryOption;
+        // Clear
+        this.matches = [];
+        this.ref.markForCheck();
+        // New matches
+        if (this.optionHasSecondaryOptions(primaryOption)) {
+            // Subscribe to keyboard events and debounce
+            this.keyboardSubscription = fromEvent(this.inputElement.nativeElement, 'keyup')
+                .pipe(debounceTime(350), distinctUntilChanged()).subscribe((keyEvent) => {
+                this.searchTerm = keyEvent.target['value'];
+                this.matches = this.filterData();
+                this.ref.markForCheck();
+            });
+            this.getNewMatches(primaryOption);
+        }
+        else {
+            this.selectActive(primaryOption);
+            this.selectMatch(event);
+        }
+    }
+    selectMatch(event) {
+        // Set focus
+        this.inputElement.nativeElement.focus();
+        return super.selectMatch(event);
+    }
+    clearSearchTerm(event) {
+        Helpers.swallowEvent(event);
+        this.searchTerm = '';
+        this.selectPrimaryOption({ value: this.selectedPrimaryOption.value, label: this.selectedPrimaryOption.label });
+        this.ref.markForCheck();
+    }
+    optionHasSecondaryOptions(primaryOption) {
+        return !!(primaryOption && (primaryOption.secondaryOptions || primaryOption.getSecondaryOptionsAsync));
+    }
+    shouldShowSearchBox(primaryOption) {
+        return !!(primaryOption && primaryOption.showSearchOnSecondaryOptions);
+    }
+    filterData() {
+        if (this.selectedPrimaryOption) {
+            if (this.selectedPrimaryOption.secondaryOptions) {
+                return this.filter(this.selectedPrimaryOption.secondaryOptions);
+            }
+            else {
+                return this.filter(this.internalMap.get(this.selectedPrimaryOption.value).items);
+            }
+        }
+        return [];
+    }
+    filter(array) {
+        let matches = array;
+        if (this.searchTerm && this.searchTerm.length !== 0 && this.selectedPrimaryOption) {
+            matches = matches.filter((match) => {
+                const searchTerm = this.searchTerm.toLowerCase();
+                return match.label.toLowerCase().indexOf(searchTerm) > -1 || match.value.toLowerCase().indexOf(searchTerm) > -1;
+            });
+        }
+        return matches;
+    }
+    getNewMatches(primaryOption) {
+        // Get new matches
+        if (primaryOption.secondaryOptions) {
+            this.matches = this.filter(primaryOption.secondaryOptions);
+            this.ref.markForCheck();
+        }
+        else {
+            if (!primaryOption.getSecondaryOptionsAsync) {
+                throw new Error('An option needs to have either an array of secondaryOptions or a function getSecondaryOptionsAsync');
+            }
+            if (!this.internalMap.get(primaryOption.value)) {
+                this.isLoading = true;
+                primaryOption.getSecondaryOptionsAsync().then((items) => {
+                    this.internalMap.set(primaryOption.value, { value: primaryOption.value, label: primaryOption.label, items });
+                    this.matches = this.filter(items);
+                    this.isLoading = false;
+                    this.ref.markForCheck();
+                    setTimeout(() => {
+                        this.inputElement.nativeElement.focus();
+                    });
+                });
+            }
+            else {
+                this.matches = this.filter(this.internalMap.get(primaryOption.value).items);
+                this.ref.markForCheck();
+            }
+        }
+    }
+}
+MixedMultiPickerResults.decorators = [
+    { type: Component, args: [{
+                selector: 'mixed-multi-picker-results',
+                template: `
+    <div class="mixed-multi-picker-groups">
+        <novo-list direction="vertical">
+            <novo-list-item
+                *ngFor="let option of options"
+                (click)="selectPrimaryOption(option, $event)"
+                [class.active]="selectedPrimaryOption?.value === option.value"
+                [attr.data-automation-id]="option.label"
+                [class.disabled]="isLoading">
+                <item-content>
+                    <i *ngIf="option.iconClass" [class]="option.iconClass"></i>
+                    <span data-automation-id="label">{{ option.label }}</span>
+                </item-content>
+                <item-end *ngIf="optionHasSecondaryOptions(option)">
+                    <i class="bhi-next"></i>
+                </item-end>
+            </novo-list-item>
+        </novo-list>
+    </div>
+    <div class="mixed-multi-picker-matches" [hidden]="!optionHasSecondaryOptions(selectedPrimaryOption)">
+        <div class="mixed-multi-picker-input-container" [hidden]="!shouldShowSearchBox(selectedPrimaryOption)" data-automation-id="input-container">
+            <input autofocus #input [(ngModel)]="searchTerm" [disabled]="isLoading" data-automation-id="input" [placeholder]="placeholder"/>
+            <i class="bhi-search" *ngIf="!searchTerm" [class.disabled]="isLoading" data-automation-id="seach-icon"></i>
+            <i class="bhi-times" *ngIf="searchTerm" (click)="clearSearchTerm($event)" [class.disabled]="isLoading" data-automation-id="remove-icon"></i>
+        </div>
+        <div class="mixed-multi-picker-list-container">
+            <novo-list direction="vertical" #list>
+                <novo-list-item
+                    *ngFor="let match of matches"
+                    (click)="selectMatch($event)"
+                    [class.active]="match === activeMatch"
+                    (mouseenter)="selectActive(match)"
+                    [class.disabled]="preselected(match) || isLoading"
+                    [attr.data-automation-id]="match.label">
+                    <item-content>
+                        <span>{{ match.label }}</span>
+                    </item-content>
+                </novo-list-item>
+            </novo-list>
+            <div class="mixed-multi-picker-no-results" *ngIf="matches.length === 0 && !isLoading && selectedPrimaryOption" data-automation-id="empty-message">
+                {{ labels.groupedMultiPickerEmpty }}
+            </div>
+            <div class="mixed-multi-picker-loading" *ngIf="isLoading" data-automation-id="loading-message">
+                <novo-loading theme="line"></novo-loading>
+            </div>
+        </div>
+    </div>`
+            },] }
+];
+MixedMultiPickerResults.ctorParameters = () => [
+    { type: ElementRef },
+    { type: Renderer2 },
+    { type: NovoLabelService },
+    { type: ChangeDetectorRef }
+];
+MixedMultiPickerResults.propDecorators = {
+    inputElement: [{ type: ViewChild, args: ['input', { static: true },] }],
+    listElement: [{ type: ViewChild, args: ['list',] }]
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"MixedMultiPickerResults.js","sourceRoot":"/home/runner/work/novo-elements/novo-elements/projects/novo-elements/src/","sources":["elements/picker/extras/mixed-multi-picker-results/MixedMultiPickerResults.ts"],"names":[],"mappings":"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","sourcesContent":["import { ChangeDetectorRef, Component, ElementRef, OnDestroy, Renderer2, ViewChild } from '@angular/core';\nimport { debounceTime, distinctUntilChanged } from 'rxjs/operators';\n\nimport { BasePickerResults } from '../base-picker-results/BasePickerResults';\nimport { Helpers } from '../../../../utils/Helpers';\nimport { NovoLabelService } from '../../../../services/novo-label-service';\nimport { NovoListElement } from '../../../list/List';\nimport { fromEvent, Subscription } from 'rxjs';\n\n\nexport interface IMixedMultiPickerOption {\n    value: string;\n    label: string;\n    secondaryOptions?: {\n        value: string,\n        label: string,\n        filterValue?: any,\n    }[];\n    getSecondaryOptionsAsync?(): Promise<{value: string, label: string}[]>;\n    showSearchOnSecondaryOptions?: boolean;\n}\n\n@Component({\n    selector: 'mixed-multi-picker-results',\n    template: `\n    <div class=\"mixed-multi-picker-groups\">\n        <novo-list direction=\"vertical\">\n            <novo-list-item\n                *ngFor=\"let option of options\"\n                (click)=\"selectPrimaryOption(option, $event)\"\n                [class.active]=\"selectedPrimaryOption?.value === option.value\"\n                [attr.data-automation-id]=\"option.label\"\n                [class.disabled]=\"isLoading\">\n                <item-content>\n                    <i *ngIf=\"option.iconClass\" [class]=\"option.iconClass\"></i>\n                    <span data-automation-id=\"label\">{{ option.label }}</span>\n                </item-content>\n                <item-end *ngIf=\"optionHasSecondaryOptions(option)\">\n                    <i class=\"bhi-next\"></i>\n                </item-end>\n            </novo-list-item>\n        </novo-list>\n    </div>\n    <div class=\"mixed-multi-picker-matches\" [hidden]=\"!optionHasSecondaryOptions(selectedPrimaryOption)\">\n        <div class=\"mixed-multi-picker-input-container\" [hidden]=\"!shouldShowSearchBox(selectedPrimaryOption)\" data-automation-id=\"input-container\">\n            <input autofocus #input [(ngModel)]=\"searchTerm\" [disabled]=\"isLoading\" data-automation-id=\"input\" [placeholder]=\"placeholder\"/>\n            <i class=\"bhi-search\" *ngIf=\"!searchTerm\" [class.disabled]=\"isLoading\" data-automation-id=\"seach-icon\"></i>\n            <i class=\"bhi-times\" *ngIf=\"searchTerm\" (click)=\"clearSearchTerm($event)\" [class.disabled]=\"isLoading\" data-automation-id=\"remove-icon\"></i>\n        </div>\n        <div class=\"mixed-multi-picker-list-container\">\n            <novo-list direction=\"vertical\" #list>\n                <novo-list-item\n                    *ngFor=\"let match of matches\"\n                    (click)=\"selectMatch($event)\"\n                    [class.active]=\"match === activeMatch\"\n                    (mouseenter)=\"selectActive(match)\"\n                    [class.disabled]=\"preselected(match) || isLoading\"\n                    [attr.data-automation-id]=\"match.label\">\n                    <item-content>\n                        <span>{{ match.label }}</span>\n                    </item-content>\n                </novo-list-item>\n            </novo-list>\n            <div class=\"mixed-multi-picker-no-results\" *ngIf=\"matches.length === 0 && !isLoading && selectedPrimaryOption\" data-automation-id=\"empty-message\">\n                {{ labels.groupedMultiPickerEmpty }}\n            </div>\n            <div class=\"mixed-multi-picker-loading\" *ngIf=\"isLoading\" data-automation-id=\"loading-message\">\n                <novo-loading theme=\"line\"></novo-loading>\n            </div>\n        </div>\n    </div>`,\n})\nexport class MixedMultiPickerResults extends BasePickerResults implements OnDestroy {\n    @ViewChild('input', { static: true })\n    private inputElement: ElementRef;\n    @ViewChild('list')\n    private listElement: NovoListElement;\n\n    public selectedPrimaryOption: IMixedMultiPickerOption;\n    public searchTerm: string;\n    public placeholder: string = '';\n\n    private keyboardSubscription: Subscription;\n\n    private internalMap: Map<string, { value: string; label: string; items: { value: string; label: string }[] }> = new Map<\n        string,\n        { value: string; label: string; items: { value: string; label: string }[] }\n    >();\n\n    set term(value) {\n        if (this.config.placeholder) {\n          this.placeholder = this.config.placeholder;\n        }\n        // Focus\n        setTimeout(() => {\n          this.inputElement.nativeElement.focus();\n        });\n    }\n\n    get options() {\n        return this.config.options || [];\n    }\n\n    constructor(element: ElementRef, private renderer: Renderer2, public labels: NovoLabelService, ref: ChangeDetectorRef) {\n        super(element, ref);\n    }\n\n    public ngOnDestroy() {\n        // Cleanup\n        if (this.keyboardSubscription) {\n            this.keyboardSubscription.unsubscribe();\n        }\n    }\n\n    public selectPrimaryOption(primaryOption: IMixedMultiPickerOption, event?: MouseEvent): void {\n        if (this.keyboardSubscription) {\n            this.keyboardSubscription.unsubscribe();\n        }\n        // Scroll to top\n        this.renderer.setProperty(this.listElement.element.nativeElement, 'scrollTop', 0);\n        // Set focus\n        this.inputElement.nativeElement.focus();\n        // Find new items\n        const key: string = primaryOption.value;\n        this.selectedPrimaryOption = primaryOption;\n        // Clear\n        this.matches = [];\n        this.ref.markForCheck();\n        // New matches\n        if (this.optionHasSecondaryOptions(primaryOption)) {\n            // Subscribe to keyboard events and debounce\n            this.keyboardSubscription = fromEvent(this.inputElement.nativeElement, 'keyup')\n            .pipe(\n                debounceTime(350),\n                distinctUntilChanged(),\n            ).subscribe((keyEvent: KeyboardEvent) => {\n                this.searchTerm = keyEvent.target['value'];\n                this.matches = this.filterData();\n                this.ref.markForCheck();\n            });\n            this.getNewMatches(primaryOption);\n        } else {\n            this.selectActive(primaryOption);\n            this.selectMatch(event);\n        }\n    }\n\n    public selectMatch(event?: MouseEvent): boolean {\n        // Set focus\n        this.inputElement.nativeElement.focus();\n        return super.selectMatch(event);\n    }\n\n    public clearSearchTerm(event: MouseEvent) {\n        Helpers.swallowEvent(event);\n        this.searchTerm = '';\n        this.selectPrimaryOption({ value: this.selectedPrimaryOption.value, label: this.selectedPrimaryOption.label });\n        this.ref.markForCheck();\n    }\n\n    public optionHasSecondaryOptions(primaryOption: IMixedMultiPickerOption) {\n        return !!(primaryOption && (primaryOption.secondaryOptions || primaryOption.getSecondaryOptionsAsync));\n    }\n\n    public shouldShowSearchBox(primaryOption: IMixedMultiPickerOption) {\n        return !!(primaryOption && primaryOption.showSearchOnSecondaryOptions);\n    }\n\n    filterData(): { value: string; label: string }[] {\n        if (this.selectedPrimaryOption) {\n            if (this.selectedPrimaryOption.secondaryOptions) {\n                return this.filter(this.selectedPrimaryOption.secondaryOptions);\n            } else {\n                return this.filter(this.internalMap.get(this.selectedPrimaryOption.value).items);\n            }\n        }\n        return [];\n    }\n\n    private filter(\n        array: { value: string; label: string; filterValue?: any }[]\n    ): { value: string; label: string }[] {\n        let matches: { value: string; label: string; filterValue?: any }[] = array;\n        if (this.searchTerm && this.searchTerm.length !== 0 && this.selectedPrimaryOption) {\n            matches = matches.filter((match) => {\n                const searchTerm = this.searchTerm.toLowerCase();\n                return match.label.toLowerCase().indexOf(searchTerm) > -1 || match.value.toLowerCase().indexOf(searchTerm) > -1;\n            });\n        }\n        return matches;\n    }\n\n    private getNewMatches(primaryOption: IMixedMultiPickerOption): void {\n        // Get new matches\n        if (primaryOption.secondaryOptions) {\n          this.matches = this.filter(primaryOption.secondaryOptions);\n          this.ref.markForCheck();\n        } else {\n            if (!primaryOption.getSecondaryOptionsAsync) {\n                throw new Error(\n                    'An option needs to have either an array of secondaryOptions or a function getSecondaryOptionsAsync',\n                );\n            }\n            if (!this.internalMap.get(primaryOption.value)) {\n                this.isLoading = true;\n                primaryOption.getSecondaryOptionsAsync().then((items: { value: string; label: string }[]) => {\n                    this.internalMap.set(primaryOption.value, { value: primaryOption.value, label: primaryOption.label, items });\n                    this.matches = this.filter(items);\n                    this.isLoading = false;\n                    this.ref.markForCheck();\n                    setTimeout(() => {\n                        this.inputElement.nativeElement.focus();\n                    });\n                });\n            } else {\n                this.matches = this.filter(this.internalMap.get(primaryOption.value).items);\n                this.ref.markForCheck();\n            }\n        }\n    }\n}\n"]}

package/esm2015/elements/picker/extras/picker-results/PickerResults.js

@@ -1,60 +1,60 @@
-// NG2
-import { Component, ElementRef, ChangeDetectorRef } from '@angular/core';
-// APP
-import { NovoLabelService } from '../../../../services/novo-label-service';
-import { BasePickerResults } from '../base-picker-results/BasePickerResults';
-export class PickerResults extends BasePickerResults {
-    constructor(element, labels, ref) {
-        super(element, ref);
-        this.labels = labels;
-    }
-    get hasNonErrorMessage() {
-        return !this.isLoading && !this.matches.length && !this.hasError;
-    }
-    getEmptyMessage() {
-        if (this.shouldShowMessageForZeroLengthSearch()) {
-            // this property comes from Field Interactions
-            return this.config.emptyPickerMessage;
-        }
-        else {
-            return this.term === '' ? this.labels.pickerTextFieldEmpty : this.labels.pickerEmpty;
-        }
-    }
-    shouldShowMessageForZeroLengthSearch() {
-        return this.config && this.config.minSearchLength === 0 && this.term === '' && this.config.emptyPickerMessage;
-    }
-    getListElement() {
-        return this.element.nativeElement.querySelector('novo-list');
-    }
-}
-PickerResults.decorators = [
-    { type: Component, args: [{
-                selector: 'picker-results',
-                host: {
-                    class: 'active',
-                },
-                template: `
-    <novo-list *ngIf="matches.length > 0" direction="vertical">
-      <novo-list-item
-        *ngFor="let match of matches"
-        (click)="selectMatch($event)"
-        [class.active]="match === activeMatch"
-        (mouseenter)="selectActive(match)"
-        [class.disabled]="preselected(match)"
-      >
-        <item-content> <span [innerHtml]="highlight(match.label, term)"></span> </item-content>
-      </novo-list-item>
-      <novo-loading *ngIf="isLoading && matches.length > 0" theme="line"></novo-loading>
-    </novo-list>
-    <div class="picker-loader" *ngIf="isLoading && matches.length === 0"><novo-loading theme="line"></novo-loading></div>
-    <p class="picker-error" *ngIf="hasError">{{ labels.pickerError }}</p>
-    <p class="picker-null-results" *ngIf="hasNonErrorMessage">{{ getEmptyMessage() }}</p>
-  `
-            },] }
-];
-PickerResults.ctorParameters = () => [
-    { type: ElementRef },
-    { type: NovoLabelService },
-    { type: ChangeDetectorRef }
-];
-//# sourceMappingURL=data:application/json;base64,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
+// NG2
+import { Component, ElementRef, ChangeDetectorRef } from '@angular/core';
+// APP
+import { NovoLabelService } from '../../../../services/novo-label-service';
+import { BasePickerResults } from '../base-picker-results/BasePickerResults';
+export class PickerResults extends BasePickerResults {
+    constructor(element, labels, ref) {
+        super(element, ref);
+        this.labels = labels;
+    }
+    get hasNonErrorMessage() {
+        return !this.isLoading && !this.matches.length && !this.hasError;
+    }
+    getEmptyMessage() {
+        if (this.shouldShowMessageForZeroLengthSearch()) {
+            // this property comes from Field Interactions
+            return this.config.emptyPickerMessage;
+        }
+        else {
+            return this.term === '' ? this.labels.pickerTextFieldEmpty : this.labels.pickerEmpty;
+        }
+    }
+    shouldShowMessageForZeroLengthSearch() {
+        return this.config && this.config.minSearchLength === 0 && this.term === '' && this.config.emptyPickerMessage;
+    }
+    getListElement() {
+        return this.element.nativeElement.querySelector('novo-list');
+    }
+}
+PickerResults.decorators = [
+    { type: Component, args: [{
+                selector: 'picker-results',
+                host: {
+                    class: 'active',
+                },
+                template: `
+    <novo-list *ngIf="matches.length > 0" direction="vertical">
+      <novo-list-item
+        *ngFor="let match of matches"
+        (click)="selectMatch($event)"
+        [class.active]="match === activeMatch"
+        (mouseenter)="selectActive(match)"
+        [class.disabled]="preselected(match)"
+      >
+        <item-content> <span [innerHtml]="highlight(match.label, term)"></span> </item-content>
+      </novo-list-item>
+      <novo-loading *ngIf="isLoading && matches.length > 0" theme="line"></novo-loading>
+    </novo-list>
+    <div class="picker-loader" *ngIf="isLoading && matches.length === 0"><novo-loading theme="line"></novo-loading></div>
+    <p class="picker-error" *ngIf="hasError">{{ labels.pickerError }}</p>
+    <p class="picker-null-results" *ngIf="hasNonErrorMessage">{{ getEmptyMessage() }}</p>
+  `
+            },] }
+];
+PickerResults.ctorParameters = () => [
+    { type: ElementRef },
+    { type: NovoLabelService },
+    { type: ChangeDetectorRef }
+];
+//# sourceMappingURL=data:application/json;base64,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