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

package/esm5/components/select/select.component.js

@@ -0,0 +1,456 @@
+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 var SELECT_VALUE_ACCESSOR = {
+    provide: NG_VALUE_ACCESSOR,
+    // tslint:disable:no-use-before-declare
+    useExisting: forwardRef(function () { return SelectComponent; }),
+    multi: true
+};
+var SelectComponent = /** @class */ (function () {
+    function SelectComponent() {
+        /** 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 = function (_) { };
+        this.onTouched = function () { };
+    }
+    /** Event handlers. **/
+    // Angular lifecycle hooks.
+    SelectComponent.prototype.ngOnInit = function () {
+        this.placeholderView = this.placeholder;
+    };
+    SelectComponent.prototype.ngAfterViewInit = function () {
+        this.updateFilterWidth();
+    };
+    SelectComponent.prototype.ngOnChanges = function (changes) {
+        if (changes.hasOwnProperty('options')) {
+            this.updateOptionsList(changes['options'].isFirstChange());
+        }
+        if (changes.hasOwnProperty('noFilter')) {
+            var numOptions = this.optionList.options.length;
+            var minNumOptions = changes['noFilter'].currentValue;
+            this.filterEnabled = numOptions >= minNumOptions;
+        }
+    };
+    // Window.
+    SelectComponent.prototype.onWindowClick = function () {
+        if (!this.selectContainerClicked) {
+            this.closeDropdown();
+        }
+        this.clearClicked = false;
+        this.selectContainerClicked = false;
+    };
+    SelectComponent.prototype.onWindowResize = function () {
+        this.updateWidth();
+    };
+    // Select container.
+    SelectComponent.prototype.onSelectContainerClick = function (event) {
+        this.selectContainerClicked = true;
+        if (!this.clearClicked) {
+            this.toggleDropdown();
+        }
+    };
+    SelectComponent.prototype.onSelectContainerFocus = function () {
+        this.onTouched();
+    };
+    SelectComponent.prototype.onSelectContainerKeydown = function (event) {
+        this.handleSelectContainerKeydown(event);
+    };
+    // Dropdown container.
+    SelectComponent.prototype.onDropdownOptionClicked = function (option) {
+        this.multiple ? this.toggleSelectOption(option) : this.selectOption(option);
+    };
+    SelectComponent.prototype.onDropdownClose = function (focus) {
+        this.closeDropdown(focus);
+    };
+    // Single filter input.
+    SelectComponent.prototype.onSingleFilterClick = function () {
+        this.selectContainerClicked = true;
+    };
+    SelectComponent.prototype.onSingleFilterInput = function (term) {
+        var _this = this;
+        setTimeout(function () {
+            if (term.length > 2) {
+                _this.typed.emit(term);
+            }
+        }, 500);
+        this.optionList.filter(term);
+    };
+    SelectComponent.prototype.onSingleFilterKeydown = function (event) {
+        this.handleSingleFilterKeydown(event);
+    };
+    // Multiple filter input.
+    SelectComponent.prototype.onMultipleFilterInput = function (event) {
+        var _this = this;
+        if (!this.isOpen) {
+            this.openDropdown();
+        }
+        this.updateFilterWidth();
+        setTimeout(function () {
+            _this.optionList.filter(event.target.value);
+        });
+    };
+    SelectComponent.prototype.onMultipleFilterKeydown = function (event) {
+        this.handleMultipleFilterKeydown(event);
+    };
+    // Single clear select.
+    SelectComponent.prototype.onClearSelectionClick = function (event) {
+        this.clearClicked = true;
+        this.clearSelection();
+        this.closeDropdown(true);
+    };
+    // Multiple deselect option.
+    SelectComponent.prototype.onDeselectOptionClick = function (option) {
+        this.clearClicked = true;
+        this.deselectOption(option);
+    };
+    /** API. **/
+    // TODO fix issues with global click/key handler that closes the dropdown.
+    SelectComponent.prototype.open = function () {
+        this.openDropdown();
+    };
+    SelectComponent.prototype.close = function () {
+        this.closeDropdown();
+    };
+    SelectComponent.prototype.clear = function () {
+        this.clearSelection();
+    };
+    SelectComponent.prototype.select = function (value) {
+        var _this = this;
+        this.optionList.getOptionsByValue(value).forEach(function (option) {
+            _this.selectOption(option);
+        });
+        this.valueChanged();
+    };
+    /** ControlValueAccessor interface methods. **/
+    SelectComponent.prototype.writeValue = function (value) {
+        this.value = value;
+    };
+    SelectComponent.prototype.registerOnChange = function (fn) {
+        this.onChange = fn;
+    };
+    SelectComponent.prototype.registerOnTouched = function (fn) {
+        this.onTouched = fn;
+    };
+    SelectComponent.prototype.setDisabledState = function (isDisabled) {
+        this.disabled = isDisabled;
+    };
+    Object.defineProperty(SelectComponent.prototype, "value", {
+        /** Value. **/
+        get: function () {
+            if (this._value.length === 0) {
+                return '';
+            }
+            else {
+                return this.multiple ? this._value : this._value[0];
+            }
+        },
+        set: function (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();
+            }
+        },
+        enumerable: true,
+        configurable: true
+    });
+    SelectComponent.prototype.valueChanged = function () {
+        this._value = this.optionList.value;
+        this.hasSelected = this._value.length > 0;
+        this.placeholderView = this.hasSelected ? '' : this.placeholder;
+        this.updateFilterWidth();
+        this.onChange(this.value);
+    };
+    /** Initialization. **/
+    SelectComponent.prototype.updateOptionsList = function (firstTime) {
+        var v;
+        if (!firstTime) {
+            v = this.optionList.value;
+        }
+        this.optionList = new OptionList(this.options);
+        if (!firstTime) {
+            this.optionList.value = v;
+            this.valueChanged();
+        }
+    };
+    /** Dropdown. **/
+    SelectComponent.prototype.toggleDropdown = function () {
+        if (!this.isDisabled) {
+            this.isOpen ? this.closeDropdown(true) : this.openDropdown();
+        }
+    };
+    SelectComponent.prototype.openDropdown = function () {
+        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 */
+    SelectComponent.prototype.closeDropdown = function (focus) {
+        if (focus === void 0) { focus = false; }
+        if (this.isOpen) {
+            this.clearFilterInput();
+            this.isOpen = false;
+            if (focus) {
+                this.focus();
+            }
+            this.closed.emit(null);
+        }
+    };
+    /* tslint:enable */
+    /** Select. **/
+    SelectComponent.prototype.selectOption = function (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();
+                      }
+                  });*/
+        }
+    };
+    SelectComponent.prototype.deselectOption = function (option) {
+        var _this = this;
+        if (option.selected) {
+            this.optionList.deselect(option);
+            this.valueChanged();
+            this.deselected.emit(option.undecoratedCopy());
+            setTimeout(function () {
+                if (_this.multiple) {
+                    // this.updateFilterWidth();
+                    _this.updatePosition();
+                    _this.optionList.highlight();
+                    if (_this.isOpen) {
+                        _this.dropdown.moveHighlightedIntoView();
+                    }
+                }
+            });
+        }
+    };
+    SelectComponent.prototype.clearSelection = function () {
+        var 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(function (option) {
+                    return option.undecoratedCopy();
+                }));
+            }
+        }
+    };
+    SelectComponent.prototype.toggleSelectOption = function (option) {
+        option.selected ? this.deselectOption(option) : this.selectOption(option);
+    };
+    SelectComponent.prototype.selectHighlightedOption = function () {
+        var option = this.optionList.highlightedOption;
+        if (option !== null) {
+            this.selectOption(option);
+            this.closeDropdown(true);
+        }
+    };
+    SelectComponent.prototype.deselectLast = function () {
+        var sel = this.optionList.selection;
+        if (sel.length > 0) {
+            var option = sel[sel.length - 1];
+            this.deselectOption(option);
+            this.setMultipleFilterInput(option.label + ' ');
+        }
+    };
+    /** Filter. **/
+    SelectComponent.prototype.clearFilterInput = function () {
+        if (this.multiple && this.filterEnabled) {
+            this.filterInput.nativeElement.value = '';
+        }
+        else {
+            this.dropdown.clearFilterInput();
+        }
+    };
+    SelectComponent.prototype.setMultipleFilterInput = function (value) {
+        if (this.filterEnabled) {
+            this.filterInput.nativeElement.value = value;
+        }
+    };
+    SelectComponent.prototype.handleSelectContainerKeydown = function (event) {
+        var _this = this;
+        var 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(function () {
+                    _this.openDropdown();
+                });
+            }
+        }
+    };
+    SelectComponent.prototype.handleMultipleFilterKeydown = function (event) {
+        var key = event.which;
+        if (key === this.KEYS.BACKSPACE) {
+            if (this.hasSelected &&
+                this.filterEnabled &&
+                this.filterInput.nativeElement.value === '') {
+                this.deselectLast();
+            }
+        }
+    };
+    SelectComponent.prototype.handleSingleFilterKeydown = function (event) {
+        var 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. **/
+    SelectComponent.prototype.focus = function () {
+        this.hasFocus = true;
+        if (this.multiple && this.filterEnabled) {
+            this.filterInput.nativeElement.focus();
+        }
+        else {
+            this.selectionSpan.nativeElement.focus();
+        }
+    };
+    SelectComponent.prototype.blur = function () {
+        this.hasFocus = false;
+        this.selectionSpan.nativeElement.blur();
+    };
+    SelectComponent.prototype.updateWidth = function () {
+        this.width = this.selectionSpan.nativeElement.offsetWidth;
+    };
+    SelectComponent.prototype.updatePosition = function () {
+        var e = this.selectionSpan.nativeElement;
+        this.left = e.offsetLeft;
+        this.top = e.offsetTop + e.offsetHeight;
+    };
+    SelectComponent.prototype.updateFilterWidth = function () {
+        if (typeof this.filterInput !== 'undefined') {
+            var 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\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",
+                    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',] }]
+    };
+    return SelectComponent;
+}());
+export { SelectComponent };
+//# 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":"AAAA,OAAO,EAEL,SAAS,EACT,KAAK,EAGL,MAAM,EACN,YAAY,EAEZ,SAAS,EACT,iBAAiB,EACjB,UAAU,EACX,MAAM,eAAe,CAAC;AACvB,OAAO,EAAE,iBAAiB,EAAwB,MAAM,gBAAgB,CAAC;AACzE,OAAO,EAAE,KAAK,EAAE,MAAM,0BAA0B,CAAC;AACjD,OAAO,EAAE,uBAAuB,EAAE,MAAM,6BAA6B,CAAC;AAEtE,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAE3C,MAAM,CAAC,IAAM,qBAAqB,GAAqB;IACrD,OAAO,EAAE,iBAAiB;IAC1B,uCAAuC;IACvC,WAAW,EAAE,UAAU,CAAC,cAAM,OAAA,eAAe,EAAf,CAAe,CAAC;IAC9C,KAAK,EAAE,IAAI;CACZ,CAAC;AAEF;IAAA;QA+EE,aAAa;QAEL,SAAI,GAAQ;YAClB,SAAS,EAAE,CAAC;YACZ,GAAG,EAAE,CAAC;YACN,KAAK,EAAE,EAAE;YACT,GAAG,EAAE,EAAE;YACP,KAAK,EAAE,EAAE;YACT,EAAE,EAAE,EAAE;YACN,IAAI,EAAE,EAAE;SACT,CAAC;QAIO,eAAU,GAAG,KAAK,CAAC;QACnB,aAAQ,GAAG,KAAK,CAAC;QACjB,mBAAc,GAAG,SAAS,CAAC;QAC3B,uBAAkB,GAAG,MAAM,CAAC;QAC5B,aAAQ,GAAG,KAAK,CAAC;QACjB,aAAQ,GAAG,CAAC,CAAC;QACb,gBAAW,GAAG,kBAAkB,CAAC;QACjC,gBAAW,GAAG,EAAE,CAAC;QAEhB,WAAM,GAAuB,IAAI,YAAY,EAAQ,CAAC;QACtD,WAAM,GAAuB,IAAI,YAAY,EAAQ,CAAC;QACtD,aAAQ,GAAsB,IAAI,YAAY,EAAO,CAAC;QACtD,eAAU,GAAsB,IAAI,YAAY,EAAO,CAAC;QACxD,UAAK,GAAsB,IAAI,YAAY,EAAO,CAAC;QAMrD,WAAM,GAAe,EAAE,CAAC;QAGhC,6BAA6B;QAC7B,gBAAW,GAAG,KAAK,CAAC;QAEpB,wBAAwB;QACxB,kBAAa,GAAG,IAAI,CAAC;QACrB,qBAAgB,GAAG,CAAC,CAAC;QACrB,aAAQ,GAAG,KAAK,CAAC;QACjB,YAAO,GAAG,IAAI,CAAC;QACf,eAAU,GAAG,KAAK,CAAC;QACnB,WAAM,GAAG,KAAK,CAAC;QACf,oBAAe,GAAG,EAAE,CAAC;QAErB,iBAAY,GAAG,KAAK,CAAC;QACrB,2BAAsB,GAAG,KAAK,CAAC;QAOvB,aAAQ,GAAG,UAAC,CAAM,IAAM,CAAC,CAAC;QAC1B,cAAS,GAAG,cAAO,CAAC,CAAC;IAkb/B,CAAC;IAhbC,uBAAuB;IAEvB,2BAA2B;IAE3B,kCAAQ,GAAR;QACE,IAAI,CAAC,eAAe,GAAG,IAAI,CAAC,WAAW,CAAC;IAC1C,CAAC;IAED,yCAAe,GAAf;QACE,IAAI,CAAC,iBAAiB,EAAE,CAAC;IAC3B,CAAC;IAED,qCAAW,GAAX,UAAY,OAAY;QACtB,EAAE,CAAC,CAAC,OAAO,CAAC,cAAc,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC;YACtC,IAAI,CAAC,iBAAiB,CAAC,OAAO,CAAC,SAAS,CAAC,CAAC,aAAa,EAAE,CAAC,CAAC;QAC7D,CAAC;QACD,EAAE,CAAC,CAAC,OAAO,CAAC,cAAc,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC;YACvC,IAAM,UAAU,GAAW,IAAI,CAAC,UAAU,CAAC,OAAO,CAAC,MAAM,CAAC;YAC1D,IAAM,aAAa,GAAW,OAAO,CAAC,UAAU,CAAC,CAAC,YAAY,CAAC;YAC/D,IAAI,CAAC,aAAa,GAAG,UAAU,IAAI,aAAa,CAAC;QACnD,CAAC;IACH,CAAC;IAED,UAAU;IAEV,uCAAa,GAAb;QACE,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,sBAAsB,CAAC,CAAC,CAAC;YACjC,IAAI,CAAC,aAAa,EAAE,CAAC;QACvB,CAAC;QACD,IAAI,CAAC,YAAY,GAAG,KAAK,CAAC;QAC1B,IAAI,CAAC,sBAAsB,GAAG,KAAK,CAAC;IACtC,CAAC;IAED,wCAAc,GAAd;QACE,IAAI,CAAC,WAAW,EAAE,CAAC;IACrB,CAAC;IAED,oBAAoB;IAEpB,gDAAsB,GAAtB,UAAuB,KAAU;QAC/B,IAAI,CAAC,sBAAsB,GAAG,IAAI,CAAC;QACnC,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,YAAY,CAAC,CAAC,CAAC;YACvB,IAAI,CAAC,cAAc,EAAE,CAAC;QACxB,CAAC;IACH,CAAC;IAED,gDAAsB,GAAtB;QACE,IAAI,CAAC,SAAS,EAAE,CAAC;IACnB,CAAC;IAED,kDAAwB,GAAxB,UAAyB,KAAU;QACjC,IAAI,CAAC,4BAA4B,CAAC,KAAK,CAAC,CAAC;IAC3C,CAAC;IAED,sBAAsB;IAEtB,iDAAuB,GAAvB,UAAwB,MAAc;QACpC,IAAI,CAAC,QAAQ,CAAC,CAAC,CAAC,IAAI,CAAC,kBAAkB,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,YAAY,CAAC,MAAM,CAAC,CAAC;IAC9E,CAAC;IAED,yCAAe,GAAf,UAAgB,KAAU;QACxB,IAAI,CAAC,aAAa,CAAC,KAAK,CAAC,CAAC;IAC5B,CAAC;IAED,uBAAuB;IAEvB,6CAAmB,GAAnB;QACE,IAAI,CAAC,sBAAsB,GAAG,IAAI,CAAC;IACrC,CAAC;IAED,6CAAmB,GAAnB,UAAoB,IAAY;QAAhC,iBAOC;QANC,UAAU,CAAC;YACT,EAAE,CAAC,CAAC,IAAI,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,CAAC;gBACpB,KAAI,CAAC,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;YACxB,CAAC;QACH,CAAC,EAAE,GAAG,CAAC,CAAC;QACR,IAAI,CAAC,UAAU,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC;IAC/B,CAAC;IAED,+CAAqB,GAArB,UAAsB,KAAU;QAC9B,IAAI,CAAC,yBAAyB,CAAC,KAAK,CAAC,CAAC;IACxC,CAAC;IAED,yBAAyB;IAEzB,+CAAqB,GAArB,UAAsB,KAAU;QAAhC,iBAQC;QAPC,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC;YACjB,IAAI,CAAC,YAAY,EAAE,CAAC;QACtB,CAAC;QACD,IAAI,CAAC,iBAAiB,EAAE,CAAC;QACzB,UAAU,CAAC;YACT,KAAI,CAAC,UAAU,CAAC,MAAM,CAAC,KAAK,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;QAC7C,CAAC,CAAC,CAAC;IACL,CAAC;IAED,iDAAuB,GAAvB,UAAwB,KAAU;QAChC,IAAI,CAAC,2BAA2B,CAAC,KAAK,CAAC,CAAC;IAC1C,CAAC;IAED,uBAAuB;IAEvB,+CAAqB,GAArB,UAAsB,KAAU;QAC9B,IAAI,CAAC,YAAY,GAAG,IAAI,CAAC;QACzB,IAAI,CAAC,cAAc,EAAE,CAAC;QACtB,IAAI,CAAC,aAAa,CAAC,IAAI,CAAC,CAAC;IAC3B,CAAC;IAED,4BAA4B;IAE5B,+CAAqB,GAArB,UAAsB,MAAc;QAClC,IAAI,CAAC,YAAY,GAAG,IAAI,CAAC;QACzB,IAAI,CAAC,cAAc,CAAC,MAAM,CAAC,CAAC;IAC9B,CAAC;IAED,YAAY;IAEZ,0EAA0E;IAC1E,8BAAI,GAAJ;QACE,IAAI,CAAC,YAAY,EAAE,CAAC;IACtB,CAAC;IAED,+BAAK,GAAL;QACE,IAAI,CAAC,aAAa,EAAE,CAAC;IACvB,CAAC;IAED,+BAAK,GAAL;QACE,IAAI,CAAC,cAAc,EAAE,CAAC;IACxB,CAAC;IAED,gCAAM,GAAN,UAAO,KAAa;QAApB,iBAKC;QAJC,IAAI,CAAC,UAAU,CAAC,iBAAiB,CAAC,KAAK,CAAC,CAAC,OAAO,CAAC,UAAC,MAAM;YACtD,KAAI,CAAC,YAAY,CAAC,MAAM,CAAC,CAAC;QAC5B,CAAC,CAAC,CAAC;QACH,IAAI,CAAC,YAAY,EAAE,CAAC;IACtB,CAAC;IAED,+CAA+C;IAE/C,oCAAU,GAAV,UAAW,KAAU;QACnB,IAAI,CAAC,KAAK,GAAG,KAAK,CAAC;IACrB,CAAC;IAED,0CAAgB,GAAhB,UAAiB,EAAoB;QACnC,IAAI,CAAC,QAAQ,GAAG,EAAE,CAAC;IACrB,CAAC;IAED,2CAAiB,GAAjB,UAAkB,EAAc;QAC9B,IAAI,CAAC,SAAS,GAAG,EAAE,CAAC;IACtB,CAAC;IAED,0CAAgB,GAAhB,UAAiB,UAAmB;QAClC,IAAI,CAAC,QAAQ,GAAG,UAAU,CAAC;IAC7B,CAAC;IAID,sBAAI,kCAAK;QAFT,cAAc;aAEd;YACE,EAAE,CAAC,CAAC,IAAI,CAAC,MAAM,CAAC,MAAM,KAAK,CAAC,CAAC,CAAC,CAAC;gBAC7B,MAAM,CAAC,EAAE,CAAC;YACZ,CAAC;YAAC,IAAI,CAAC,CAAC;gBACN,MAAM,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC;YACtD,CAAC;QACH,CAAC;aAED,UAAU,CAAM;YACd,EAAE,CAAC,CAAC,OAAO,CAAC,KAAK,WAAW,IAAI,CAAC,KAAK,IAAI,IAAI,CAAC,KAAK,EAAE,CAAC,CAAC,CAAC;gBACvD,CAAC,GAAG,EAAE,CAAC;YACT,CAAC;YAAC,IAAI,CAAC,EAAE,CAAC,CAAC,OAAO,CAAC,KAAK,QAAQ,CAAC,CAAC,CAAC;gBACjC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;YACV,CAAC;YAAC,IAAI,CAAC,EAAE,CAAC,CAAC,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;gBAC7B,MAAM,IAAI,SAAS,CAAC,qCAAqC,CAAC,CAAC;YAC7D,CAAC;YAED,EAAE,CAAC,CAAC,CAAC,UAAU,CAAC,WAAW,CAAC,CAAC,EAAE,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC;gBAC5C,IAAI,CAAC,UAAU,CAAC,KAAK,GAAG,CAAC,CAAC;gBAC1B,IAAI,CAAC,YAAY,EAAE,CAAC;YACtB,CAAC;QACH,CAAC;;;OAfA;IAiBO,sCAAY,GAApB;QACE,IAAI,CAAC,MAAM,GAAG,IAAI,CAAC,UAAU,CAAC,KAAK,CAAC;QAEpC,IAAI,CAAC,WAAW,GAAG,IAAI,CAAC,MAAM,CAAC,MAAM,GAAG,CAAC,CAAC;QAC1C,IAAI,CAAC,eAAe,GAAG,IAAI,CAAC,WAAW,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,WAAW,CAAC;QAChE,IAAI,CAAC,iBAAiB,EAAE,CAAC;QAEzB,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;IAC5B,CAAC;IAED,uBAAuB;IAEf,2CAAiB,GAAzB,UAA0B,SAAkB;QAC1C,IAAI,CAAgB,CAAC;QAErB,EAAE,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC;YACf,CAAC,GAAG,IAAI,CAAC,UAAU,CAAC,KAAK,CAAC;QAC5B,CAAC;QAED,IAAI,CAAC,UAAU,GAAG,IAAI,UAAU,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;QAE/C,EAAE,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC;YACf,IAAI,CAAC,UAAU,CAAC,KAAK,GAAG,CAAC,CAAC;YAC1B,IAAI,CAAC,YAAY,EAAE,CAAC;QACtB,CAAC;IACH,CAAC;IAED,iBAAiB;IAET,wCAAc,GAAtB;QACE,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC,CAAC;YACrB,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC,IAAI,CAAC,aAAa,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,YAAY,EAAE,CAAC;QAC/D,CAAC;IACH,CAAC;IAEO,sCAAY,GAApB;QACE,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC;YACjB,IAAI,CAAC,WAAW,EAAE,CAAC;YACnB,IAAI,CAAC,cAAc,EAAE,CAAC;YACtB,IAAI,CAAC,MAAM,GAAG,IAAI,CAAC;YACnB,EAAE,CAAC,CAAC,IAAI,CAAC,QAAQ,IAAI,IAAI,CAAC,aAAa,CAAC,CAAC,CAAC;gBACxC,IAAI,CAAC,WAAW,CAAC,aAAa,CAAC,KAAK,EAAE,CAAC;YACzC,CAAC;YACD,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QACzB,CAAC;IACH,CAAC;IACD,oBAAoB;IACZ,uCAAa,GAArB,UAAsB,KAAsB;QAAtB,sBAAA,EAAA,aAAsB;QAC1C,EAAE,CAAC,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC;YAChB,IAAI,CAAC,gBAAgB,EAAE,CAAC;YACxB,IAAI,CAAC,MAAM,GAAG,KAAK,CAAC;YACpB,EAAE,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC;gBACV,IAAI,CAAC,KAAK,EAAE,CAAC;YACf,CAAC;YACD,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QACzB,CAAC;IACH,CAAC;IACD,mBAAmB;IACnB,eAAe;IAEP,sCAAY,GAApB,UAAqB,MAAc;QACjC,EAAE,CAAC,CAAC,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC,CAAC;YACrB,IAAI,CAAC,UAAU,CAAC,MAAM,CAAC,MAAM,EAAE,IAAI,CAAC,QAAQ,CAAC,CAAC;YAC9C,IAAI,CAAC,YAAY,EAAE,CAAC;YACpB,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,MAAM,CAAC,eAAe,EAAE,CAAC,CAAC;YAC7C,qDAAqD;YACrD;;;;uBAIW;QACb,CAAC;IACH,CAAC;IAEO,wCAAc,GAAtB,UAAuB,MAAc;QAArC,iBAgBC;QAfC,EAAE,CAAC,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC,CAAC;YACpB,IAAI,CAAC,UAAU,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAC;YACjC,IAAI,CAAC,YAAY,EAAE,CAAC;YACpB,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,MAAM,CAAC,eAAe,EAAE,CAAC,CAAC;YAC/C,UAAU,CAAC;gBACT,EAAE,CAAC,CAAC,KAAI,CAAC,QAAQ,CAAC,CAAC,CAAC;oBAClB,4BAA4B;oBAC5B,KAAI,CAAC,cAAc,EAAE,CAAC;oBACtB,KAAI,CAAC,UAAU,CAAC,SAAS,EAAE,CAAC;oBAC5B,EAAE,CAAC,CAAC,KAAI,CAAC,MAAM,CAAC,CAAC,CAAC;wBAChB,KAAI,CAAC,QAAQ,CAAC,uBAAuB,EAAE,CAAC;oBAC1C,CAAC;gBACH,CAAC;YACH,CAAC,CAAC,CAAC;QACL,CAAC;IACH,CAAC;IAEO,wCAAc,GAAtB;QACE,IAAM,SAAS,GAAkB,IAAI,CAAC,UAAU,CAAC,SAAS,CAAC;QAC3D,EAAE,CAAC,CAAC,SAAS,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,CAAC;YACzB,IAAI,CAAC,UAAU,CAAC,cAAc,EAAE,CAAC;YACjC,IAAI,CAAC,YAAY,EAAE,CAAC;YAEpB,EAAE,CAAC,CAAC,SAAS,CAAC,MAAM,KAAK,CAAC,CAAC,CAAC,CAAC;gBAC3B,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,eAAe,EAAE,CAAC,CAAC;YACvD,CAAC;YAAC,IAAI,CAAC,CAAC;gBACN,IAAI,CAAC,UAAU,CAAC,IAAI,CAClB,SAAS,CAAC,GAAG,CAAC,UAAC,MAAM;oBACnB,MAAM,CAAC,MAAM,CAAC,eAAe,EAAE,CAAC;gBAClC,CAAC,CAAC,CACH,CAAC;YACJ,CAAC;QACH,CAAC;IACH,CAAC;IAEO,4CAAkB,GAA1B,UAA2B,MAAc;QACvC,MAAM,CAAC,QAAQ,CAAC,CAAC,CAAC,IAAI,CAAC,cAAc,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,YAAY,CAAC,MAAM,CAAC,CAAC;IAC5E,CAAC;IAEO,iDAAuB,GAA/B;QACE,IAAM,MAAM,GAAW,IAAI,CAAC,UAAU,CAAC,iBAAiB,CAAC;QACzD,EAAE,CAAC,CAAC,MAAM,KAAK,IAAI,CAAC,CAAC,CAAC;YACpB,IAAI,CAAC,YAAY,CAAC,MAAM,CAAC,CAAC;YAC1B,IAAI,CAAC,aAAa,CAAC,IAAI,CAAC,CAAC;QAC3B,CAAC;IACH,CAAC;IAEO,sCAAY,GAApB;QACE,IAAM,GAAG,GAAkB,IAAI,CAAC,UAAU,CAAC,SAAS,CAAC;QAErD,EAAE,CAAC,CAAC,GAAG,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,CAAC;YACnB,IAAM,MAAM,GAAW,GAAG,CAAC,GAAG,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC;YAC3C,IAAI,CAAC,cAAc,CAAC,MAAM,CAAC,CAAC;YAC5B,IAAI,CAAC,sBAAsB,CAAC,MAAM,CAAC,KAAK,GAAG,GAAG,CAAC,CAAC;QAClD,CAAC;IACH,CAAC;IAED,eAAe;IAEP,0CAAgB,GAAxB;QACE,EAAE,CAAC,CAAC,IAAI,CAAC,QAAQ,IAAI,IAAI,CAAC,aAAa,CAAC,CAAC,CAAC;YACxC,IAAI,CAAC,WAAW,CAAC,aAAa,CAAC,KAAK,GAAG,EAAE,CAAC;QAC5C,CAAC;QAAC,IAAI,CAAC,CAAC;YACN,IAAI,CAAC,QAAQ,CAAC,gBAAgB,EAAE,CAAC;QACnC,CAAC;IACH,CAAC;IAEO,gDAAsB,GAA9B,UAA+B,KAAa;QAC1C,EAAE,CAAC,CAAC,IAAI,CAAC,aAAa,CAAC,CAAC,CAAC;YACvB,IAAI,CAAC,WAAW,CAAC,aAAa,CAAC,KAAK,GAAG,KAAK,CAAC;QAC/C,CAAC;IACH,CAAC;IAEO,sDAA4B,GAApC,UAAqC,KAAU;QAA/C,iBAwCC;QAvCC,IAAM,GAAG,GAAG,KAAK,CAAC,KAAK,CAAC;QAExB,EAAE,CAAC,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC;YAChB,EAAE,CAAC,CAAC,GAAG,KAAK,IAAI,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC,GAAG,KAAK,IAAI,CAAC,IAAI,CAAC,EAAE,IAAI,KAAK,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC;gBACpE,IAAI,CAAC,aAAa,CAAC,IAAI,CAAC,CAAC;YAC3B,CAAC;YAAC,IAAI,CAAC,EAAE,CAAC,CAAC,GAAG,KAAK,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC;gBACjC,IAAI,CAAC,aAAa,EAAE,CAAC;YACvB,CAAC;YAAC,IAAI,CAAC,EAAE,CAAC,CAAC,GAAG,KAAK,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC;gBACnC,IAAI,CAAC,uBAAuB,EAAE,CAAC;YACjC,CAAC;YAAC,IAAI,CAAC,EAAE,CAAC,CAAC,GAAG,KAAK,IAAI,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC,CAAC;gBAChC,IAAI,CAAC,UAAU,CAAC,uBAAuB,EAAE,CAAC;gBAC1C,IAAI,CAAC,QAAQ,CAAC,uBAAuB,EAAE,CAAC;gBACxC,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,aAAa,CAAC,CAAC,CAAC;oBACxB,KAAK,CAAC,cAAc,EAAE,CAAC;gBACzB,CAAC;YACH,CAAC;YAAC,IAAI,CAAC,EAAE,CAAC,CAAC,GAAG,KAAK,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC;gBAClC,IAAI,CAAC,UAAU,CAAC,mBAAmB,EAAE,CAAC;gBACtC,IAAI,CAAC,QAAQ,CAAC,uBAAuB,EAAE,CAAC;gBACxC,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,aAAa,CAAC,CAAC,CAAC;oBACxB,KAAK,CAAC,cAAc,EAAE,CAAC;gBACzB,CAAC;YACH,CAAC;QACH,CAAC;QAAC,IAAI,CAAC,CAAC;YACN,EAAE,CAAC,CACD,GAAG,KAAK,IAAI,CAAC,IAAI,CAAC,KAAK;gBACvB,GAAG,KAAK,IAAI,CAAC,IAAI,CAAC,KAAK;gBACvB,CAAC,GAAG,KAAK,IAAI,CAAC,IAAI,CAAC,IAAI,IAAI,KAAK,CAAC,MAAM,CACzC,CAAC,CAAC,CAAC;gBACD;;;;;mBAKG;gBACH,UAAU,CAAC;oBACT,KAAI,CAAC,YAAY,EAAE,CAAC;gBACtB,CAAC,CAAC,CAAC;YACL,CAAC;QACH,CAAC;IACH,CAAC;IAEO,qDAA2B,GAAnC,UAAoC,KAAU;QAC5C,IAAM,GAAG,GAAG,KAAK,CAAC,KAAK,CAAC;QAExB,EAAE,CAAC,CAAC,GAAG,KAAK,IAAI,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC,CAAC;YAChC,EAAE,CAAC,CACD,IAAI,CAAC,WAAW;gBAChB,IAAI,CAAC,aAAa;gBAClB,IAAI,CAAC,WAAW,CAAC,aAAa,CAAC,KAAK,KAAK,EAC3C,CAAC,CAAC,CAAC;gBACD,IAAI,CAAC,YAAY,EAAE,CAAC;YACtB,CAAC;QACH,CAAC;IACH,CAAC;IAEO,mDAAyB,GAAjC,UAAkC,KAAU;QAC1C,IAAM,GAAG,GAAG,KAAK,CAAC,KAAK,CAAC;QAExB,EAAE,CAAC,CACD,GAAG,KAAK,IAAI,CAAC,IAAI,CAAC,GAAG;YACrB,GAAG,KAAK,IAAI,CAAC,IAAI,CAAC,GAAG;YACrB,GAAG,KAAK,IAAI,CAAC,IAAI,CAAC,EAAE;YACpB,GAAG,KAAK,IAAI,CAAC,IAAI,CAAC,IAAI;YACtB,GAAG,KAAK,IAAI,CAAC,IAAI,CAAC,KACpB,CAAC,CAAC,CAAC;YACD,IAAI,CAAC,4BAA4B,CAAC,KAAK,CAAC,CAAC;QAC3C,CAAC;IACH,CAAC;IAED,aAAa;IAEb,+BAAK,GAAL;QACE,IAAI,CAAC,QAAQ,GAAG,IAAI,CAAC;QACrB,EAAE,CAAC,CAAC,IAAI,CAAC,QAAQ,IAAI,IAAI,CAAC,aAAa,CAAC,CAAC,CAAC;YACxC,IAAI,CAAC,WAAW,CAAC,aAAa,CAAC,KAAK,EAAE,CAAC;QACzC,CAAC;QAAC,IAAI,CAAC,CAAC;YACN,IAAI,CAAC,aAAa,CAAC,aAAa,CAAC,KAAK,EAAE,CAAC;QAC3C,CAAC;IACH,CAAC;IAED,8BAAI,GAAJ;QACE,IAAI,CAAC,QAAQ,GAAG,KAAK,CAAC;QACtB,IAAI,CAAC,aAAa,CAAC,aAAa,CAAC,IAAI,EAAE,CAAC;IAC1C,CAAC;IAED,qCAAW,GAAX;QACE,IAAI,CAAC,KAAK,GAAG,IAAI,CAAC,aAAa,CAAC,aAAa,CAAC,WAAW,CAAC;IAC5D,CAAC;IAED,wCAAc,GAAd;QACE,IAAM,CAAC,GAAG,IAAI,CAAC,aAAa,CAAC,aAAa,CAAC;QAC3C,IAAI,CAAC,IAAI,GAAG,CAAC,CAAC,UAAU,CAAC;QACzB,IAAI,CAAC,GAAG,GAAG,CAAC,CAAC,SAAS,GAAG,CAAC,CAAC,YAAY,CAAC;IAC1C,CAAC;IAED,2CAAiB,GAAjB;QACE,EAAE,CAAC,CAAC,OAAO,IAAI,CAAC,WAAW,KAAK,WAAW,CAAC,CAAC,CAAC;YAC5C,IAAM,KAAK,GAAW,IAAI,CAAC,WAAW,CAAC,aAAa,CAAC,KAAK,CAAC;YAC3D,IAAI,CAAC,gBAAgB;gBACnB,KAAK,CAAC,MAAM,KAAK,CAAC;oBAChB,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC,eAAe,CAAC,MAAM,GAAG,EAAE;oBACtC,CAAC,CAAC,CAAC,GAAG,KAAK,CAAC,MAAM,GAAG,EAAE,CAAC;QAC9B,CAAC;IACH,CAAC;;gBAzjBF,SAAS,SAAC;oBACT,QAAQ,EAAE,WAAW;oBACrB,QAAQ,EAAE,8kEAsEX;oBACC,MAAM,EAAE,CAAC,KAAK,CAAC;oBACf,SAAS,EAAE,CAAC,qBAAqB,CAAC;oBAClC,aAAa,EAAE,iBAAiB,CAAC,IAAI;iBACtC;;;0BAeE,KAAK;6BAEL,KAAK;2BACL,KAAK;iCACL,KAAK;qCACL,KAAK;2BACL,KAAK;2BACL,KAAK;8BACL,KAAK;8BACL,KAAK;yBAEL,MAAM;yBACN,MAAM;2BACN,MAAM;6BACN,MAAM;wBACN,MAAM;gCAEN,SAAS,SAAC,WAAW;2BACrB,SAAS,SAAC,UAAU;8BACpB,SAAS,SAAC,aAAa;;IA4c1B,sBAAC;CAAA,AA1jBD,IA0jBC;SA7eY,eAAe","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"]}

