@ampath-kenya/ngx-openmrs-formentry 2.12.11 → 2.12.13

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

@@ -0,0 +1,514 @@
+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() {
+        /** Keys. **/
+        this.KEYS = {
+            BACKSPACE: 8,
+            TAB: 9,
+            ENTER: 13,
+            ESC: 27,
+            SPACE: 32,
+            UP: 38,
+            DOWN: 40
+        };
+        this.allowClear = false;
+        this.disabled = false;
+        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 = () => { };
+    }
+    /** 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;
+        }
+    }
+    // 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;
+    }
+    registerOnChange(fn) {
+        this.onChange = fn;
+    }
+    registerOnTouched(fn) {
+        this.onTouched = fn;
+    }
+    setDisabledState(isDisabled) {
+        this.disabled = isDisabled;
+    }
+    /** Value. **/
+    get value() {
+        if (this._value.length === 0) {
+            return '';
+        }
+        else {
+            return this.multiple ? this._value : this._value[0];
+        }
+    }
+    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();
+        }
+    }
+    valueChanged() {
+        this._value = this.optionList.value;
+        this.hasSelected = this._value.length > 0;
+        this.placeholderView = this.hasSelected ? '' : this.placeholder;
+        this.updateFilterWidth();
+        this.onChange(this.value);
+    }
+    /** 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();
+                    }
+                }
+            });
+        }
+    }
+    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
+            },] },
+];
+SelectComponent.propDecorators = {
+    options: [{ type: Input }],
+    allowClear: [{ type: Input }],
+    disabled: [{ type: Input }],
+    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":"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"]}