novo-elements 5.1.1 → 5.2.3

package/esm2015/elements/picker/extras/grouped-multi-picker-results/GroupedMultiPickerResults.js

@@ -1,264 +1,264 @@
-import { Component, ElementRef, ViewChild, Renderer2, ChangeDetectorRef } from '@angular/core';
-import { fromEvent } from 'rxjs';
-import { debounceTime, distinctUntilChanged } from 'rxjs/operators';
-import { BasePickerResults } from '../base-picker-results/BasePickerResults';
-import { Helpers } from '../../../../utils/Helpers';
-import { NovoListElement } from '../../../list/List';
-import { NovoLabelService } from '../../../../services/novo-label-service';
-export class GroupedMultiPickerResults extends BasePickerResults {
-    constructor(element, renderer, labels, ref) {
-        super(element, ref);
-        this.renderer = renderer;
-        this.labels = labels;
-        this.customFilterEnabled = false;
-        this.placeholder = '';
-        this.internalMap = new Map();
-    }
-    set term(value) {
-        // Display all only will work for static categories
-        if (this.config.displayAll && this.config.getItemsForCategoryAsync) {
-            throw new Error('[GroupedMultiPickerResults] - you can only have `displayAll` with a static `categoryMap`. Not available with `getItemsForCategoryAsync`');
-        }
-        // Custom filter
-        if (this.config.customFilter) {
-            this.customFilterEnabled = true;
-            this.customFilterLabel = this.config.customFilter.label;
-            this.customFilterValue = !!this.config.customFilter.defaultFilterValue;
-            this.ref.markForCheck();
-            if (!this.customFilterLabel || !this.config.customFilter.matchFunction) {
-                throw new Error('[GroupedMultiPickerResults] - custom filter/matchFunction set no label was provided!');
-            }
-        }
-        else {
-            this.customFilterEnabled = false;
-        }
-        // Configure ALL
-        if (this.config.displayAll && !this.selectedCategory) {
-            this.setAllCategory();
-        }
-        // Placeholder
-        if (this.config.placeholder) {
-            this.placeholder = this.config.placeholder;
-        }
-        // Focus
-        setTimeout(() => {
-            this.inputElement.nativeElement.focus();
-        });
-    }
-    get categories() {
-        if (this.config.categories || this.config.categoryMap) {
-            return (this.config.categories ||
-                Array.from(this.config.categoryMap.values()).filter((category) => {
-                    return category.value !== 'all';
-                }));
-        }
-        return [];
-    }
-    ngOnInit() {
-        // Subscribe to keyboard events and debounce
-        this.keyboardSubscription = fromEvent(this.inputElement.nativeElement, 'keyup')
-            .pipe(debounceTime(350), distinctUntilChanged())
-            .subscribe((event) => {
-            this.searchTerm = event.target['value'];
-            this.matches = this.filterData();
-            this.ref.markForCheck();
-        });
-    }
-    ngOnDestroy() {
-        // Cleanup
-        this.keyboardSubscription.unsubscribe();
-    }
-    setAllCategory() {
-        // If we have display all, set the all categories up
-        if (this.config.displayAll) {
-            this.selectedCategory = { value: 'all', label: 'all' };
-            const allItems = [];
-            Array.from(this.config.categoryMap.values())
-                .filter((category) => {
-                return category.value !== 'all';
-            })
-                .forEach((v) => allItems.push(...v.items));
-            this.matches = this.filter(allItems);
-            this.config.categoryMap.set('all', { value: 'all', label: 'All', items: allItems });
-            this.ref.markForCheck();
-        }
-    }
-    selectCategory(category) {
-        // Scroll to top
-        this.renderer.setProperty(this.listElement.element.nativeElement, 'scrollTop', 0);
-        // Set focus
-        this.inputElement.nativeElement.focus();
-        // Find new items
-        const key = category.value;
-        this.selectedCategory = category;
-        // Clear
-        this.matches = [];
-        this.ref.markForCheck();
-        // New matches
-        this.getNewMatches(category, key);
-    }
-    clearSearchTerm(event) {
-        Helpers.swallowEvent(event);
-        this.searchTerm = '';
-        this.selectCategory({ value: this.selectedCategory.value, label: this.selectedCategory.label });
-        this.ref.markForCheck();
-    }
-    selectMatch(event, item) {
-        // Set focus
-        this.inputElement.nativeElement.focus();
-        return super.selectMatch(event);
-    }
-    fireCustomFilter(value) {
-        this.customFilterValue = value;
-        // Clear cache map
-        this.internalMap.clear();
-        // Only fire if we have a selected category
-        if (this.selectCategory) {
-            // Find new items
-            const key = this.selectedCategory.value;
-            // Get new matches
-            this.getNewMatches(this.selectedCategory, key);
-            this.ref.markForCheck();
-        }
-        // Focus
-        setTimeout(() => {
-            this.inputElement.nativeElement.focus();
-        });
-    }
-    filterData() {
-        if (this.selectedCategory) {
-            if (this.config.categoryMap) {
-                return this.filter(this.config.categoryMap.get(this.selectedCategory.value).items);
-            }
-            else {
-                return this.filter(this.internalMap.get(this.selectedCategory.value).items);
-            }
-        }
-        return [];
-    }
-    getNewMatches(category, key) {
-        // Get new matches
-        if (this.config.categoryMap) {
-            this.matches = this.filter(this.config.categoryMap.get(key).items);
-            this.ref.markForCheck();
-        }
-        else {
-            if (!this.config.getItemsForCategoryAsync) {
-                throw new Error('The "config" for the Chips must include a function "getItemsForCategoryAsync(categoryKey: string)" to retrieve the items by category. Or if you have static data provide a "categoryMap"');
-            }
-            if (!this.internalMap.get(key)) {
-                this.isLoading = true;
-                this.config.getItemsForCategoryAsync(key, this.customFilterValue).then((items) => {
-                    this.internalMap.set(key, { value: category.value, label: category.label, items });
-                    this.matches = this.filter(items, true);
-                    this.isLoading = false;
-                    this.ref.markForCheck();
-                    setTimeout(() => {
-                        this.inputElement.nativeElement.focus();
-                    });
-                });
-            }
-            else {
-                this.matches = this.filter(this.internalMap.get(key).items);
-                this.ref.markForCheck();
-            }
-        }
-    }
-    filter(array, ignoreCustomFilter = false) {
-        let matches = array;
-        if (this.searchTerm && this.searchTerm.length !== 0 && this.selectedCategory) {
-            matches = matches.filter((match) => {
-                const searchTerm = this.searchTerm.toLowerCase();
-                return match.label.toLowerCase().indexOf(searchTerm) > -1 || match.value.toLowerCase().indexOf(searchTerm) > -1;
-            });
-        }
-        if (this.customFilterEnabled && this.config.customFilter.matchFunction && !ignoreCustomFilter) {
-            matches = matches.filter((match) => this.config.customFilter.matchFunction(match, this.customFilterValue));
-        }
-        return matches;
-    }
-}
-GroupedMultiPickerResults.decorators = [
-    { type: Component, args: [{
-                selector: 'grouped-multi-picker-results',
-                template: `
-        <div class="grouped-multi-picker-groups">
-            <novo-list direction="vertical">
-                <novo-list-item
-                    *ngIf="config.displayAll"
-                    (click)="selectCategory({ value: 'all', label: 'all' })"
-                    [class.active]="selectedCategory?.value === 'all'"
-                    data-automation-id="display-all"
-                    [class.disabled]="isLoading">
-                    <item-content>
-                        <span data-automation-id="label">{{ labels.all }}</span>
-                    </item-content>
-                    <item-end>
-                        <i class="bhi-next"></i>
-                    </item-end>
-                </novo-list-item>
-                <novo-list-item
-                    *ngFor="let category of categories"
-                    (click)="selectCategory(category)"
-                    [class.active]="selectedCategory?.value === category.value"
-                    [attr.data-automation-id]="category.label"
-                    [class.disabled]="isLoading">
-                    <item-content>
-                        <i *ngIf="category.iconClass" [class]="category.iconClass"></i>
-                        <span data-automation-id="label">{{ category.label }}</span>
-                    </item-content>
-                    <item-end>
-                        <i class="bhi-next"></i>
-                    </item-end>
-                </novo-list-item>
-            </novo-list>
-            <footer class="grouped-multi-picker-groups-footer" *ngIf="customFilterEnabled" data-automation-id="footer" [class.disabled]="isLoading">
-                <novo-switch [(ngModel)]="customFilterValue" (onChange)="fireCustomFilter($event)" data-automation-id="switch"></novo-switch>
-                <label data-automation-id="label">{{ customFilterLabel }}</label>
-            </footer>
-        </div>
-        <div class="grouped-multi-picker-matches">
-            <div class="grouped-multi-picker-input-container" [hidden]="!selectedCategory" 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="grouped-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="grouped-multi-picker-no-results" *ngIf="matches.length === 0 && !isLoading && selectedCategory" data-automation-id="empty-message">
-                    {{ labels.groupedMultiPickerEmpty }}
-                </div>
-                <div class="grouped-multi-picker-no-category" *ngIf="matches.length === 0 && !isLoading && !selectedCategory" data-automation-id="select-category-message">
-                    {{ labels.groupedMultiPickerSelectCategory }}
-                </div>
-                <div class="grouped-multi-picker-loading" *ngIf="isLoading" data-automation-id="loading-message">
-                    <novo-loading theme="line"></novo-loading>
-                </div>
-            </div>
-        </div>
-    `
-            },] }
-];
-GroupedMultiPickerResults.ctorParameters = () => [
-    { type: ElementRef },
-    { type: Renderer2 },
-    { type: NovoLabelService },
-    { type: ChangeDetectorRef }
-];
-GroupedMultiPickerResults.propDecorators = {
-    inputElement: [{ type: ViewChild, args: ['input', { static: true },] }],
-    listElement: [{ type: ViewChild, args: ['list',] }]
-};
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"GroupedMultiPickerResults.js","sourceRoot":"C:/Users/charles.barnes/Documents/dev/novo-elements/projects/novo-elements/src/","sources":["elements/picker/extras/grouped-multi-picker-results/GroupedMultiPickerResults.ts"],"names":[],"mappings":"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","sourcesContent":["import { Component, ElementRef, ViewChild, OnInit, OnDestroy, Renderer2, ChangeDetectorRef } from '@angular/core';\r\nimport { fromEvent, Subscription } from 'rxjs';\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 { NovoListElement } from '../../../list/List';\r\nimport { NovoLabelService } from '../../../../services/novo-label-service';\r\n\r\n@Component({\r\n  selector: 'grouped-multi-picker-results',\r\n  template: `\r\n        <div class=\"grouped-multi-picker-groups\">\r\n            <novo-list direction=\"vertical\">\r\n                <novo-list-item\r\n                    *ngIf=\"config.displayAll\"\r\n                    (click)=\"selectCategory({ value: 'all', label: 'all' })\"\r\n                    [class.active]=\"selectedCategory?.value === 'all'\"\r\n                    data-automation-id=\"display-all\"\r\n                    [class.disabled]=\"isLoading\">\r\n                    <item-content>\r\n                        <span data-automation-id=\"label\">{{ labels.all }}</span>\r\n                    </item-content>\r\n                    <item-end>\r\n                        <i class=\"bhi-next\"></i>\r\n                    </item-end>\r\n                </novo-list-item>\r\n                <novo-list-item\r\n                    *ngFor=\"let category of categories\"\r\n                    (click)=\"selectCategory(category)\"\r\n                    [class.active]=\"selectedCategory?.value === category.value\"\r\n                    [attr.data-automation-id]=\"category.label\"\r\n                    [class.disabled]=\"isLoading\">\r\n                    <item-content>\r\n                        <i *ngIf=\"category.iconClass\" [class]=\"category.iconClass\"></i>\r\n                        <span data-automation-id=\"label\">{{ category.label }}</span>\r\n                    </item-content>\r\n                    <item-end>\r\n                        <i class=\"bhi-next\"></i>\r\n                    </item-end>\r\n                </novo-list-item>\r\n            </novo-list>\r\n            <footer class=\"grouped-multi-picker-groups-footer\" *ngIf=\"customFilterEnabled\" data-automation-id=\"footer\" [class.disabled]=\"isLoading\">\r\n                <novo-switch [(ngModel)]=\"customFilterValue\" (onChange)=\"fireCustomFilter($event)\" data-automation-id=\"switch\"></novo-switch>\r\n                <label data-automation-id=\"label\">{{ customFilterLabel }}</label>\r\n            </footer>\r\n        </div>\r\n        <div class=\"grouped-multi-picker-matches\">\r\n            <div class=\"grouped-multi-picker-input-container\" [hidden]=\"!selectedCategory\" 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=\"grouped-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=\"grouped-multi-picker-no-results\" *ngIf=\"matches.length === 0 && !isLoading && selectedCategory\" data-automation-id=\"empty-message\">\r\n                    {{ labels.groupedMultiPickerEmpty }}\r\n                </div>\r\n                <div class=\"grouped-multi-picker-no-category\" *ngIf=\"matches.length === 0 && !isLoading && !selectedCategory\" data-automation-id=\"select-category-message\">\r\n                    {{ labels.groupedMultiPickerSelectCategory }}\r\n                </div>\r\n                <div class=\"grouped-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\n})\r\nexport class GroupedMultiPickerResults extends BasePickerResults implements OnInit, 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 selectedCategory: { value: string; label: string };\r\n  public searchTerm: string;\r\n  public customFilterEnabled: boolean = false;\r\n  public customFilterLabel: string;\r\n  public placeholder: string = '';\r\n\r\n  private keyboardSubscription: Subscription;\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  public customFilterValue: any;\r\n\r\n  set term(value) {\r\n    // Display all only will work for static categories\r\n    if (this.config.displayAll && this.config.getItemsForCategoryAsync) {\r\n      throw new Error(\r\n        '[GroupedMultiPickerResults] - you can only have `displayAll` with a static `categoryMap`. Not available with `getItemsForCategoryAsync`',\r\n      );\r\n    }\r\n    // Custom filter\r\n    if (this.config.customFilter) {\r\n      this.customFilterEnabled = true;\r\n      this.customFilterLabel = this.config.customFilter.label;\r\n      this.customFilterValue = !!this.config.customFilter.defaultFilterValue;\r\n      this.ref.markForCheck();\r\n      if (!this.customFilterLabel || !this.config.customFilter.matchFunction) {\r\n        throw new Error('[GroupedMultiPickerResults] - custom filter/matchFunction set no label was provided!');\r\n      }\r\n    } else {\r\n      this.customFilterEnabled = false;\r\n    }\r\n    // Configure ALL\r\n    if (this.config.displayAll && !this.selectedCategory) {\r\n      this.setAllCategory();\r\n    }\r\n    // Placeholder\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 categories() {\r\n    if (this.config.categories || this.config.categoryMap) {\r\n      return (\r\n        this.config.categories ||\r\n        Array.from(this.config.categoryMap.values()).filter((category: { value: string }) => {\r\n          return category.value !== 'all';\r\n        })\r\n      );\r\n    }\r\n    return [];\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 ngOnInit() {\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      )\r\n      .subscribe((event: KeyboardEvent) => {\r\n        this.searchTerm = event.target['value'];\r\n        this.matches = this.filterData();\r\n        this.ref.markForCheck();\r\n      });\r\n  }\r\n\r\n  public ngOnDestroy() {\r\n    // Cleanup\r\n    this.keyboardSubscription.unsubscribe();\r\n  }\r\n\r\n  public setAllCategory() {\r\n    // If we have display all, set the all categories up\r\n    if (this.config.displayAll) {\r\n      this.selectedCategory = { value: 'all', label: 'all' };\r\n      const allItems = [];\r\n      Array.from(this.config.categoryMap.values())\r\n        .filter((category: { value: string }) => {\r\n          return category.value !== 'all';\r\n        })\r\n        .forEach((v: { value: string; label: string; items: any[] }) => allItems.push(...v.items));\r\n      this.matches = this.filter(allItems);\r\n      this.config.categoryMap.set('all', { value: 'all', label: 'All', items: allItems });\r\n      this.ref.markForCheck();\r\n    }\r\n  }\r\n\r\n  public selectCategory(category: { value: string; label: string }): void {\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 = category.value;\r\n    this.selectedCategory = category;\r\n    // Clear\r\n    this.matches = [];\r\n    this.ref.markForCheck();\r\n    // New matches\r\n    this.getNewMatches(category, key);\r\n  }\r\n\r\n  public clearSearchTerm(event: MouseEvent) {\r\n    Helpers.swallowEvent(event);\r\n    this.searchTerm = '';\r\n    this.selectCategory({ value: this.selectedCategory.value, label: this.selectedCategory.label });\r\n    this.ref.markForCheck();\r\n  }\r\n\r\n  public selectMatch(event?: MouseEvent, item?: { value: string; label: string }): boolean {\r\n    // Set focus\r\n    this.inputElement.nativeElement.focus();\r\n    return super.selectMatch(event);\r\n  }\r\n\r\n  public fireCustomFilter(value: boolean) {\r\n    this.customFilterValue = value;\r\n    // Clear cache map\r\n    this.internalMap.clear();\r\n    // Only fire if we have a selected category\r\n    if (this.selectCategory) {\r\n      // Find new items\r\n      const key: string = this.selectedCategory.value;\r\n      // Get new matches\r\n      this.getNewMatches(this.selectedCategory, key);\r\n      this.ref.markForCheck();\r\n    }\r\n    // Focus\r\n    setTimeout(() => {\r\n      this.inputElement.nativeElement.focus();\r\n    });\r\n  }\r\n\r\n  filterData(): { value: string; label: string }[] {\r\n    if (this.selectedCategory) {\r\n      if (this.config.categoryMap) {\r\n        return this.filter(this.config.categoryMap.get(this.selectedCategory.value).items);\r\n      } else {\r\n        return this.filter(this.internalMap.get(this.selectedCategory.value).items);\r\n      }\r\n    }\r\n    return [];\r\n  }\r\n\r\n  private getNewMatches(category: { value: string; label: string }, key: string): void {\r\n    // Get new matches\r\n    if (this.config.categoryMap) {\r\n      this.matches = this.filter(this.config.categoryMap.get(key).items);\r\n      this.ref.markForCheck();\r\n    } else {\r\n      if (!this.config.getItemsForCategoryAsync) {\r\n        throw new Error(\r\n          'The \"config\" for the Chips must include a function \"getItemsForCategoryAsync(categoryKey: string)\" to retrieve the items by category. Or if you have static data provide a \"categoryMap\"',\r\n        );\r\n      }\r\n      if (!this.internalMap.get(key)) {\r\n        this.isLoading = true;\r\n        this.config.getItemsForCategoryAsync(key, this.customFilterValue).then((items: { value: string; label: string }[]) => {\r\n          this.internalMap.set(key, { value: category.value, label: category.label, items });\r\n          this.matches = this.filter(items, true);\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(key).items);\r\n        this.ref.markForCheck();\r\n      }\r\n    }\r\n  }\r\n\r\n  private filter(\r\n    array: { value: string; label: string; filterValue?: any }[],\r\n    ignoreCustomFilter: boolean = false,\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.selectedCategory) {\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    if (this.customFilterEnabled && this.config.customFilter.matchFunction && !ignoreCustomFilter) {\r\n      matches = matches.filter((match) => this.config.customFilter.matchFunction(match, this.customFilterValue));\r\n    }\r\n    return matches;\r\n  }\r\n}\r\n"]}
+import { Component, ElementRef, ViewChild, Renderer2, ChangeDetectorRef } from '@angular/core';
+import { fromEvent } from 'rxjs';
+import { debounceTime, distinctUntilChanged } from 'rxjs/operators';
+import { BasePickerResults } from '../base-picker-results/BasePickerResults';
+import { Helpers } from '../../../../utils/Helpers';
+import { NovoListElement } from '../../../list/List';
+import { NovoLabelService } from '../../../../services/novo-label-service';
+export class GroupedMultiPickerResults extends BasePickerResults {
+    constructor(element, renderer, labels, ref) {
+        super(element, ref);
+        this.renderer = renderer;
+        this.labels = labels;
+        this.customFilterEnabled = false;
+        this.placeholder = '';
+        this.internalMap = new Map();
+    }
+    set term(value) {
+        // Display all only will work for static categories
+        if (this.config.displayAll && this.config.getItemsForCategoryAsync) {
+            throw new Error('[GroupedMultiPickerResults] - you can only have `displayAll` with a static `categoryMap`. Not available with `getItemsForCategoryAsync`');
+        }
+        // Custom filter
+        if (this.config.customFilter) {
+            this.customFilterEnabled = true;
+            this.customFilterLabel = this.config.customFilter.label;
+            this.customFilterValue = !!this.config.customFilter.defaultFilterValue;
+            this.ref.markForCheck();
+            if (!this.customFilterLabel || !this.config.customFilter.matchFunction) {
+                throw new Error('[GroupedMultiPickerResults] - custom filter/matchFunction set no label was provided!');
+            }
+        }
+        else {
+            this.customFilterEnabled = false;
+        }
+        // Configure ALL
+        if (this.config.displayAll && !this.selectedCategory) {
+            this.setAllCategory();
+        }
+        // Placeholder
+        if (this.config.placeholder) {
+            this.placeholder = this.config.placeholder;
+        }
+        // Focus
+        setTimeout(() => {
+            this.inputElement.nativeElement.focus();
+        });
+    }
+    get categories() {
+        if (this.config.categories || this.config.categoryMap) {
+            return (this.config.categories ||
+                Array.from(this.config.categoryMap.values()).filter((category) => {
+                    return category.value !== 'all';
+                }));
+        }
+        return [];
+    }
+    ngOnInit() {
+        // Subscribe to keyboard events and debounce
+        this.keyboardSubscription = fromEvent(this.inputElement.nativeElement, 'keyup')
+            .pipe(debounceTime(350), distinctUntilChanged())
+            .subscribe((event) => {
+            this.searchTerm = event.target['value'];
+            this.matches = this.filterData();
+            this.ref.markForCheck();
+        });
+    }
+    ngOnDestroy() {
+        // Cleanup
+        this.keyboardSubscription.unsubscribe();
+    }
+    setAllCategory() {
+        // If we have display all, set the all categories up
+        if (this.config.displayAll) {
+            this.selectedCategory = { value: 'all', label: 'all' };
+            const allItems = [];
+            Array.from(this.config.categoryMap.values())
+                .filter((category) => {
+                return category.value !== 'all';
+            })
+                .forEach((v) => allItems.push(...v.items));
+            this.matches = this.filter(allItems);
+            this.config.categoryMap.set('all', { value: 'all', label: 'All', items: allItems });
+            this.ref.markForCheck();
+        }
+    }
+    selectCategory(category) {
+        // Scroll to top
+        this.renderer.setProperty(this.listElement.element.nativeElement, 'scrollTop', 0);
+        // Set focus
+        this.inputElement.nativeElement.focus();
+        // Find new items
+        const key = category.value;
+        this.selectedCategory = category;
+        // Clear
+        this.matches = [];
+        this.ref.markForCheck();
+        // New matches
+        this.getNewMatches(category, key);
+    }
+    clearSearchTerm(event) {
+        Helpers.swallowEvent(event);
+        this.searchTerm = '';
+        this.selectCategory({ value: this.selectedCategory.value, label: this.selectedCategory.label });
+        this.ref.markForCheck();
+    }
+    selectMatch(event, item) {
+        // Set focus
+        this.inputElement.nativeElement.focus();
+        return super.selectMatch(event);
+    }
+    fireCustomFilter(value) {
+        this.customFilterValue = value;
+        // Clear cache map
+        this.internalMap.clear();
+        // Only fire if we have a selected category
+        if (this.selectCategory) {
+            // Find new items
+            const key = this.selectedCategory.value;
+            // Get new matches
+            this.getNewMatches(this.selectedCategory, key);
+            this.ref.markForCheck();
+        }
+        // Focus
+        setTimeout(() => {
+            this.inputElement.nativeElement.focus();
+        });
+    }
+    filterData() {
+        if (this.selectedCategory) {
+            if (this.config.categoryMap) {
+                return this.filter(this.config.categoryMap.get(this.selectedCategory.value).items);
+            }
+            else {
+                return this.filter(this.internalMap.get(this.selectedCategory.value).items);
+            }
+        }
+        return [];
+    }
+    getNewMatches(category, key) {
+        // Get new matches
+        if (this.config.categoryMap) {
+            this.matches = this.filter(this.config.categoryMap.get(key).items);
+            this.ref.markForCheck();
+        }
+        else {
+            if (!this.config.getItemsForCategoryAsync) {
+                throw new Error('The "config" for the Chips must include a function "getItemsForCategoryAsync(categoryKey: string)" to retrieve the items by category. Or if you have static data provide a "categoryMap"');
+            }
+            if (!this.internalMap.get(key)) {
+                this.isLoading = true;
+                this.config.getItemsForCategoryAsync(key, this.customFilterValue).then((items) => {
+                    this.internalMap.set(key, { value: category.value, label: category.label, items });
+                    this.matches = this.filter(items, true);
+                    this.isLoading = false;
+                    this.ref.markForCheck();
+                    setTimeout(() => {
+                        this.inputElement.nativeElement.focus();
+                    });
+                });
+            }
+            else {
+                this.matches = this.filter(this.internalMap.get(key).items);
+                this.ref.markForCheck();
+            }
+        }
+    }
+    filter(array, ignoreCustomFilter = false) {
+        let matches = array;
+        if (this.searchTerm && this.searchTerm.length !== 0 && this.selectedCategory) {
+            matches = matches.filter((match) => {
+                const searchTerm = this.searchTerm.toLowerCase();
+                return match.label.toLowerCase().indexOf(searchTerm) > -1 || match.value.toLowerCase().indexOf(searchTerm) > -1;
+            });
+        }
+        if (this.customFilterEnabled && this.config.customFilter.matchFunction && !ignoreCustomFilter) {
+            matches = matches.filter((match) => this.config.customFilter.matchFunction(match, this.customFilterValue));
+        }
+        return matches;
+    }
+}
+GroupedMultiPickerResults.decorators = [
+    { type: Component, args: [{
+                selector: 'grouped-multi-picker-results',
+                template: `
+        <div class="grouped-multi-picker-groups">
+            <novo-list direction="vertical">
+                <novo-list-item
+                    *ngIf="config.displayAll"
+                    (click)="selectCategory({ value: 'all', label: 'all' })"
+                    [class.active]="selectedCategory?.value === 'all'"
+                    data-automation-id="display-all"
+                    [class.disabled]="isLoading">
+                    <item-content>
+                        <span data-automation-id="label">{{ labels.all }}</span>
+                    </item-content>
+                    <item-end>
+                        <i class="bhi-next"></i>
+                    </item-end>
+                </novo-list-item>
+                <novo-list-item
+                    *ngFor="let category of categories"
+                    (click)="selectCategory(category)"
+                    [class.active]="selectedCategory?.value === category.value"
+                    [attr.data-automation-id]="category.label"
+                    [class.disabled]="isLoading">
+                    <item-content>
+                        <i *ngIf="category.iconClass" [class]="category.iconClass"></i>
+                        <span data-automation-id="label">{{ category.label }}</span>
+                    </item-content>
+                    <item-end>
+                        <i class="bhi-next"></i>
+                    </item-end>
+                </novo-list-item>
+            </novo-list>
+            <footer class="grouped-multi-picker-groups-footer" *ngIf="customFilterEnabled" data-automation-id="footer" [class.disabled]="isLoading">
+                <novo-switch [(ngModel)]="customFilterValue" (onChange)="fireCustomFilter($event)" data-automation-id="switch"></novo-switch>
+                <label data-automation-id="label">{{ customFilterLabel }}</label>
+            </footer>
+        </div>
+        <div class="grouped-multi-picker-matches">
+            <div class="grouped-multi-picker-input-container" [hidden]="!selectedCategory" 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="grouped-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="grouped-multi-picker-no-results" *ngIf="matches.length === 0 && !isLoading && selectedCategory" data-automation-id="empty-message">
+                    {{ labels.groupedMultiPickerEmpty }}
+                </div>
+                <div class="grouped-multi-picker-no-category" *ngIf="matches.length === 0 && !isLoading && !selectedCategory" data-automation-id="select-category-message">
+                    {{ labels.groupedMultiPickerSelectCategory }}
+                </div>
+                <div class="grouped-multi-picker-loading" *ngIf="isLoading" data-automation-id="loading-message">
+                    <novo-loading theme="line"></novo-loading>
+                </div>
+            </div>
+        </div>
+    `
+            },] }
+];
+GroupedMultiPickerResults.ctorParameters = () => [
+    { type: ElementRef },
+    { type: Renderer2 },
+    { type: NovoLabelService },
+    { type: ChangeDetectorRef }
+];
+GroupedMultiPickerResults.propDecorators = {
+    inputElement: [{ type: ViewChild, args: ['input', { static: true },] }],
+    listElement: [{ type: ViewChild, args: ['list',] }]
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"GroupedMultiPickerResults.js","sourceRoot":"/home/runner/work/novo-elements/novo-elements/projects/novo-elements/src/","sources":["elements/picker/extras/grouped-multi-picker-results/GroupedMultiPickerResults.ts"],"names":[],"mappings":"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","sourcesContent":["import { Component, ElementRef, ViewChild, OnInit, OnDestroy, Renderer2, ChangeDetectorRef } from '@angular/core';\nimport { fromEvent, Subscription } from 'rxjs';\nimport { debounceTime, distinctUntilChanged } from 'rxjs/operators';\n\nimport { BasePickerResults } from '../base-picker-results/BasePickerResults';\nimport { Helpers } from '../../../../utils/Helpers';\nimport { NovoListElement } from '../../../list/List';\nimport { NovoLabelService } from '../../../../services/novo-label-service';\n\n@Component({\n  selector: 'grouped-multi-picker-results',\n  template: `\n        <div class=\"grouped-multi-picker-groups\">\n            <novo-list direction=\"vertical\">\n                <novo-list-item\n                    *ngIf=\"config.displayAll\"\n                    (click)=\"selectCategory({ value: 'all', label: 'all' })\"\n                    [class.active]=\"selectedCategory?.value === 'all'\"\n                    data-automation-id=\"display-all\"\n                    [class.disabled]=\"isLoading\">\n                    <item-content>\n                        <span data-automation-id=\"label\">{{ labels.all }}</span>\n                    </item-content>\n                    <item-end>\n                        <i class=\"bhi-next\"></i>\n                    </item-end>\n                </novo-list-item>\n                <novo-list-item\n                    *ngFor=\"let category of categories\"\n                    (click)=\"selectCategory(category)\"\n                    [class.active]=\"selectedCategory?.value === category.value\"\n                    [attr.data-automation-id]=\"category.label\"\n                    [class.disabled]=\"isLoading\">\n                    <item-content>\n                        <i *ngIf=\"category.iconClass\" [class]=\"category.iconClass\"></i>\n                        <span data-automation-id=\"label\">{{ category.label }}</span>\n                    </item-content>\n                    <item-end>\n                        <i class=\"bhi-next\"></i>\n                    </item-end>\n                </novo-list-item>\n            </novo-list>\n            <footer class=\"grouped-multi-picker-groups-footer\" *ngIf=\"customFilterEnabled\" data-automation-id=\"footer\" [class.disabled]=\"isLoading\">\n                <novo-switch [(ngModel)]=\"customFilterValue\" (onChange)=\"fireCustomFilter($event)\" data-automation-id=\"switch\"></novo-switch>\n                <label data-automation-id=\"label\">{{ customFilterLabel }}</label>\n            </footer>\n        </div>\n        <div class=\"grouped-multi-picker-matches\">\n            <div class=\"grouped-multi-picker-input-container\" [hidden]=\"!selectedCategory\" 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=\"grouped-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=\"grouped-multi-picker-no-results\" *ngIf=\"matches.length === 0 && !isLoading && selectedCategory\" data-automation-id=\"empty-message\">\n                    {{ labels.groupedMultiPickerEmpty }}\n                </div>\n                <div class=\"grouped-multi-picker-no-category\" *ngIf=\"matches.length === 0 && !isLoading && !selectedCategory\" data-automation-id=\"select-category-message\">\n                    {{ labels.groupedMultiPickerSelectCategory }}\n                </div>\n                <div class=\"grouped-multi-picker-loading\" *ngIf=\"isLoading\" data-automation-id=\"loading-message\">\n                    <novo-loading theme=\"line\"></novo-loading>\n                </div>\n            </div>\n        </div>\n    `,\n})\nexport class GroupedMultiPickerResults extends BasePickerResults implements OnInit, OnDestroy {\n  @ViewChild('input', { static: true })\n  private inputElement: ElementRef;\n  @ViewChild('list')\n  private listElement: NovoListElement;\n\n  public selectedCategory: { value: string; label: string };\n  public searchTerm: string;\n  public customFilterEnabled: boolean = false;\n  public customFilterLabel: string;\n  public placeholder: string = '';\n\n  private keyboardSubscription: Subscription;\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  public customFilterValue: any;\n\n  set term(value) {\n    // Display all only will work for static categories\n    if (this.config.displayAll && this.config.getItemsForCategoryAsync) {\n      throw new Error(\n        '[GroupedMultiPickerResults] - you can only have `displayAll` with a static `categoryMap`. Not available with `getItemsForCategoryAsync`',\n      );\n    }\n    // Custom filter\n    if (this.config.customFilter) {\n      this.customFilterEnabled = true;\n      this.customFilterLabel = this.config.customFilter.label;\n      this.customFilterValue = !!this.config.customFilter.defaultFilterValue;\n      this.ref.markForCheck();\n      if (!this.customFilterLabel || !this.config.customFilter.matchFunction) {\n        throw new Error('[GroupedMultiPickerResults] - custom filter/matchFunction set no label was provided!');\n      }\n    } else {\n      this.customFilterEnabled = false;\n    }\n    // Configure ALL\n    if (this.config.displayAll && !this.selectedCategory) {\n      this.setAllCategory();\n    }\n    // Placeholder\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 categories() {\n    if (this.config.categories || this.config.categoryMap) {\n      return (\n        this.config.categories ||\n        Array.from(this.config.categoryMap.values()).filter((category: { value: string }) => {\n          return category.value !== 'all';\n        })\n      );\n    }\n    return [];\n  }\n\n  constructor(element: ElementRef, private renderer: Renderer2, public labels: NovoLabelService, ref: ChangeDetectorRef) {\n    super(element, ref);\n  }\n\n  public ngOnInit() {\n    // Subscribe to keyboard events and debounce\n    this.keyboardSubscription = fromEvent(this.inputElement.nativeElement, 'keyup')\n      .pipe(\n        debounceTime(350),\n        distinctUntilChanged(),\n      )\n      .subscribe((event: KeyboardEvent) => {\n        this.searchTerm = event.target['value'];\n        this.matches = this.filterData();\n        this.ref.markForCheck();\n      });\n  }\n\n  public ngOnDestroy() {\n    // Cleanup\n    this.keyboardSubscription.unsubscribe();\n  }\n\n  public setAllCategory() {\n    // If we have display all, set the all categories up\n    if (this.config.displayAll) {\n      this.selectedCategory = { value: 'all', label: 'all' };\n      const allItems = [];\n      Array.from(this.config.categoryMap.values())\n        .filter((category: { value: string }) => {\n          return category.value !== 'all';\n        })\n        .forEach((v: { value: string; label: string; items: any[] }) => allItems.push(...v.items));\n      this.matches = this.filter(allItems);\n      this.config.categoryMap.set('all', { value: 'all', label: 'All', items: allItems });\n      this.ref.markForCheck();\n    }\n  }\n\n  public selectCategory(category: { value: string; label: string }): void {\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 = category.value;\n    this.selectedCategory = category;\n    // Clear\n    this.matches = [];\n    this.ref.markForCheck();\n    // New matches\n    this.getNewMatches(category, key);\n  }\n\n  public clearSearchTerm(event: MouseEvent) {\n    Helpers.swallowEvent(event);\n    this.searchTerm = '';\n    this.selectCategory({ value: this.selectedCategory.value, label: this.selectedCategory.label });\n    this.ref.markForCheck();\n  }\n\n  public selectMatch(event?: MouseEvent, item?: { value: string; label: string }): boolean {\n    // Set focus\n    this.inputElement.nativeElement.focus();\n    return super.selectMatch(event);\n  }\n\n  public fireCustomFilter(value: boolean) {\n    this.customFilterValue = value;\n    // Clear cache map\n    this.internalMap.clear();\n    // Only fire if we have a selected category\n    if (this.selectCategory) {\n      // Find new items\n      const key: string = this.selectedCategory.value;\n      // Get new matches\n      this.getNewMatches(this.selectedCategory, key);\n      this.ref.markForCheck();\n    }\n    // Focus\n    setTimeout(() => {\n      this.inputElement.nativeElement.focus();\n    });\n  }\n\n  filterData(): { value: string; label: string }[] {\n    if (this.selectedCategory) {\n      if (this.config.categoryMap) {\n        return this.filter(this.config.categoryMap.get(this.selectedCategory.value).items);\n      } else {\n        return this.filter(this.internalMap.get(this.selectedCategory.value).items);\n      }\n    }\n    return [];\n  }\n\n  private getNewMatches(category: { value: string; label: string }, key: string): void {\n    // Get new matches\n    if (this.config.categoryMap) {\n      this.matches = this.filter(this.config.categoryMap.get(key).items);\n      this.ref.markForCheck();\n    } else {\n      if (!this.config.getItemsForCategoryAsync) {\n        throw new Error(\n          'The \"config\" for the Chips must include a function \"getItemsForCategoryAsync(categoryKey: string)\" to retrieve the items by category. Or if you have static data provide a \"categoryMap\"',\n        );\n      }\n      if (!this.internalMap.get(key)) {\n        this.isLoading = true;\n        this.config.getItemsForCategoryAsync(key, this.customFilterValue).then((items: { value: string; label: string }[]) => {\n          this.internalMap.set(key, { value: category.value, label: category.label, items });\n          this.matches = this.filter(items, true);\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(key).items);\n        this.ref.markForCheck();\n      }\n    }\n  }\n\n  private filter(\n    array: { value: string; label: string; filterValue?: any }[],\n    ignoreCustomFilter: boolean = false,\n  ): { value: string; label: string }[] {\n    let matches: { value: string; label: string; filterValue?: any }[] = array;\n    if (this.searchTerm && this.searchTerm.length !== 0 && this.selectedCategory) {\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    if (this.customFilterEnabled && this.config.customFilter.matchFunction && !ignoreCustomFilter) {\n      matches = matches.filter((match) => this.config.customFilter.matchFunction(match, this.customFilterValue));\n    }\n    return matches;\n  }\n}\n"]}