package/esm5/components/select/select.component.style.js

@@ -0,0 +1,2 @@
+export var STYLE = "\nng-select {\n  display: inline-block;\n  margin: 0;\n  position: relative;\n  vertical-align: middle;\n  width: 100%;\n}\nng-select * {\n  box-sizing: border-box;\n  font-family: Sans-Serif;\n}\nng-select > div {\n  border: 1px solid #ddd;\n  box-sizing: border-box;\n  cursor: pointer;\n  user-select: none;\n  width: 100%;\n}\nng-select > div.disabled {\n  background-color: #eee;\n  color: #aaa;\n  cursor: default;\n  pointer-events: none;\n}\nng-select > div > div.single {\n  display: flex;\n  height: 30px;\n  width: 100%;\n}\nng-select > div > div.single > div.value,\nng-select > div > div.single > div.placeholder {\n  flex: 1;\n  line-height: 30px;\n  overflow: hidden;\n  padding: 0 10px;\n  white-space: nowrap;\n}\nng-select > div > div.single > div.placeholder {\n  color: #a9a9a9;\n}\nng-select > div > div.single > div.clear,\nng-select > div > div.single > div.toggle {\n  color: #aaa;\n  line-height: 30px;\n  text-align: center;\n  width: 30px;\n}\nng-select > div > div.single > div.clear:hover,\nng-select > div > div.single > div.toggle:hover {\n  background-color: #ececec;\n}\nng-select > div > div.single > div.clear {\n  font-size: 18px;\n}\nng-select > div > div.single > div.toggle {\n  font-size: 14px;\n}\nng-select > div > div.multiple {\n  display: flex;\n  flex-flow: row wrap;\n  height: 100%;\n  min-height: 30px;\n  padding: 0 10px;\n  width: 100%;\n}\nng-select > div > div.multiple > div.option {\n  background-color: #eee;\n  border: 1px solid #aaa;\n  border-radius: 4px;\n  color: #333;\n  cursor: default;\n  display: inline-block;\n  flex-shrink: 0;\n  font-size: 14px;\n  line-height: 22px;\n  margin: 3px 5px 3px 0;\n  padding: 0 4px;\n}\nng-select > div > div.multiple > div.option span.deselect-option {\n  color: #aaa;\n  cursor: pointer;\n  font-size: 14px;\n  height: 20px;\n  line-height: 20px;\n}\nng-select > div > div.multiple > div.option span.deselect-option:hover {\n  color: #555;\n}\nng-select > div > div.multiple input {\n  background-color: transparent;\n  border: none;\n  height: 30px;\n  line-height: 30px;\n  padding: 0;\n}\nng-select > div > div.multiple input:focus {\n  outline: none;\n}\n";
+//# sourceMappingURL=data:application/json;base64,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

