@ampath-kenya/ngx-openmrs-formentry 3.0.0-alpha9 → 3.0.0-ampath.1-beta.0

package/esm2015/components/select/select.component.js

@@ -1,238 +1,515 @@
-/* tslint:disable:component-class-suffix  */
-import { Component, ElementRef, Input, Output, HostListener, EventEmitter, TemplateRef, ViewChild } from "@angular/core";
-import { NG_VALUE_ACCESSOR } from "@angular/forms";
-/**
- * `ibm-select` provides a styled `select` component.
- *
- * [See demo](../../?path=/story/select--basic)
- *
- * Example:
- *
- * ```
- * <ibm-select [(ngModel)]="model">
- *     <option value="default" disabled selected hidden>Choose an option</option>
- *     <option value="option1">Option 1</option>
- *    <option value="option2">Option 2</option>
- *     <option value="option3">Option 3</option>
- * </ibm-select>
- *    ```
- *
- * <example-url>../../iframe.html?id=select--basic</example-url>
- */
-export class Select {
+import { Component, Input, Output, EventEmitter, ViewChild, ViewEncapsulation, forwardRef } from '@angular/core';
+import { NG_VALUE_ACCESSOR } from '@angular/forms';
+import { STYLE } from './select.component.style';
+import { SelectDropdownComponent } from './select-dropdown.component';
+import { OptionList } from './option-list';
+export const SELECT_VALUE_ACCESSOR = {
+    provide: NG_VALUE_ACCESSOR,
+    // tslint:disable:no-use-before-declare
+    useExisting: forwardRef(() => SelectComponent),
+    multi: true
+};
+export class SelectComponent {
     constructor() {
-        /**
-         * `inline` or `default` select displays
-         */
-        this.display = "default";
-        /**
-          * Set to `true` to show a warning (contents set by warningText)
-          */
-        this.warn = false;
-        /**
-         * Sets the unique ID. Defaults to `select-${total count of selects instantiated}`
-         */
-        this.id = `select-${Select.selectCount++}`;
-        /**
-         * Number input field render size
-         */
-        this.size = "md";
-        /**
-         * Set to true to disable component.
-         */
+        /** Keys. **/
+        this.KEYS = {
+            BACKSPACE: 8,
+            TAB: 9,
+            ENTER: 13,
+            ESC: 27,
+            SPACE: 32,
+            UP: 38,
+            DOWN: 40
+        };
+        this.allowClear = false;
         this.disabled = false;
-        /**
-         * Set to true for a loading select.
-         */
-        this.skeleton = false;
-        /**
-         * Set to `true` for an invalid select component.
-         */
-        this.invalid = false;
-        /**
-         * `light` or `dark` select theme
-         */
-        this.theme = "dark";
-        this.valueChange = new EventEmitter();
-        /**
-         * placeholder declarations. Replaced by the functions provided to `registerOnChange` and `registerOnTouched`
-         */
-        this.onChangeHandler = (_) => { };
-        this.onTouchedHandler = () => { };
+        this.highlightColor = '#2196f3';
+        this.highlightTextColor = '#fff';
+        this.multiple = false;
+        this.noFilter = 0;
+        this.notFoundMsg = 'No results found';
+        this.placeholder = '';
+        this.opened = new EventEmitter();
+        this.closed = new EventEmitter();
+        this.selected = new EventEmitter();
+        this.deselected = new EventEmitter();
+        this.typed = new EventEmitter();
+        this._value = [];
+        // Selection state variables.
+        this.hasSelected = false;
+        // View state variables.
+        this.filterEnabled = true;
+        this.filterInputWidth = 1;
+        this.hasFocus = false;
+        this.isBelow = true;
+        this.isDisabled = false;
+        this.isOpen = false;
+        this.placeholderView = '';
+        this.clearClicked = false;
+        this.selectContainerClicked = false;
+        this.onChange = (_) => { };
+        this.onTouched = () => { };
     }
-    set value(v) {
-        this._value = v;
-        if (this.select) {
-            this.select.nativeElement.value = this._value;
+    /** Event handlers. **/
+    // Angular lifecycle hooks.
+    ngOnInit() {
+        this.placeholderView = this.placeholder;
+    }
+    ngAfterViewInit() {
+        this.updateFilterWidth();
+    }
+    ngOnChanges(changes) {
+        if (changes.hasOwnProperty('options')) {
+            this.updateOptionsList(changes['options'].isFirstChange());
+        }
+        if (changes.hasOwnProperty('noFilter')) {
+            const numOptions = this.optionList.options.length;
+            const minNumOptions = changes['noFilter'].currentValue;
+            this.filterEnabled = numOptions >= minNumOptions;
         }
     }
-    get value() {
-        return this._value;
+    // Window.
+    onWindowClick() {
+        if (!this.selectContainerClicked) {
+            this.closeDropdown();
+        }
+        this.clearClicked = false;
+        this.selectContainerClicked = false;
+    }
+    onWindowResize() {
+        this.updateWidth();
+    }
+    // Select container.
+    onSelectContainerClick(event) {
+        this.selectContainerClicked = true;
+        if (!this.clearClicked) {
+            this.toggleDropdown();
+        }
+    }
+    onSelectContainerFocus() {
+        this.onTouched();
+    }
+    onSelectContainerKeydown(event) {
+        this.handleSelectContainerKeydown(event);
+    }
+    // Dropdown container.
+    onDropdownOptionClicked(option) {
+        this.multiple ? this.toggleSelectOption(option) : this.selectOption(option);
+    }
+    onDropdownClose(focus) {
+        this.closeDropdown(focus);
+    }
+    // Single filter input.
+    onSingleFilterClick() {
+        this.selectContainerClicked = true;
+    }
+    onSingleFilterInput(term) {
+        setTimeout(() => {
+            if (term.length > 2) {
+                this.typed.emit(term);
+            }
+        }, 500);
+        this.optionList.filter(term);
+    }
+    onSingleFilterKeydown(event) {
+        this.handleSingleFilterKeydown(event);
+    }
+    // Multiple filter input.
+    onMultipleFilterInput(event) {
+        if (!this.isOpen) {
+            this.openDropdown();
+        }
+        this.updateFilterWidth();
+        setTimeout(() => {
+            this.optionList.filter(event.target.value);
+        });
+    }
+    onMultipleFilterKeydown(event) {
+        this.handleMultipleFilterKeydown(event);
+    }
+    // Single clear select.
+    onClearSelectionClick(event) {
+        this.clearClicked = true;
+        this.clearSelection();
+        this.closeDropdown(true);
+    }
+    // Multiple deselect option.
+    onDeselectOptionClick(option) {
+        this.clearClicked = true;
+        this.deselectOption(option);
+    }
+    /** API. **/
+    // TODO fix issues with global click/key handler that closes the dropdown.
+    open() {
+        this.openDropdown();
+    }
+    close() {
+        this.closeDropdown();
+    }
+    clear() {
+        this.clearSelection();
+    }
+    select(value) {
+        this.optionList.getOptionsByValue(value).forEach((option) => {
+            this.selectOption(option);
+        });
+        this.valueChanged();
+    }
+    /** ControlValueAccessor interface methods. **/
+    writeValue(value) {
+        this.value = value;
     }
-    ngAfterViewInit() {
-        if (this.value !== undefined &&
-            this.value !== null &&
-            this.select &&
-            this.select.nativeElement.value !== this.value) {
-            this.select.nativeElement.value = this.value;
-        }
-    }
-    /**
-     * Receives a value from the model.
-     */
-    writeValue(obj) {
-        this.value = obj;
-    }
-    /**
-     * Registers a listener that notifies the model when the control updates
-     */
     registerOnChange(fn) {
-        this.onChangeHandler = fn;
+        this.onChange = fn;
     }
-    /**
-     * Registers a listener that notifies the model when the control is blurred
-     */
     registerOnTouched(fn) {
-        this.onTouchedHandler = fn;
+        this.onTouched = fn;
     }
-    /**
-     * Sets the disabled state through the model
-     */
     setDisabledState(isDisabled) {
         this.disabled = isDisabled;
     }
-    /**
-     * Handles the change event from the `select`.
-     * Sends events to the change handler and emits a `selected` event.
-     */
-    onChange(event) {
-        this.value = event.target.value;
-        this.onChangeHandler(event.target.value);
-        this.valueChange.emit(event.target.value);
+    /** Value. **/
+    get value() {
+        if (this._value.length === 0) {
+            return '';
+        }
+        else {
+            return this.multiple ? this._value : this._value[0];
+        }
     }
-    /**
-     * Listens for the host blurring, and notifies the model
-     */
-    focusOut() {
-        this.onTouchedHandler();
+    set value(v) {
+        if (typeof v === 'undefined' || v === null || v === '') {
+            v = [];
+        }
+        else if (typeof v === 'string') {
+            v = [v];
+        }
+        else if (!Array.isArray(v)) {
+            throw new TypeError('Value must be a string or an array.');
+        }
+        if (!OptionList.equalValues(v, this._value)) {
+            this.optionList.value = v;
+            this.valueChanged();
+        }
     }
-    isTemplate(value) {
-        return value instanceof TemplateRef;
+    valueChanged() {
+        this._value = this.optionList.value;
+        this.hasSelected = this._value.length > 0;
+        this.placeholderView = this.hasSelected ? '' : this.placeholder;
+        this.updateFilterWidth();
+        this.onChange(this.value);
     }
-}
-/**
- * Tracks the total number of selects instantiated. Used to generate unique IDs
- */
-Select.selectCount = 0;
-Select.decorators = [
-    { type: Component, args: [{
-                selector: "ibm-select",
-                template: `
-        <div class="bx--form-item">
-            <ng-template [ngIf]="skeleton">
-                <div *ngIf="label" class="bx--label bx--skeleton"></div>
-                <div class="bx--select bx--skeleton"></div>
-            </ng-template>
-            <div
-                *ngIf="!skeleton"
-                class="bx--select"
-                [ngClass]="{
-                    'bx--select--inline': display === 'inline',
-                    'bx--select--light': theme === 'light',
-                    'bx--select--invalid': invalid,
-                    'bx--select--warning': warn,
-                    'bx--select--disabled': disabled
-                }">
-                <label *ngIf="label" [for]="id" class="bx--label">
-                    <ng-container *ngIf="!isTemplate(label)">{{label}}</ng-container>
-                    <ng-template *ngIf="isTemplate(label)" [ngTemplateOutlet]="label"></ng-template>
-                </label>
-                <div *ngIf="helperText" class="bx--form__helper-text">
-                    <ng-container *ngIf="!isTemplate(helperText)">{{helperText}}</ng-container>
-                    <ng-template *ngIf="isTemplate(helperText)" [ngTemplateOutlet]="helperText"></ng-template>
-                </div>
-                <div *ngIf="display === 'inline'; else noInline" class="bx--select-input--inline__wrapper">
-                    <ng-container *ngTemplateOutlet="noInline"></ng-container>
-                </div>
-            </div>
-        </div>
-
-        <!-- select element: dynamically projected based on 'display' variant -->
-        <ng-template #noInline>
-            <div class="bx--select-input__wrapper" [attr.data-invalid]="(invalid ? true : null)">
-                <select
-                    #select
-                    [attr.id]="id"
-                    [attr.aria-label]="ariaLabel"
-                    [disabled]="disabled"
-                    (change)="onChange($event)"
-                    [attr.aria-invalid]="invalid ? 'true' : null"
-                    class="bx--select-input"
-                    [ngClass]="{
-                        'bx--select-input--xl': size === 'xl',
-                        'bx--select-input--sm': size === 'sm'
-                    }">
-                    <ng-content></ng-content>
-                </select>
-                <svg
-                    focusable="false"
-                    preserveAspectRatio="xMidYMid meet"
-                    style="will-change: transform;"
-                    xmlns="http://www.w3.org/2000/svg"
-                    class="bx--select__arrow"
-                    width="16"
-                    height="16"
-                    viewBox="0 0 16 16"
-                    aria-hidden="true">
-                    <path d="M8 11L3 6 3.7 5.3 8 9.6 12.3 5.3 13 6z"></path>
-                </svg>
-                <svg *ngIf="invalid"focusable="false" preserveAspectRatio="xMidYMid meet" style="will-change: transform;" xmlns="http://www.w3.org/2000/svg" class="bx--text-input__invalid-icon" width="16" height="16" viewBox="0 0 16 16" aria-hidden="true"><path d="M8,1C4.2,1,1,4.2,1,8s3.2,7,7,7s7-3.1,7-7S11.9,1,8,1z M7.5,4h1v5h-1C7.5,9,7.5,4,7.5,4z M8,12.2    c-0.4,0-0.8-0.4-0.8-0.8s0.3-0.8,0.8-0.8c0.4,0,0.8,0.4,0.8,0.8S8.4,12.2,8,12.2z"></path><path d="M7.5,4h1v5h-1C7.5,9,7.5,4,7.5,4z M8,12.2c-0.4,0-0.8-0.4-0.8-0.8s0.3-0.8,0.8-0.8    c0.4,0,0.8,0.4,0.8,0.8S8.4,12.2,8,12.2z" data-icon-path="inner-path" opacity="0"></path></svg>
-            </div>
-            <div *ngIf="invalid && invalidText && !warn" role="alert" class="bx--form-requirement" aria-live="polite">
-                <ng-container *ngIf="!isTemplate(invalidText)">{{invalidText}}</ng-container>
-                <ng-template *ngIf="isTemplate(invalidText)" [ngTemplateOutlet]="invalidText"></ng-template>
-            </div>
-            <div *ngIf="!invalid && warn" class="bx--form-requirement">
-                <ng-container *ngIf="!isTemplate(warnText)">{{warnText}}</ng-container>
-                <ng-template *ngIf="isTemplate(warnText)" [ngTemplateOutlet]="warnText"></ng-template>
-            </div>
-        </ng-template>
-    `,
-                providers: [
-                    {
-                        provide: NG_VALUE_ACCESSOR,
-                        useExisting: Select,
-                        multi: true
+    /** Initialization. **/
+    updateOptionsList(firstTime) {
+        let v;
+        if (!firstTime) {
+            v = this.optionList.value;
+        }
+        this.optionList = new OptionList(this.options);
+        if (!firstTime) {
+            this.optionList.value = v;
+            this.valueChanged();
+        }
+    }
+    /** Dropdown. **/
+    toggleDropdown() {
+        if (!this.isDisabled) {
+            this.isOpen ? this.closeDropdown(true) : this.openDropdown();
+        }
+    }
+    openDropdown() {
+        if (!this.isOpen) {
+            this.updateWidth();
+            this.updatePosition();
+            this.isOpen = true;
+            if (this.multiple && this.filterEnabled) {
+                this.filterInput.nativeElement.focus();
+            }
+            this.opened.emit(null);
+        }
+    }
+    /* tslint:disable */
+    closeDropdown(focus = false) {
+        if (this.isOpen) {
+            this.clearFilterInput();
+            this.isOpen = false;
+            if (focus) {
+                this.focus();
+            }
+            this.closed.emit(null);
+        }
+    }
+    /* tslint:enable */
+    /** Select. **/
+    selectOption(option) {
+        if (!option.selected) {
+            this.optionList.select(option, this.multiple);
+            this.valueChanged();
+            this.selected.emit(option.undecoratedCopy());
+            // Is this not allready done when setting the value??
+            /*setTimeout(() => {
+                      if (this.multiple) {
+                          this.updateFilterWidth();
+                      }
+                  });*/
+        }
+    }
+    deselectOption(option) {
+        if (option.selected) {
+            this.optionList.deselect(option);
+            this.valueChanged();
+            this.deselected.emit(option.undecoratedCopy());
+            setTimeout(() => {
+                if (this.multiple) {
+                    // this.updateFilterWidth();
+                    this.updatePosition();
+                    this.optionList.highlight();
+                    if (this.isOpen) {
+                        this.dropdown.moveHighlightedIntoView();
                     }
-                ],
-                styles: [`
-        .bx--select--inline .bx--form__helper-text {
-            order: 4;
+                }
+            });
         }
-
-        .bx--select--inline:not(.bx--select--invalid) .bx--form__helper-text {
-            margin-top: 0;
+    }
+    clearSelection() {
+        const selection = this.optionList.selection;
+        if (selection.length > 0) {
+            this.optionList.clearSelection();
+            this.valueChanged();
+            if (selection.length === 1) {
+                this.deselected.emit(selection[0].undecoratedCopy());
+            }
+            else {
+                this.deselected.emit(selection.map((option) => {
+                    return option.undecoratedCopy();
+                }));
+            }
+        }
+    }
+    toggleSelectOption(option) {
+        option.selected ? this.deselectOption(option) : this.selectOption(option);
+    }
+    selectHighlightedOption() {
+        const option = this.optionList.highlightedOption;
+        if (option !== null) {
+            this.selectOption(option);
+            this.closeDropdown(true);
+        }
+    }
+    deselectLast() {
+        const sel = this.optionList.selection;
+        if (sel.length > 0) {
+            const option = sel[sel.length - 1];
+            this.deselectOption(option);
+            this.setMultipleFilterInput(option.label + ' ');
+        }
+    }
+    /** Filter. **/
+    clearFilterInput() {
+        if (this.multiple && this.filterEnabled) {
+            this.filterInput.nativeElement.value = '';
+        }
+        else {
+            this.dropdown.clearFilterInput();
+        }
+    }
+    setMultipleFilterInput(value) {
+        if (this.filterEnabled) {
+            this.filterInput.nativeElement.value = value;
         }
-    `]
-            },] }
+    }
+    handleSelectContainerKeydown(event) {
+        const key = event.which;
+        if (this.isOpen) {
+            if (key === this.KEYS.ESC || (key === this.KEYS.UP && event.altKey)) {
+                this.closeDropdown(true);
+            }
+            else if (key === this.KEYS.TAB) {
+                this.closeDropdown();
+            }
+            else if (key === this.KEYS.ENTER) {
+                this.selectHighlightedOption();
+            }
+            else if (key === this.KEYS.UP) {
+                this.optionList.highlightPreviousOption();
+                this.dropdown.moveHighlightedIntoView();
+                if (!this.filterEnabled) {
+                    event.preventDefault();
+                }
+            }
+            else if (key === this.KEYS.DOWN) {
+                this.optionList.highlightNextOption();
+                this.dropdown.moveHighlightedIntoView();
+                if (!this.filterEnabled) {
+                    event.preventDefault();
+                }
+            }
+        }
+        else {
+            if (key === this.KEYS.ENTER ||
+                key === this.KEYS.SPACE ||
+                (key === this.KEYS.DOWN && event.altKey)) {
+                /* FIREFOX HACK:
+                 *
+                 * The setTimeout is added to prevent the enter keydown event
+                 * to be triggered for the filter input field, which causes
+                 * the dropdown to be closed again.
+                 */
+                setTimeout(() => {
+                    this.openDropdown();
+                });
+            }
+        }
+    }
+    handleMultipleFilterKeydown(event) {
+        const key = event.which;
+        if (key === this.KEYS.BACKSPACE) {
+            if (this.hasSelected &&
+                this.filterEnabled &&
+                this.filterInput.nativeElement.value === '') {
+                this.deselectLast();
+            }
+        }
+    }
+    handleSingleFilterKeydown(event) {
+        const key = event.which;
+        if (key === this.KEYS.ESC ||
+            key === this.KEYS.TAB ||
+            key === this.KEYS.UP ||
+            key === this.KEYS.DOWN ||
+            key === this.KEYS.ENTER) {
+            this.handleSelectContainerKeydown(event);
+        }
+    }
+    /** View. **/
+    focus() {
+        this.hasFocus = true;
+        if (this.multiple && this.filterEnabled) {
+            this.filterInput.nativeElement.focus();
+        }
+        else {
+            this.selectionSpan.nativeElement.focus();
+        }
+    }
+    blur() {
+        this.hasFocus = false;
+        this.selectionSpan.nativeElement.blur();
+    }
+    updateWidth() {
+        this.width = this.selectionSpan.nativeElement.offsetWidth;
+    }
+    updatePosition() {
+        const e = this.selectionSpan.nativeElement;
+        this.left = e.offsetLeft;
+        this.top = e.offsetTop + e.offsetHeight;
+    }
+    updateFilterWidth() {
+        if (typeof this.filterInput !== 'undefined') {
+            const value = this.filterInput.nativeElement.value;
+            this.filterInputWidth =
+                value.length === 0
+                    ? 1 + this.placeholderView.length * 10
+                    : 1 + value.length * 10;
+        }
+    }
+}
+SelectComponent.decorators = [
+    { type: Component, args: [{
+                selector: 'ng-select',
+                template: `<div
+  #selection
+  [attr.tabindex]="disabled ? null : 0"
+  [ngClass]="{
+    open: isOpen,
+    focus: hasFocus,
+    below: isBelow,
+    disabled: disabled
+  }"
+  (click)="onSelectContainerClick($event)"
+  (focus)="onSelectContainerFocus()"
+  (keydown)="onSelectContainerKeydown($event)"
+  (window:click)="onWindowClick()"
+  (window:resize)="onWindowResize()"
+>
+  <div class="single" *ngIf="!multiple">
+    <div class="value" *ngIf="optionList.hasSelected()">
+      {{ optionList.selection[0].label }}
+    </div>
+    <div class="placeholder" *ngIf="!optionList.hasSelected()">
+      {{ placeholderView }}
+    </div>
+    <div
+      class="clear"
+      *ngIf="allowClear"
+      (click)="onClearSelectionClick($event)"
+    >
+      &#x2715;
+    </div>
+    <div class="toggle" *ngIf="isOpen">&#x25B2;</div>
+    <div class="toggle" *ngIf="!isOpen">&#x25BC;</div>
+  </div>
+
+  <div class="multiple" *ngIf="multiple">
+    <div class="option" *ngFor="let option of optionList.selection">
+      <span class="deselect-option" (click)="onDeselectOptionClick(option)">
+        &#x2715;
+      </span>
+      {{ option.label }}
+    </div>
+    <input
+      *ngIf="filterEnabled"
+      #filterInput
+      tabindex="-1"
+      [placeholder]="placeholderView"
+      [ngStyle]="{ 'width.px': filterInputWidth }"
+      (input)="onMultipleFilterInput($event)"
+      (keydown)="onMultipleFilterKeydown($event)"
+    />
+  </div>
+</div>
+<select-dropdown
+  *ngIf="isOpen"
+  #dropdown
+  [multiple]="multiple"
+  [optionList]="optionList"
+  [notFoundMsg]="notFoundMsg"
+  [highlightColor]="highlightColor"
+  [highlightTextColor]="highlightTextColor"
+  [filterEnabled]="filterEnabled"
+  [width]="width"
+  [top]="top"
+  [left]="left"
+  (close)="onDropdownClose($event)"
+  (optionClicked)="onDropdownOptionClicked($event)"
+  (singleFilterClick)="onSingleFilterClick()"
+  (singleFilterInput)="onSingleFilterInput($event)"
+  (singleFilterKeydown)="onSingleFilterKeydown($event)"
+>
+</select-dropdown>
+`,
+                styles: [STYLE],
+                providers: [SELECT_VALUE_ACCESSOR],
+                encapsulation: ViewEncapsulation.None
+            },] },
 ];
-Select.propDecorators = {
-    display: [{ type: Input }],
-    label: [{ type: Input }],
-    helperText: [{ type: Input }],
-    invalidText: [{ type: Input }],
-    warn: [{ type: Input }],
-    warnText: [{ type: Input }],
-    id: [{ type: Input }],
-    size: [{ type: Input }],
+SelectComponent.propDecorators = {
+    options: [{ type: Input }],
+    allowClear: [{ type: Input }],
     disabled: [{ type: Input }],
-    skeleton: [{ type: Input }],
-    invalid: [{ type: Input }],
-    theme: [{ type: Input }],
-    ariaLabel: [{ type: Input }],
-    valueChange: [{ type: Output }],
-    select: [{ type: ViewChild, args: ["select", { static: false },] }],
-    value: [{ type: Input }],
-    focusOut: [{ type: HostListener, args: ["focusout",] }]
+    highlightColor: [{ type: Input }],
+    highlightTextColor: [{ type: Input }],
+    multiple: [{ type: Input }],
+    noFilter: [{ type: Input }],
+    notFoundMsg: [{ type: Input }],
+    placeholder: [{ type: Input }],
+    opened: [{ type: Output }],
+    closed: [{ type: Output }],
+    selected: [{ type: Output }],
+    deselected: [{ type: Output }],
+    typed: [{ type: Output }],
+    selectionSpan: [{ type: ViewChild, args: ['selection',] }],
+    dropdown: [{ type: ViewChild, args: ['dropdown',] }],
+    filterInput: [{ type: ViewChild, args: ['filterInput',] }]
 };
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"select.component.js","sourceRoot":"","sources":["../../../../../projects/ngx-formentry/src/components/select/select.component.ts"],"names":[],"mappings":"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","sourcesContent":["/* tslint:disable:component-class-suffix  */\nimport {\n    AfterViewInit,\n    Component,\n    ElementRef,\n    Input,\n    Output,\n    HostListener,\n    EventEmitter,\n    TemplateRef,\n    ViewChild\n} from \"@angular/core\";\nimport { ControlValueAccessor, NG_VALUE_ACCESSOR } from \"@angular/forms\";\n\n/**\n * `ibm-select` provides a styled `select` component.\n *\n * [See demo](../../?path=/story/select--basic)\n *\n * Example:\n *\n * ```\n * <ibm-select [(ngModel)]=\"model\">\n *     <option value=\"default\" disabled selected hidden>Choose an option</option>\n *     <option value=\"option1\">Option 1</option>\n *    <option value=\"option2\">Option 2</option>\n *     <option value=\"option3\">Option 3</option>\n * </ibm-select>\n *    ```\n *\n * <example-url>../../iframe.html?id=select--basic</example-url>\n */\n@Component({\n    selector: \"ibm-select\",\n    template: `\n        <div class=\"bx--form-item\">\n            <ng-template [ngIf]=\"skeleton\">\n                <div *ngIf=\"label\" class=\"bx--label bx--skeleton\"></div>\n                <div class=\"bx--select bx--skeleton\"></div>\n            </ng-template>\n            <div\n                *ngIf=\"!skeleton\"\n                class=\"bx--select\"\n                [ngClass]=\"{\n                    'bx--select--inline': display === 'inline',\n                    'bx--select--light': theme === 'light',\n                    'bx--select--invalid': invalid,\n                    'bx--select--warning': warn,\n                    'bx--select--disabled': disabled\n                }\">\n                <label *ngIf=\"label\" [for]=\"id\" class=\"bx--label\">\n                    <ng-container *ngIf=\"!isTemplate(label)\">{{label}}</ng-container>\n                    <ng-template *ngIf=\"isTemplate(label)\" [ngTemplateOutlet]=\"label\"></ng-template>\n                </label>\n                <div *ngIf=\"helperText\" class=\"bx--form__helper-text\">\n                    <ng-container *ngIf=\"!isTemplate(helperText)\">{{helperText}}</ng-container>\n                    <ng-template *ngIf=\"isTemplate(helperText)\" [ngTemplateOutlet]=\"helperText\"></ng-template>\n                </div>\n                <div *ngIf=\"display === 'inline'; else noInline\" class=\"bx--select-input--inline__wrapper\">\n                    <ng-container *ngTemplateOutlet=\"noInline\"></ng-container>\n                </div>\n            </div>\n        </div>\n\n        <!-- select element: dynamically projected based on 'display' variant -->\n        <ng-template #noInline>\n            <div class=\"bx--select-input__wrapper\" [attr.data-invalid]=\"(invalid ? true : null)\">\n                <select\n                    #select\n                    [attr.id]=\"id\"\n                    [attr.aria-label]=\"ariaLabel\"\n                    [disabled]=\"disabled\"\n                    (change)=\"onChange($event)\"\n                    [attr.aria-invalid]=\"invalid ? 'true' : null\"\n                    class=\"bx--select-input\"\n                    [ngClass]=\"{\n                        'bx--select-input--xl': size === 'xl',\n                        'bx--select-input--sm': size === 'sm'\n                    }\">\n                    <ng-content></ng-content>\n                </select>\n                <svg\n                    focusable=\"false\"\n                    preserveAspectRatio=\"xMidYMid meet\"\n                    style=\"will-change: transform;\"\n                    xmlns=\"http://www.w3.org/2000/svg\"\n                    class=\"bx--select__arrow\"\n                    width=\"16\"\n                    height=\"16\"\n                    viewBox=\"0 0 16 16\"\n                    aria-hidden=\"true\">\n                    <path d=\"M8 11L3 6 3.7 5.3 8 9.6 12.3 5.3 13 6z\"></path>\n                </svg>\n                <svg *ngIf=\"invalid\"focusable=\"false\" preserveAspectRatio=\"xMidYMid meet\" style=\"will-change: transform;\" xmlns=\"http://www.w3.org/2000/svg\" class=\"bx--text-input__invalid-icon\" width=\"16\" height=\"16\" viewBox=\"0 0 16 16\" aria-hidden=\"true\"><path d=\"M8,1C4.2,1,1,4.2,1,8s3.2,7,7,7s7-3.1,7-7S11.9,1,8,1z M7.5,4h1v5h-1C7.5,9,7.5,4,7.5,4z M8,12.2    c-0.4,0-0.8-0.4-0.8-0.8s0.3-0.8,0.8-0.8c0.4,0,0.8,0.4,0.8,0.8S8.4,12.2,8,12.2z\"></path><path d=\"M7.5,4h1v5h-1C7.5,9,7.5,4,7.5,4z M8,12.2c-0.4,0-0.8-0.4-0.8-0.8s0.3-0.8,0.8-0.8    c0.4,0,0.8,0.4,0.8,0.8S8.4,12.2,8,12.2z\" data-icon-path=\"inner-path\" opacity=\"0\"></path></svg>\n            </div>\n            <div *ngIf=\"invalid && invalidText && !warn\" role=\"alert\" class=\"bx--form-requirement\" aria-live=\"polite\">\n                <ng-container *ngIf=\"!isTemplate(invalidText)\">{{invalidText}}</ng-container>\n                <ng-template *ngIf=\"isTemplate(invalidText)\" [ngTemplateOutlet]=\"invalidText\"></ng-template>\n            </div>\n            <div *ngIf=\"!invalid && warn\" class=\"bx--form-requirement\">\n                <ng-container *ngIf=\"!isTemplate(warnText)\">{{warnText}}</ng-container>\n                <ng-template *ngIf=\"isTemplate(warnText)\" [ngTemplateOutlet]=\"warnText\"></ng-template>\n            </div>\n        </ng-template>\n    `,\n    styles: [`\n        .bx--select--inline .bx--form__helper-text {\n            order: 4;\n        }\n\n        .bx--select--inline:not(.bx--select--invalid) .bx--form__helper-text {\n            margin-top: 0;\n        }\n    `],\n    providers: [\n        {\n            provide: NG_VALUE_ACCESSOR,\n            useExisting: Select,\n            multi: true\n        }\n    ]\n})\nexport class Select implements ControlValueAccessor, AfterViewInit {\n    /**\n     * Tracks the total number of selects instantiated. Used to generate unique IDs\n     */\n    static selectCount = 0;\n\n    /**\n     * `inline` or `default` select displays\n     */\n    @Input() display: \"inline\" | \"default\" = \"default\";\n    /**\n     * Label for the select. Appears above the input.\n     */\n    @Input() label: string | TemplateRef<any>;\n    /**\n     * Optional helper text that appears under the label.\n     */\n    @Input() helperText: string | TemplateRef<any>;\n    /**\n     * Sets the invalid text.\n     */\n    @Input() invalidText: string | TemplateRef<any>;\n    /**\n      * Set to `true` to show a warning (contents set by warningText)\n      */\n    @Input() warn = false;\n    /**\n     * Sets the warning text\n     */\n    @Input() warnText: string | TemplateRef<any>;\n    /**\n     * Sets the unique ID. Defaults to `select-${total count of selects instantiated}`\n     */\n    @Input() id = `select-${Select.selectCount++}`;\n    /**\n     * Number input field render size\n     */\n    @Input() size: \"sm\" | \"md\" | \"xl\" = \"md\";\n    /**\n     * Set to true to disable component.\n     */\n    @Input() disabled = false;\n    /**\n     * Set to true for a loading select.\n     */\n    @Input() skeleton = false;\n    /**\n     * Set to `true` for an invalid select component.\n     */\n    @Input() invalid = false;\n\n    /**\n     * `light` or `dark` select theme\n     */\n    @Input() theme: \"light\" | \"dark\" = \"dark\";\n    @Input() ariaLabel: string;\n\n    @Output() valueChange = new EventEmitter();\n\n    // @ts-ignore\n    @ViewChild(\"select\", { static: false }) select: ElementRef;\n\n    @Input() set value(v) {\n        this._value = v;\n        if (this.select) {\n            this.select.nativeElement.value = this._value;\n        }\n    }\n\n    get value() {\n        return this._value;\n    }\n\n    protected _value;\n\n    ngAfterViewInit() {\n        if (\n            this.value !== undefined &&\n            this.value !== null &&\n            this.select &&\n            this.select.nativeElement.value !== this.value\n        ) {\n            this.select.nativeElement.value = this.value;\n        }\n    }\n\n    /**\n     * Receives a value from the model.\n     */\n    writeValue(obj: any) {\n        this.value = obj;\n    }\n\n    /**\n     * Registers a listener that notifies the model when the control updates\n     */\n    registerOnChange(fn: any) {\n        this.onChangeHandler = fn;\n    }\n\n    /**\n     * Registers a listener that notifies the model when the control is blurred\n     */\n    registerOnTouched(fn: any) {\n        this.onTouchedHandler = fn;\n    }\n\n    /**\n     * Sets the disabled state through the model\n     */\n    setDisabledState(isDisabled: boolean) {\n        this.disabled = isDisabled;\n    }\n\n    /**\n     * Handles the change event from the `select`.\n     * Sends events to the change handler and emits a `selected` event.\n     */\n    onChange(event) {\n        this.value = event.target.value;\n        this.onChangeHandler(event.target.value);\n        this.valueChange.emit(event.target.value);\n    }\n\n    /**\n     * Listens for the host blurring, and notifies the model\n     */\n    @HostListener(\"focusout\")\n    focusOut() {\n        this.onTouchedHandler();\n    }\n\n    public isTemplate(value) {\n        return value instanceof TemplateRef;\n    }\n\n    /**\n     * placeholder declarations. Replaced by the functions provided to `registerOnChange` and `registerOnTouched`\n     */\n    protected onChangeHandler = (_: any) => { };\n    protected onTouchedHandler = () => { };\n}\n"]}
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"select.component.js","sourceRoot":"ng://@ampath-kenya/ngx-openmrs-formentry/","sources":["components/select/select.component.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  AfterViewInit,\n  Component,\n  Input,\n  OnChanges,\n  OnInit,\n  Output,\n  EventEmitter,\n  ExistingProvider,\n  ViewChild,\n  ViewEncapsulation,\n  forwardRef\n} from '@angular/core';\nimport { NG_VALUE_ACCESSOR, ControlValueAccessor } from '@angular/forms';\nimport { STYLE } from './select.component.style';\nimport { SelectDropdownComponent } from './select-dropdown.component';\nimport { Option } from './option';\nimport { OptionList } from './option-list';\n\nexport const SELECT_VALUE_ACCESSOR: ExistingProvider = {\n  provide: NG_VALUE_ACCESSOR,\n  // tslint:disable:no-use-before-declare\n  useExisting: forwardRef(() => SelectComponent),\n  multi: true\n};\n\n@Component({\n  selector: 'ng-select',\n  template: `<div\n  #selection\n  [attr.tabindex]=\"disabled ? null : 0\"\n  [ngClass]=\"{\n    open: isOpen,\n    focus: hasFocus,\n    below: isBelow,\n    disabled: disabled\n  }\"\n  (click)=\"onSelectContainerClick($event)\"\n  (focus)=\"onSelectContainerFocus()\"\n  (keydown)=\"onSelectContainerKeydown($event)\"\n  (window:click)=\"onWindowClick()\"\n  (window:resize)=\"onWindowResize()\"\n>\n  <div class=\"single\" *ngIf=\"!multiple\">\n    <div class=\"value\" *ngIf=\"optionList.hasSelected()\">\n      {{ optionList.selection[0].label }}\n    </div>\n    <div class=\"placeholder\" *ngIf=\"!optionList.hasSelected()\">\n      {{ placeholderView }}\n    </div>\n    <div\n      class=\"clear\"\n      *ngIf=\"allowClear\"\n      (click)=\"onClearSelectionClick($event)\"\n    >\n      &#x2715;\n    </div>\n    <div class=\"toggle\" *ngIf=\"isOpen\">&#x25B2;</div>\n    <div class=\"toggle\" *ngIf=\"!isOpen\">&#x25BC;</div>\n  </div>\n\n  <div class=\"multiple\" *ngIf=\"multiple\">\n    <div class=\"option\" *ngFor=\"let option of optionList.selection\">\n      <span class=\"deselect-option\" (click)=\"onDeselectOptionClick(option)\">\n        &#x2715;\n      </span>\n      {{ option.label }}\n    </div>\n    <input\n      *ngIf=\"filterEnabled\"\n      #filterInput\n      tabindex=\"-1\"\n      [placeholder]=\"placeholderView\"\n      [ngStyle]=\"{ 'width.px': filterInputWidth }\"\n      (input)=\"onMultipleFilterInput($event)\"\n      (keydown)=\"onMultipleFilterKeydown($event)\"\n    />\n  </div>\n</div>\n<select-dropdown\n  *ngIf=\"isOpen\"\n  #dropdown\n  [multiple]=\"multiple\"\n  [optionList]=\"optionList\"\n  [notFoundMsg]=\"notFoundMsg\"\n  [highlightColor]=\"highlightColor\"\n  [highlightTextColor]=\"highlightTextColor\"\n  [filterEnabled]=\"filterEnabled\"\n  [width]=\"width\"\n  [top]=\"top\"\n  [left]=\"left\"\n  (close)=\"onDropdownClose($event)\"\n  (optionClicked)=\"onDropdownOptionClicked($event)\"\n  (singleFilterClick)=\"onSingleFilterClick()\"\n  (singleFilterInput)=\"onSingleFilterInput($event)\"\n  (singleFilterKeydown)=\"onSingleFilterKeydown($event)\"\n>\n</select-dropdown>\n`,\n  styles: [STYLE],\n  providers: [SELECT_VALUE_ACCESSOR],\n  encapsulation: ViewEncapsulation.None\n})\nexport class SelectComponent\n  implements AfterViewInit, ControlValueAccessor, OnChanges, OnInit {\n  /** Keys. **/\n\n  private KEYS: any = {\n    BACKSPACE: 8,\n    TAB: 9,\n    ENTER: 13,\n    ESC: 27,\n    SPACE: 32,\n    UP: 38,\n    DOWN: 40\n  };\n\n  @Input() options: Array<any>;\n\n  @Input() allowClear = false;\n  @Input() disabled = false;\n  @Input() highlightColor = '#2196f3';\n  @Input() highlightTextColor = '#fff';\n  @Input() multiple = false;\n  @Input() noFilter = 0;\n  @Input() notFoundMsg = 'No results found';\n  @Input() placeholder = '';\n\n  @Output() opened: EventEmitter<null> = new EventEmitter<null>();\n  @Output() closed: EventEmitter<null> = new EventEmitter<null>();\n  @Output() selected: EventEmitter<any> = new EventEmitter<any>();\n  @Output() deselected: EventEmitter<any> = new EventEmitter<any>();\n  @Output() typed: EventEmitter<any> = new EventEmitter<any>();\n\n  @ViewChild('selection') selectionSpan: any;\n  @ViewChild('dropdown') dropdown: SelectDropdownComponent;\n  @ViewChild('filterInput') filterInput: any;\n\n  private _value: Array<any> = [];\n  optionList: OptionList;\n\n  // Selection state variables.\n  hasSelected = false;\n\n  // View state variables.\n  filterEnabled = true;\n  filterInputWidth = 1;\n  hasFocus = false;\n  isBelow = true;\n  isDisabled = false;\n  isOpen = false;\n  placeholderView = '';\n\n  clearClicked = false;\n  selectContainerClicked = false;\n\n  // Width and position for the dropdown container.\n  width: number;\n  top: number;\n  left: number;\n\n  private onChange = (_: any) => {};\n  private onTouched = () => {};\n\n  /** Event handlers. **/\n\n  // Angular lifecycle hooks.\n\n  ngOnInit() {\n    this.placeholderView = this.placeholder;\n  }\n\n  ngAfterViewInit() {\n    this.updateFilterWidth();\n  }\n\n  ngOnChanges(changes: any) {\n    if (changes.hasOwnProperty('options')) {\n      this.updateOptionsList(changes['options'].isFirstChange());\n    }\n    if (changes.hasOwnProperty('noFilter')) {\n      const numOptions: number = this.optionList.options.length;\n      const minNumOptions: number = changes['noFilter'].currentValue;\n      this.filterEnabled = numOptions >= minNumOptions;\n    }\n  }\n\n  // Window.\n\n  onWindowClick() {\n    if (!this.selectContainerClicked) {\n      this.closeDropdown();\n    }\n    this.clearClicked = false;\n    this.selectContainerClicked = false;\n  }\n\n  onWindowResize() {\n    this.updateWidth();\n  }\n\n  // Select container.\n\n  onSelectContainerClick(event: any) {\n    this.selectContainerClicked = true;\n    if (!this.clearClicked) {\n      this.toggleDropdown();\n    }\n  }\n\n  onSelectContainerFocus() {\n    this.onTouched();\n  }\n\n  onSelectContainerKeydown(event: any) {\n    this.handleSelectContainerKeydown(event);\n  }\n\n  // Dropdown container.\n\n  onDropdownOptionClicked(option: Option) {\n    this.multiple ? this.toggleSelectOption(option) : this.selectOption(option);\n  }\n\n  onDropdownClose(focus: any) {\n    this.closeDropdown(focus);\n  }\n\n  // Single filter input.\n\n  onSingleFilterClick() {\n    this.selectContainerClicked = true;\n  }\n\n  onSingleFilterInput(term: string) {\n    setTimeout(() => {\n      if (term.length > 2) {\n        this.typed.emit(term);\n      }\n    }, 500);\n    this.optionList.filter(term);\n  }\n\n  onSingleFilterKeydown(event: any) {\n    this.handleSingleFilterKeydown(event);\n  }\n\n  // Multiple filter input.\n\n  onMultipleFilterInput(event: any) {\n    if (!this.isOpen) {\n      this.openDropdown();\n    }\n    this.updateFilterWidth();\n    setTimeout(() => {\n      this.optionList.filter(event.target.value);\n    });\n  }\n\n  onMultipleFilterKeydown(event: any) {\n    this.handleMultipleFilterKeydown(event);\n  }\n\n  // Single clear select.\n\n  onClearSelectionClick(event: any) {\n    this.clearClicked = true;\n    this.clearSelection();\n    this.closeDropdown(true);\n  }\n\n  // Multiple deselect option.\n\n  onDeselectOptionClick(option: Option) {\n    this.clearClicked = true;\n    this.deselectOption(option);\n  }\n\n  /** API. **/\n\n  // TODO fix issues with global click/key handler that closes the dropdown.\n  open() {\n    this.openDropdown();\n  }\n\n  close() {\n    this.closeDropdown();\n  }\n\n  clear() {\n    this.clearSelection();\n  }\n\n  select(value: string) {\n    this.optionList.getOptionsByValue(value).forEach((option) => {\n      this.selectOption(option);\n    });\n    this.valueChanged();\n  }\n\n  /** ControlValueAccessor interface methods. **/\n\n  writeValue(value: any) {\n    this.value = value;\n  }\n\n  registerOnChange(fn: (_: any) => void) {\n    this.onChange = fn;\n  }\n\n  registerOnTouched(fn: () => void) {\n    this.onTouched = fn;\n  }\n\n  setDisabledState(isDisabled: boolean) {\n    this.disabled = isDisabled;\n  }\n\n  /** Value. **/\n\n  get value(): any {\n    if (this._value.length === 0) {\n      return '';\n    } else {\n      return this.multiple ? this._value : this._value[0];\n    }\n  }\n\n  set value(v: any) {\n    if (typeof v === 'undefined' || v === null || v === '') {\n      v = [];\n    } else if (typeof v === 'string') {\n      v = [v];\n    } else if (!Array.isArray(v)) {\n      throw new TypeError('Value must be a string or an array.');\n    }\n\n    if (!OptionList.equalValues(v, this._value)) {\n      this.optionList.value = v;\n      this.valueChanged();\n    }\n  }\n\n  private valueChanged() {\n    this._value = this.optionList.value;\n\n    this.hasSelected = this._value.length > 0;\n    this.placeholderView = this.hasSelected ? '' : this.placeholder;\n    this.updateFilterWidth();\n\n    this.onChange(this.value);\n  }\n\n  /** Initialization. **/\n\n  private updateOptionsList(firstTime: boolean) {\n    let v: Array<string>;\n\n    if (!firstTime) {\n      v = this.optionList.value;\n    }\n\n    this.optionList = new OptionList(this.options);\n\n    if (!firstTime) {\n      this.optionList.value = v;\n      this.valueChanged();\n    }\n  }\n\n  /** Dropdown. **/\n\n  private toggleDropdown() {\n    if (!this.isDisabled) {\n      this.isOpen ? this.closeDropdown(true) : this.openDropdown();\n    }\n  }\n\n  private openDropdown() {\n    if (!this.isOpen) {\n      this.updateWidth();\n      this.updatePosition();\n      this.isOpen = true;\n      if (this.multiple && this.filterEnabled) {\n        this.filterInput.nativeElement.focus();\n      }\n      this.opened.emit(null);\n    }\n  }\n  /* tslint:disable */\n  private closeDropdown(focus: boolean = false) {\n    if (this.isOpen) {\n      this.clearFilterInput();\n      this.isOpen = false;\n      if (focus) {\n        this.focus();\n      }\n      this.closed.emit(null);\n    }\n  }\n  /* tslint:enable */\n  /** Select. **/\n\n  private selectOption(option: Option) {\n    if (!option.selected) {\n      this.optionList.select(option, this.multiple);\n      this.valueChanged();\n      this.selected.emit(option.undecoratedCopy());\n      // Is this not allready done when setting the value??\n      /*setTimeout(() => {\n                if (this.multiple) {\n                    this.updateFilterWidth();\n                }\n            });*/\n    }\n  }\n\n  private deselectOption(option: Option) {\n    if (option.selected) {\n      this.optionList.deselect(option);\n      this.valueChanged();\n      this.deselected.emit(option.undecoratedCopy());\n      setTimeout(() => {\n        if (this.multiple) {\n          // this.updateFilterWidth();\n          this.updatePosition();\n          this.optionList.highlight();\n          if (this.isOpen) {\n            this.dropdown.moveHighlightedIntoView();\n          }\n        }\n      });\n    }\n  }\n\n  private clearSelection() {\n    const selection: Array<Option> = this.optionList.selection;\n    if (selection.length > 0) {\n      this.optionList.clearSelection();\n      this.valueChanged();\n\n      if (selection.length === 1) {\n        this.deselected.emit(selection[0].undecoratedCopy());\n      } else {\n        this.deselected.emit(\n          selection.map((option) => {\n            return option.undecoratedCopy();\n          })\n        );\n      }\n    }\n  }\n\n  private toggleSelectOption(option: Option) {\n    option.selected ? this.deselectOption(option) : this.selectOption(option);\n  }\n\n  private selectHighlightedOption() {\n    const option: Option = this.optionList.highlightedOption;\n    if (option !== null) {\n      this.selectOption(option);\n      this.closeDropdown(true);\n    }\n  }\n\n  private deselectLast() {\n    const sel: Array<Option> = this.optionList.selection;\n\n    if (sel.length > 0) {\n      const option: Option = sel[sel.length - 1];\n      this.deselectOption(option);\n      this.setMultipleFilterInput(option.label + ' ');\n    }\n  }\n\n  /** Filter. **/\n\n  private clearFilterInput() {\n    if (this.multiple && this.filterEnabled) {\n      this.filterInput.nativeElement.value = '';\n    } else {\n      this.dropdown.clearFilterInput();\n    }\n  }\n\n  private setMultipleFilterInput(value: string) {\n    if (this.filterEnabled) {\n      this.filterInput.nativeElement.value = value;\n    }\n  }\n\n  private handleSelectContainerKeydown(event: any) {\n    const key = event.which;\n\n    if (this.isOpen) {\n      if (key === this.KEYS.ESC || (key === this.KEYS.UP && event.altKey)) {\n        this.closeDropdown(true);\n      } else if (key === this.KEYS.TAB) {\n        this.closeDropdown();\n      } else if (key === this.KEYS.ENTER) {\n        this.selectHighlightedOption();\n      } else if (key === this.KEYS.UP) {\n        this.optionList.highlightPreviousOption();\n        this.dropdown.moveHighlightedIntoView();\n        if (!this.filterEnabled) {\n          event.preventDefault();\n        }\n      } else if (key === this.KEYS.DOWN) {\n        this.optionList.highlightNextOption();\n        this.dropdown.moveHighlightedIntoView();\n        if (!this.filterEnabled) {\n          event.preventDefault();\n        }\n      }\n    } else {\n      if (\n        key === this.KEYS.ENTER ||\n        key === this.KEYS.SPACE ||\n        (key === this.KEYS.DOWN && event.altKey)\n      ) {\n        /* FIREFOX HACK:\n         *\n         * The setTimeout is added to prevent the enter keydown event\n         * to be triggered for the filter input field, which causes\n         * the dropdown to be closed again.\n         */\n        setTimeout(() => {\n          this.openDropdown();\n        });\n      }\n    }\n  }\n\n  private handleMultipleFilterKeydown(event: any) {\n    const key = event.which;\n\n    if (key === this.KEYS.BACKSPACE) {\n      if (\n        this.hasSelected &&\n        this.filterEnabled &&\n        this.filterInput.nativeElement.value === ''\n      ) {\n        this.deselectLast();\n      }\n    }\n  }\n\n  private handleSingleFilterKeydown(event: any) {\n    const key = event.which;\n\n    if (\n      key === this.KEYS.ESC ||\n      key === this.KEYS.TAB ||\n      key === this.KEYS.UP ||\n      key === this.KEYS.DOWN ||\n      key === this.KEYS.ENTER\n    ) {\n      this.handleSelectContainerKeydown(event);\n    }\n  }\n\n  /** View. **/\n\n  focus() {\n    this.hasFocus = true;\n    if (this.multiple && this.filterEnabled) {\n      this.filterInput.nativeElement.focus();\n    } else {\n      this.selectionSpan.nativeElement.focus();\n    }\n  }\n\n  blur() {\n    this.hasFocus = false;\n    this.selectionSpan.nativeElement.blur();\n  }\n\n  updateWidth() {\n    this.width = this.selectionSpan.nativeElement.offsetWidth;\n  }\n\n  updatePosition() {\n    const e = this.selectionSpan.nativeElement;\n    this.left = e.offsetLeft;\n    this.top = e.offsetTop + e.offsetHeight;\n  }\n\n  updateFilterWidth() {\n    if (typeof this.filterInput !== 'undefined') {\n      const value: string = this.filterInput.nativeElement.value;\n      this.filterInputWidth =\n        value.length === 0\n          ? 1 + this.placeholderView.length * 10\n          : 1 + value.length * 10;\n    }\n  }\n}\n"]}