package/esm5/components/select/select.module.js

@@ -0,0 +1,19 @@
+import { NgModule } from '@angular/core';
+import { CommonModule } from '@angular/common';
+import { FormsModule } from '@angular/forms';
+import { SelectComponent } from './select.component';
+import { SelectDropdownComponent } from './select-dropdown.component';
+var SelectModule = /** @class */ (function () {
+    function SelectModule() {
+    }
+    SelectModule.decorators = [
+        { type: NgModule, args: [{
+                    declarations: [SelectComponent, SelectDropdownComponent],
+                    exports: [SelectComponent],
+                    imports: [CommonModule, FormsModule]
+                },] },
+    ];
+    return SelectModule;
+}());
+export { SelectModule };
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2VsZWN0Lm1vZHVsZS5qcyIsInNvdXJjZVJvb3QiOiJuZzovL0BhbXBhdGgta2VueWEvbmd4LW9wZW5tcnMtZm9ybWVudHJ5LyIsInNvdXJjZXMiOlsiY29tcG9uZW50cy9zZWxlY3Qvc2VsZWN0Lm1vZHVsZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsUUFBUSxFQUFFLE1BQU0sZUFBZSxDQUFDO0FBQ3pDLE9BQU8sRUFBRSxZQUFZLEVBQUUsTUFBTSxpQkFBaUIsQ0FBQztBQUMvQyxPQUFPLEVBQUUsV0FBVyxFQUFFLE1BQU0sZ0JBQWdCLENBQUM7QUFFN0MsT0FBTyxFQUFFLGVBQWUsRUFBRSxNQUFNLG9CQUFvQixDQUFDO0FBQ3JELE9BQU8sRUFBRSx1QkFBdUIsRUFBRSxNQUFNLDZCQUE2QixDQUFDO0FBRXRFO0lBQUE7SUFLMkIsQ0FBQzs7Z0JBTDNCLFFBQVEsU0FBQztvQkFDUixZQUFZLEVBQUUsQ0FBQyxlQUFlLEVBQUUsdUJBQXVCLENBQUM7b0JBQ3hELE9BQU8sRUFBRSxDQUFDLGVBQWUsQ0FBQztvQkFDMUIsT0FBTyxFQUFFLENBQUMsWUFBWSxFQUFFLFdBQVcsQ0FBQztpQkFDckM7O0lBQzBCLG1CQUFDO0NBQUEsQUFMNUIsSUFLNEI7U0FBZixZQUFZIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgTmdNb2R1bGUgfSBmcm9tICdAYW5ndWxhci9jb3JlJztcbmltcG9ydCB7IENvbW1vbk1vZHVsZSB9IGZyb20gJ0Bhbmd1bGFyL2NvbW1vbic7XG5pbXBvcnQgeyBGb3Jtc01vZHVsZSB9IGZyb20gJ0Bhbmd1bGFyL2Zvcm1zJztcblxuaW1wb3J0IHsgU2VsZWN0Q29tcG9uZW50IH0gZnJvbSAnLi9zZWxlY3QuY29tcG9uZW50JztcbmltcG9ydCB7IFNlbGVjdERyb3Bkb3duQ29tcG9uZW50IH0gZnJvbSAnLi9zZWxlY3QtZHJvcGRvd24uY29tcG9uZW50JztcblxuQE5nTW9kdWxlKHtcbiAgZGVjbGFyYXRpb25zOiBbU2VsZWN0Q29tcG9uZW50LCBTZWxlY3REcm9wZG93bkNvbXBvbmVudF0sXG4gIGV4cG9ydHM6IFtTZWxlY3RDb21wb25lbnRdLFxuICBpbXBvcnRzOiBbQ29tbW9uTW9kdWxlLCBGb3Jtc01vZHVsZV1cbn0pXG5leHBvcnQgY2xhc3MgU2VsZWN0TW9kdWxlIHt9XG4iXX0=