@bmat/angular/fesm2015/bmat-angular-forms.js

import { CommonModule } from '@angular/common';
import { Component, ChangeDetectionStrategy, ViewEncapsulation, forwardRef, Renderer2, ViewChildren, ElementRef, Input, ChangeDetectorRef, ViewChild, HostBinding, EventEmitter, Output, Directive, ContentChildren, NgModule } from '@angular/core';
import { NG_VALUE_ACCESSOR } from '@angular/forms';
import { trigger, state, style, transition, animate } from '@angular/animations';

/**
 * @fileoverview added by tsickle
 * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
 */
class BMDurationInputComponent {
    /**
     * @param {?} renderer
     */
    constructor(renderer) {
        this.renderer = renderer;
        // tslint:disable-next-line:prefer-array-literal
        this.timeValues = new Array(3).fill(null);
        // tslint:disable:no-any
        // tslint:disable:no-empty
        this.propagateChange = (/**
         * @param {?} _
         * @return {?}
         */
        (_) => { });
    }
    /**
     * @param {?} val
     * @return {?}
     */
    set value(val) {
        this.writeValue(val);
    }
    /**
     * @return {?}
     */
    get value() {
        return this.computeTotalTime();
    }
    /**
     * @param {?} index
     * @param {?} $event
     * @return {?}
     */
    format(index, $event) {
        /** @type {?} */
        const inputEle = (/** @type {?} */ ($event.target));
        /** @type {?} */
        let value = Number.parseInt(inputEle.value, 10);
        if (Number.isNaN(value)) {
            value = 0;
        }
        if (index && value >= 60) {
            value = (value % 100) % 60;
        }
        this.timeValues[index] = value;
        this.propagateChange(this.computeTotalTime());
        /** @type {?} */
        const formatedVal = this.timeValues[index] < 10
            ? '0' + this.timeValues[index]
            : this.timeValues[index];
        this.renderer.setProperty(inputEle, 'value', formatedVal);
    }
    // tslint:disable-next-line:no-any
    /**
     * @param {?} value
     * @return {?}
     */
    writeValue(value) {
        if (!value && value !== 0) {
            // tslint:disable-next-line:prefer-array-literal
            this.timeValues = new Array(3).fill(null);
        }
        else {
            /** @type {?} */
            let coerceInteger = Number.parseInt(value, 10);
            if (Number.isNaN(coerceInteger)) {
                coerceInteger = 0;
            }
            coerceInteger = Math.max(0, coerceInteger);
            [
                Math.floor(coerceInteger / 3600),
                Math.floor(coerceInteger / 60) % 60,
                coerceInteger % 60,
            ].forEach((/**
             * @param {?} val
             * @param {?} i
             * @return {?}
             */
            (val, i) => {
                this.timeValues[i] = val;
            }));
        }
        this.updateInputValues();
    }
    // tslint:disable-next-line:no-any
    /**
     * @param {?} fn
     * @return {?}
     */
    registerOnChange(fn) {
        this.propagateChange = fn;
    }
    // tslint:disable-next-line:no-empty
    /**
     * @return {?}
     */
    registerOnTouched() { }
    /**
     * @return {?}
     */
    ngAfterViewInit() {
        this.updateInputValues();
    }
    /**
     * @private
     * @return {?}
     */
    computeTotalTime() {
        return this.timeValues.reduce((/**
         * @param {?} acum
         * @param {?} curr
         * @param {?} i
         * @return {?}
         */
        (acum, curr, i) => {
            if (curr) {
                acum += ((/** @type {?} */ (curr))) * Math.pow(60, (2 - i));
            }
            return acum;
        }), 0);
    }
    /**
     * @private
     * @return {?}
     */
    updateInputValues() {
        if (this.viewTimeValues) {
            this.viewTimeValues.forEach((/**
             * @param {?} element
             * @param {?} index
             * @return {?}
             */
            (element, index) => {
                /** @type {?} */
                const value = this.timeValues[index];
                /** @type {?} */
                const formatedValue = value < 10 ? '0' + value : value;
                this.renderer.setProperty(element.nativeElement, 'value', formatedValue);
            }));
        }
    }
}
BMDurationInputComponent.decorators = [
    { type: Component, args: [{
                selector: 'bm-input-duration',
                template: "<input #hours type=\"number\" min=\"0\" class=\"bm-input bm-duration-input__input\"\n  (input)=\"format(0, $event)\" (keyup)=\"format(0, $event)\" placeholder=\"HH\" />\n<input #minutes type=\"number\" min=\"0\" max=\"59\"  class=\"bm-input bm-duration-input__input\"\n  (input)=\"format(1, $event)\" (keyup)=\"format(1, $event)\" placeholder=\"MM\"/>\n<input #seconds type=\"number\" min=\"0\" max=\"59\"  class=\"bm-input bm-duration-input__input\"\n  (input)=\"format(2, $event)\" (keyup)=\"format(2, $event)\" placeholder=\"SS\"/>",
                changeDetection: ChangeDetectionStrategy.OnPush,
                encapsulation: ViewEncapsulation.None,
                providers: [
                    {
                        provide: NG_VALUE_ACCESSOR,
                        // tslint:disable-next-line:no-forward-ref
                        useExisting: forwardRef((/**
                         * @return {?}
                         */
                        () => BMDurationInputComponent)),
                        multi: true,
                    },
                ],
                styles: ["bm-input-duration{display:inline-flex;flex-wrap:nowrap}.bm-duration-input--inverse .bm-duration-input__input{background-color:#fff}.bm-duration-input__input{width:3em}"]
            }] }
];
/** @nocollapse */
BMDurationInputComponent.ctorParameters = () => [
    { type: Renderer2 }
];
BMDurationInputComponent.propDecorators = {
    viewTimeValues: [{ type: ViewChildren, args: ['hours, minutes, seconds', { read: ElementRef },] }],
    value: [{ type: Input }]
};

/**
 * @fileoverview added by tsickle
 * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
 */
class BMMultiselectComponent {
    /**
     * @param {?} changeDetectorRef
     */
    constructor(changeDetectorRef) {
        this.changeDetectorRef = changeDetectorRef;
        /**
         * Input values to directly copy to inner input
         */
        this.name = '';
        this.tabIndex = 0;
        this.options = [];
        this.availableOptions = [];
        this.filteredOptions = [];
        this.selectedOptionsList = [];
        this.selectedOptions = new Set();
        this.showSuggestions = false;
        // tslint:disable-next-line:no-any no-empty
        this.onTouched = (/**
         * @return {?}
         */
        () => { });
        // tslint:disable:no-any
        // tslint:disable:no-empty
        this.propagateChange = (/**
         * @param {?} _
         * @return {?}
         */
        (_) => { });
    }
    /**
     * @return {?}
     */
    get isFocused() {
        return this.focused;
    }
    /**
     * @param {?} v
     * @return {?}
     */
    set value(v) {
        if (Array.isArray(v)) {
            this.selectedOptions = new Set(v);
        }
        this.updateListAndSuggestions();
        this.updateSelectedList();
    }
    /**
     * @return {?}
     */
    get value() {
        return Array.from(this.selectedOptions.values());
    }
    /**
     * @param {?} option
     * @param {?} event
     * @return {?}
     */
    selectOption(option, event) {
        /** @type {?} */
        const target = (/** @type {?} */ (event.target));
        if (target.nextElementSibling) {
            ((/** @type {?} */ (target.nextElementSibling))).focus();
        }
        else if (target.previousElementSibling) {
            ((/** @type {?} */ (target.previousElementSibling))).focus();
        }
        this.selectedOptions.add(option.key);
        this.valueChange();
    }
    /**
     * @param {?} option
     * @return {?}
     */
    removeOption(option) {
        this.selectedOptions.delete(option.key);
        this.valueChange();
    }
    /**
     * @return {?}
     */
    removeAll() {
        this.selectedOptions.clear();
        this.valueChange();
    }
    /**
     * @return {?}
     */
    addAll() {
        this.selectedOptions = new Set(this.options.map((/**
         * @param {?} item
         * @return {?}
         */
        item => item.key)));
        this.valueChange();
        this.showSuggestions = false;
    }
    /**
     * @param {?} event
     * @return {?}
     */
    inputKeyUp(event) {
        switch (event.keyCode) {
            case 40: // Down arrow
                this.showSuggestions = true;
                if (this.suggestionList.first &&
                    this.suggestionList.first.nativeElement) {
                    this.suggestionList.first.nativeElement.focus();
                }
                break;
            case 27: // Escape
                this.showSuggestions = false;
                break;
            default:
                this.updateSuggestionList();
        }
    }
    /**
     * @param {?} event
     * @param {?} index
     * @param {?} value
     * @return {?}
     */
    suggestionKeyUp(event, index, value) {
        /** @type {?} */
        const suggestionLi = this.suggestionList.toArray();
        /** @type {?} */
        const keyDown = (/**
         * @return {?}
         */
        () => {
            if (index === 0 &&
                this.suggestionList.last &&
                this.suggestionList.last.nativeElement) {
                this.suggestionList.last.nativeElement.focus();
            }
            else if (suggestionLi[index - 1] &&
                suggestionLi[index - 1].nativeElement) {
                suggestionLi[index - 1].nativeElement.focus();
            }
        });
        switch (event.keyCode) {
            case 40: // Up arrow
                if (index === this.filteredOptions.length - 1 &&
                    this.suggestionList.first &&
                    this.suggestionList.first.nativeElement) {
                    this.suggestionList.first.nativeElement.focus();
                }
                else if (suggestionLi[index + 1] &&
                    suggestionLi[index + 1].nativeElement) {
                    suggestionLi[index + 1].nativeElement.focus();
                }
                event.preventDefault();
                break;
            case 38: // Down arrow
                keyDown();
                event.preventDefault();
                break;
            case 27: // Escape
                this.showSuggestions = false;
                break;
            case 13: // Enter
                this.selectOption(value, event);
                keyDown();
                break;
            default:
                return;
        }
    }
    /**
     * @param {?} event
     * @param {?} value
     * @return {?}
     */
    selectedItemKeyup(event, value) {
        if (event.keyCode === 46 || event.keyCode === 8) {
            event.preventDefault();
            this.removeOption(value);
        }
    }
    /**
     * @return {?}
     */
    afterOptionFocus() {
        this.showSuggestions = false;
    }
    // Focus Blur Handle
    /**
     * @return {?}
     */
    inputFocus() {
        this.focused = true;
        this.showSuggestions = true;
    }
    /**
     * @param {?} event
     * @return {?}
     */
    inputFocusout(event) {
        /** @type {?} */
        const relatedTarget = (/** @type {?} */ (event.relatedTarget));
        /** @type {?} */
        const suggestions = this.suggestionList.map((/**
         * @param {?} item
         * @return {?}
         */
        item => item.nativeElement));
        if (suggestions.indexOf(relatedTarget) === -1) {
            this.showSuggestions = false;
        }
        this.focused = false;
        this.onTouched();
    }
    /**
     * @param {?} event
     * @return {?}
     */
    suggestionFocusout(event) {
        /** @type {?} */
        const target = (/** @type {?} */ (event.target));
        /** @type {?} */
        const relatedTarget = (/** @type {?} */ (event.relatedTarget));
        if (!relatedTarget ||
            target.parentElement !== relatedTarget.parentElement) {
            this.showSuggestions = false;
        }
    }
    /**
     * @return {?}
     */
    ngAfterViewInit() {
        this.updateListAndSuggestions();
    }
    // tslint:disable-next-line:no-any
    /**
     * @param {?} value
     * @return {?}
     */
    writeValue(value) {
        this.value = value;
        this.changeDetectorRef.markForCheck();
    }
    // tslint:disable-next-line:no-any
    /**
     * @param {?} fn
     * @return {?}
     */
    registerOnChange(fn) {
        this.propagateChange = fn;
    }
    // tslint:disable-next-line:no-any
    /**
     * @param {?} fn
     * @return {?}
     */
    registerOnTouched(fn) {
        this.onTouched = fn;
    }
    /**
     * @return {?}
     */
    focus() {
        if (this.input && this.input.nativeElement) {
            this.input.nativeElement.focus();
        }
    }
    /**
     * @private
     * @return {?}
     */
    updateSelectedList() {
        this.selectedOptionsList = this.options.filter((/**
         * @param {?} option
         * @return {?}
         */
        option => this.selectedOptions.has(option.key)));
    }
    /**
     * @private
     * @return {?}
     */
    updateListAndSuggestions() {
        this.availableOptions = this.options.filter((/**
         * @param {?} option
         * @return {?}
         */
        option => !this.selectedOptions.has(option.key)));
        this.updateSuggestionList();
    }
    /**
     * @private
     * @return {?}
     */
    updateSuggestionList() {
        /** @type {?} */
        const value = ((/** @type {?} */ ((this.input.nativeElement)))).value.toLowerCase();
        this.filteredOptions = this.availableOptions.filter((/**
         * @param {?} item
         * @return {?}
         */
        item => item.displayValue.toLowerCase().search(value) !== -1));
    }
    /**
     * @private
     * @return {?}
     */
    valueChange() {
        this.propagateChange(Array.from(this.selectedOptions.values()));
        this.updateListAndSuggestions();
        this.updateSelectedList();
        if (this.availableOptions.length === 0 &&
            this.input &&
            this.input.nativeElement) {
            this.input.nativeElement.focus();
        }
    }
}
BMMultiselectComponent.decorators = [
    { type: Component, args: [{
                selector: 'bm-multiselect',
                template: "<div class=\"bm-multiselect-input-container\">\n  <input\n    class=\"bm-multiselect-input bm-input\"\n    #input\n    autocomplete=\"off\"\n    [required]=\"required\"\n    [disabled]=\"disabled\"\n    [name]=\"name\"\n    [tabIndex]=\"tabIndex\"\n    [readonly]=\"readonly\"\n    [attr.aria-label]=\"ariaLabel\"\n    [attr.aria-labelledby]=\"ariaLabelledby\"\n    (keyup)=\"inputKeyUp($event)\"\n    (focus)=\"inputFocus()\"\n    (focusout)=\"inputFocusout($event)\"\n  />\n  <div\n    *ngIf=\"showSuggestions\"\n    tabindex=\"-1\"\n    class=\"bm-multiselect-suggestions-container\"\n    [@fadeInOut]=\"'in'\"\n  >\n    <ul>\n      <li i18n tabindex=\"-1\" *ngIf=\"filteredOptions.length === 0\">\n        No matches found\n      </li>\n      <li\n        #sugg\n        tabindex=\"0\"\n        *ngFor=\"let option of filteredOptions; let i = index\"\n        aria-selected=\"true\"\n        (click)=\"selectOption(option, $event)\"\n        (focusout)=\"suggestionFocusout($event)\"\n        (keydown)=\"suggestionKeyUp($event, i, option)\"\n      >\n        {{ option.displayValue }}\n      </li>\n    </ul>\n  </div>\n  <button\n    class=\"bm-multiselect-add-all\"\n    i18n\n    (click)=\"addAll()\"\n    (focus)=\"afterOptionFocus()\"\n  >\n    Add all\n  </button>\n</div>\n<div *ngIf=\"value.length\" class=\"bm-multiselect-selected-options\">\n  <div class=\"bm-multiselect-button-container\">\n    <button class=\"bm-multiselect-remove-all\" i18n (click)=\"removeAll()\">\n      Remove all\n    </button>\n  </div>\n  <ul>\n    <li\n      *ngFor=\"let option of selectedOptionsList\"\n      tabindex=\"0\"\n      aria-selected=\"false\"\n      (keyup)=\"selectedItemKeyup($event, option)\"\n    >\n      <span>{{ option.displayValue }}</span>\n      <button\n        bmIconButton\n        class=\"bm-multiselect-remove-item fas fa-trash\"\n        arial-label=\"Remove this item\"\n        (click)=\"removeOption(option)\"\n        i18n-arial-label\n      ></button>\n    </li>\n  </ul>\n</div>\n",
                changeDetection: ChangeDetectionStrategy.OnPush,
                encapsulation: ViewEncapsulation.None,
                providers: [
                    {
                        provide: NG_VALUE_ACCESSOR,
                        // tslint:disable-next-line:no-forward-ref
                        useExisting: forwardRef((/**
                         * @return {?}
                         */
                        () => BMMultiselectComponent)),
                        multi: true,
                    },
                ],
                animations: [
                    trigger('fadeInOut', [
                        state('in', style({ opacity: 1 })),
                        transition('void => *', [
                            style({
                                opacity: 0,
                            }),
                            animate('0.2s ease-in'),
                        ]),
                        transition('* => void', [
                            animate('0.2s ease-out', style({
                                opacity: 0,
                            })),
                        ]),
                    ]),
                ],
                styles: ["bm-multiselect{display:inline-block}.bm-multiselect-input-container{display:block;position:relative}.bm-multiselect-input{width:100%;box-sizing:border-box}.bm-multiselect-add-all,.bm-multiselect-remove-all,.bm-multiselect-remove-item{background:0 0;color:#4399fd;border:none}.bm-multiselect-add-all{position:absolute;right:0;top:.5em}.bm-multiselect-suggestions-container{position:absolute;top:1.8em;width:100%;background:#fff;max-height:10em;box-shadow:0 0 4px 0 rgba(0,0,0,.09);overflow-x:auto;z-index:1000}.bm-multiselect-suggestions-container ul{list-style:none;padding:0;margin:0}.bm-multiselect-suggestions-container li{padding:.2em 1em;cursor:pointer}.bm-multiselect-suggestions-container li:nth-child(odd){background-color:#fff}.bm-multiselect-suggestions-container li:nth-child(even){background-color:var(--secondary-color,#bcbcbc)}.bm-multiselect-suggestions-container li:focus,.bm-multiselect-suggestions-container li:hover{background-color:var(--secondary-color-hover,#959494)}.bm-multiselect-selected-options{text-align:left}.bm-multiselect-selected-options .bm-multiselect-button-container{text-align:right;padding:1em 0}.bm-multiselect-selected-options .bm-multiselect-remove-item{display:none}.bm-multiselect-selected-options ul{margin:0;padding:0;max-height:15em;overflow-x:auto;list-style-type:none}.bm-multiselect-selected-options li{padding:.5em;display:flex}.bm-multiselect-selected-options li:nth-child(odd){background-color:#f5f7f8}.bm-multiselect-selected-options li:focus{background-color:var(--secondary-color-hover,#959494)}.bm-multiselect-selected-options li:hover .bm-multiselect-remove-item{display:block;margin-right:0;margin-left:auto}"]
            }] }
];
/** @nocollapse */
BMMultiselectComponent.ctorParameters = () => [
    { type: ChangeDetectorRef }
];
BMMultiselectComponent.propDecorators = {
    input: [{ type: ViewChild, args: ['input', { static: true },] }],
    suggestionList: [{ type: ViewChildren, args: ['sugg',] }],
    isFocused: [{ type: HostBinding, args: ['class.bm-multiselect-focused',] }],
    name: [{ type: Input }],
    tabIndex: [{ type: Input }],
    required: [{ type: Input }],
    disabled: [{ type: Input }],
    readonly: [{ type: Input }],
    ariaLabel: [{ type: Input, args: ['aria-label',] }],
    ariaLabelledby: [{ type: Input, args: ['aria-labelledby',] }],
    value: [{ type: Input }],
    options: [{ type: Input }]
};

/**
 * @fileoverview added by tsickle
 * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
 */
class BMInputSearchComponent {
    /**
     * @param {?} _renderer
     */
    constructor(_renderer) {
        this._renderer = _renderer;
        /**
         * Input values to directly copy to inner checkbox
         */
        this.name = '';
        this.placeholder = '';
        this.tabIndex = 0;
        // tslint:disable-next-line:no-reserved-keywords
        this.type = 'text';
        /**
         * Suggestions specifics
         */
        this.showSuggestions = false;
        this.minSuggestionChars = 2;
        this.search = new EventEmitter();
        // tslint:disable-next-line:no-any no-empty
        this.onTouched = (/**
         * @return {?}
         */
        () => { });
        // tslint:disable:no-any
        // tslint:disable:no-empty
        this.propagateChange = (/**
         * @param {?} _
         * @return {?}
         */
        (_) => { });
    }
    /**
     * @param {?} v
     * @return {?}
     */
    set value(v) {
        if (v) {
            this._renderer.setProperty(this.input.nativeElement, 'value', v);
        }
    }
    /**
     * @return {?}
     */
    get value() {
        return this.input.nativeElement.value;
    }
    /**
     * @param {?} event
     * @return {?}
     */
    inputKeyUp(event) {
        switch (event.keyCode) {
            case 40: // Down arrow
                if (this.suggestionList.first) {
                    this.suggestionList.first.nativeElement.focus();
                }
                break;
            case 27: // Escape
                this.closeSuggestions();
                break;
            default:
                /** @type {?} */
                const value = ((/** @type {?} */ (event.target))).value.toLowerCase();
                if (value.length >= this.minSuggestionChars &&
                    Array.isArray(this.suggestions)) {
                    this.showSuggestions = true;
                    this.filteredSuggestions = this.suggestions
                        .map((/**
                     * @param {?} item
                     * @return {?}
                     */
                    item => item.toString().toLowerCase()))
                        .filter((/**
                     * @param {?} item
                     * @return {?}
                     */
                    item => item.search(value) !== -1));
                }
                else {
                    this.showSuggestions = false;
                }
                return;
        }
    }
    // tslint:disable-next-line:no-any
    /**
     * @param {?} event
     * @param {?} index
     * @param {?} value
     * @return {?}
     */
    suggestionKeyUp(event, index, value) {
        /** @type {?} */
        const suggestionLi = this.suggestionList.toArray();
        switch (event.keyCode) {
            case 40: // Up arrow
                if (index === this.suggestions.length - 1) {
                    this.suggestionList.first.nativeElement.focus();
                }
                else {
                    suggestionLi[index + 1].nativeElement.focus();
                }
                event.preventDefault();
                break;
            case 38: // Down arrow
                if (index === 0) {
                    this.suggestionList.last.nativeElement.focus();
                }
                else {
                    suggestionLi[index - 1].nativeElement.focus();
                }
                event.preventDefault();
                break;
            case 27: // Escape
                this.closeSuggestions();
                break;
            case 13: // Enter
                this.setInput(value);
                break;
            default:
                return;
        }
    }
    // tslint:disable-next-line:no-any
    /**
     * @param {?} v
     * @return {?}
     */
    setInput(v) {
        this.value = v;
        this.propagateChange(this.value);
        this.closeSuggestions();
    }
    /**
     * Custom Input functions
     * @return {?}
     */
    inputBlur() {
        this.onTouched();
    }
    // tslint:disable-next-line:no-any
    /**
     * @param {?} value
     * @return {?}
     */
    writeValue(value) {
        this._renderer.setProperty(this.input.nativeElement, 'value', value);
    }
    // tslint:disable-next-line:no-any
    /**
     * @param {?} fn
     * @return {?}
     */
    registerOnChange(fn) {
        this.propagateChange = fn;
    }
    // tslint:disable-next-line:no-any
    /**
     * @param {?} fn
     * @return {?}
     */
    registerOnTouched(fn) {
        this.onTouched = fn;
    }
    /**
     * @param {?} event
     * @return {?}
     */
    inputChange(event) {
        const { value } = (/** @type {?} */ (event.target));
        this.propagateChange(value);
    }
    /**
     * @return {?}
     */
    focus() {
        this.input.nativeElement.focus();
    }
    /**
     * @private
     * @return {?}
     */
    closeSuggestions() {
        this.input.nativeElement.focus();
        this.showSuggestions = false;
    }
}
BMInputSearchComponent.decorators = [
    { type: Component, args: [{
                selector: 'bm-input-search',
                template: "<div class=\"bm-input bm-input-search__input-container\">\n  <input\n    #input\n    class=\"bm-input bm-input-search__input\"\n    autocomplete=\"off\"\n    [type]=\"type\"\n    [required]=\"required\"\n    [disabled]=\"disabled\"\n    [name]=\"name\"\n    [tabIndex]=\"tabIndex\"\n    [readonly]=\"readonly\"\n    [placeholder]=\"placeholder\"\n    [attr.aria-label]=\"ariaLabel\"\n    [attr.aria-labelledby]=\"ariaLabelledby\"\n    (keyup)=\"inputKeyUp($event)\"\n    (change)=\"inputChange($event)\"\n    (blur)=\"inputBlur()\"\n  />\n  <button\n    class=\"bm-button bm-button--primary bm-input-search__search-button\"\n    (click)=\"search.emit(input.value)\"\n  >\n    <i class=\"fas fa-search\" aria-hidden=\"true\"></i>\n  </button>\n</div>\n\n<div class=\"bm-input-search__suggestions-container\" *ngIf=\"showSuggestions\">\n  <ul class=\"bm-input-search__suggestions-list\">\n    <li\n      i18n\n      tabindex=\"-1\"\n      *ngIf=\"filteredSuggestions?.length === 0\"\n      class=\"bm-input-search__suggestions-list-item\"\n    >\n      No matches found\n    </li>\n    <li\n      #sugg\n      tabindex=\"0\"\n      *ngFor=\"let suggestion of filteredSuggestions; let i = index\"\n      class=\"bm-input-search__suggestions-list-item\"\n      (click)=\"setInput(suggestion)\"\n      (keydown)=\"suggestionKeyUp($event, i, suggestion)\"\n    >\n      {{ suggestion }}\n    </li>\n  </ul>\n</div>\n",
                providers: [
                    {
                        provide: NG_VALUE_ACCESSOR,
                        // tslint:disable-next-line:no-forward-ref
                        useExisting: forwardRef((/**
                         * @return {?}
                         */
                        () => BMInputSearchComponent)),
                        multi: true,
                    },
                ],
                changeDetection: ChangeDetectionStrategy.OnPush,
                encapsulation: ViewEncapsulation.None,
                styles: ["bm-input-search{display:inline-block;position:relative}.bm-input-search__input{padding:.3rem 3rem .3rem 1rem!important;width:100%;box-sizing:border-box}.bm-input-search__input-container{position:relative;width:100%;height:100%}.bm-input-search__search-button{display:block;position:absolute;right:0;top:1px;bottom:1px;border-top-left-radius:0;border-bottom-left-radius:0;padding:0 .75em;font-weight:400}.bm-input-search--inverse .bm-input-search__input{background-color:#fff}.bm-input-search__suggestions-container{position:absolute;top:2.4em;width:100%;max-height:10em;box-shadow:0 0 4px 0 rgba(0,0,0,.09);overflow-x:auto}.bm-input-search__suggestions-list{list-style:none;padding:0;margin:0}.bm-input-search__suggestions-list-item{padding:.2em 1em;cursor:pointer}.bm-input-search__suggestions-list-item:nth-child(odd){background-color:#fff}.bm-input-search__suggestions-list-item:nth-child(even){background-color:var(--secondary-color,#bcbcbc)}.bm-input-search__suggestions-list-item:focus,.bm-input-search__suggestions-list-item:hover{background-color:var(--secondary-color-hover,#959494)}"]
            }] }
];
/** @nocollapse */
BMInputSearchComponent.ctorParameters = () => [
    { type: Renderer2 }
];
BMInputSearchComponent.propDecorators = {
    input: [{ type: ViewChild, args: ['input', { static: true },] }],
    suggestionList: [{ type: ViewChildren, args: ['sugg',] }],
    name: [{ type: Input }],
    placeholder: [{ type: Input }],
    tabIndex: [{ type: Input }],
    required: [{ type: Input }],
    disabled: [{ type: Input }],
    readonly: [{ type: Input }],
    type: [{ type: Input }],
    ariaLabel: [{ type: Input, args: ['aria-label',] }],
    ariaLabelledby: [{ type: Input, args: ['aria-labelledby',] }],
    value: [{ type: Input }],
    minSuggestionChars: [{ type: Input }],
    suggestions: [{ type: Input }],
    search: [{ type: Output }]
};

/**
 * @fileoverview added by tsickle
 * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
 */
class BMOptionDirective {
}
BMOptionDirective.decorators = [
    { type: Directive, args: [{
                selector: '[bmOption]',
            },] }
];
class BMSelectComponent {
    /**
     * @param {?} _renderer
     */
    constructor(_renderer) {
        this._renderer = _renderer;
        /**
         * Input values to directly copy to inner checkbox
         */
        this.name = '';
        this.tabIndex = 0;
        // tslint:disable-next-line:no-reserved-keywords
        this.type = 'text';
        // tslint:disable-next-line:no-any no-empty
        this.onTouched = (/**
         * @return {?}
         */
        () => { });
        // tslint:disable:no-any
        // tslint:disable:no-empty
        this.propagateChange = (/**
         * @param {?} _
         * @return {?}
         */
        (_) => { });
    }
    /**
     * @param {?} v
     * @return {?}
     */
    set value(v) {
        this._valueCopy = v;
        this.setCheckedOption();
    }
    /**
     * @return {?}
     */
    get value() {
        return this._valueCopy;
    }
    /**
     * Custom Input functions
     * @return {?}
     */
    inputBlur() {
        this.onTouched();
    }
    // tslint:disable-next-line:no-any
    /**
     * @param {?} value
     * @return {?}
     */
    writeValue(value) {
        this._valueCopy = value;
        this.setCheckedOption();
    }
    // tslint:disable-next-line:no-any
    /**
     * @param {?} fn
     * @return {?}
     */
    registerOnChange(fn) {
        this.propagateChange = fn;
    }
    // tslint:disable-next-line:no-any
    /**
     * @param {?} fn
     * @return {?}
     */
    registerOnTouched(fn) {
        this.onTouched = fn;
    }
    /**
     * @param {?} event
     * @return {?}
     */
    inputChange(event) {
        const { value } = (/** @type {?} */ (event.target));
        this._valueCopy = value;
        this.propagateChange(value);
    }
    /**
     * @return {?}
     */
    focus() {
        ((/** @type {?} */ (this.select.nativeElement))).focus();
    }
    /**
     * @return {?}
     */
    ngAfterContentInit() {
        this._optionsSubs = this.options.changes.subscribe((/**
         * @return {?}
         */
        () => this.setCheckedOption()));
        this.setCheckedOption();
    }
    /**
     * @return {?}
     */
    ngOnDestroy() {
        if (this._optionsSubs) {
            this._optionsSubs.unsubscribe();
        }
    }
    /**
     * @private
     * @return {?}
     */
    setCheckedOption() {
        if (this._valueCopy !== undefined) {
            this._renderer.setValue(this.select.nativeElement, this._valueCopy);
        }
        if (!this.options) {
            return;
        }
        this.options.forEach((/**
         * @param {?} elem
         * @return {?}
         */
        elem => {
            /** @type {?} */
            const domEle = elem.nativeElement;
            if (domEle) {
                domEle.selected = domEle.value === this._valueCopy;
            }
        }));
    }
}
BMSelectComponent.decorators = [
    { type: Component, args: [{
                selector: 'bm-select',
                template: "<select #select\n  class=\"bm-select__select\"\n  [required]=\"required\"\n  [disabled]=\"disabled\"\n  [name]=\"name\"\n  [tabIndex]=\"tabIndex\"\n  [attr.aria-label]=\"ariaLabel\"\n  [attr.aria-labelledby]=\"ariaLabelledby\"\n  (change)=\"inputChange($event)\"\n  (blur)=\"inputBlur()\">\n  <ng-content></ng-content>\n</select>\n",
                providers: [
                    {
                        provide: NG_VALUE_ACCESSOR,
                        // tslint:disable-next-line:no-forward-ref
                        useExisting: forwardRef((/**
                         * @return {?}
                         */
                        () => BMSelectComponent)),
                        multi: true,
                    },
                ],
                changeDetection: ChangeDetectionStrategy.OnPush,
                encapsulation: ViewEncapsulation.None,
                styles: [".bm-select__select{-moz-appearance:none;-ms-word-break:normal;-webkit-appearance:none;appearance:none;background:var(--header-color,#f8f8f8);border-radius:.333em;border:none;box-shadow:0 1px 1px 0 rgba(0,0,0,.2);font-family:proxima-regular;font-size:.815rem;font-weight:400;line-height:1.45rem;padding:.3em 2em .3em .6em;width:100%;word-break:normal}bm-select{min-width:200;display:inline-block;position:relative}bm-select--inverse .bm-select__select{background:#fff;box-shadow:inset 0 1px 1px 0 rgba(0,0,0,.2)}bm-select::after{content:'\\f0d7';font-weight:900;font-family:\"Font Awesome 5 Free\";pointer-events:none;position:absolute;right:8px;top:6px}"]
            }] }
];
/** @nocollapse */
BMSelectComponent.ctorParameters = () => [
    { type: Renderer2 }
];
BMSelectComponent.propDecorators = {
    select: [{ type: ViewChild, args: ['select', { static: true },] }],
    options: [{ type: ContentChildren, args: [BMOptionDirective, { read: ElementRef },] }],
    name: [{ type: Input }],
    tabIndex: [{ type: Input }],
    required: [{ type: Input }],
    disabled: [{ type: Input }],
    readonly: [{ type: Input }],
    type: [{ type: Input }],
    ariaLabel: [{ type: Input, args: ['aria-label',] }],
    ariaLabelledby: [{ type: Input, args: ['aria-labelledby',] }],
    value: [{ type: Input }]
};

/**
 * @fileoverview added by tsickle
 * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
 */
class BMATFormsModule {
}
BMATFormsModule.decorators = [
    { type: NgModule, args: [{
                imports: [CommonModule],
                declarations: [
                    BMDurationInputComponent,
                    BMInputSearchComponent,
                    BMMultiselectComponent,
                    BMOptionDirective,
                    BMSelectComponent,
                ],
                exports: [
                    BMDurationInputComponent,
                    BMInputSearchComponent,
                    BMMultiselectComponent,
                    BMOptionDirective,
                    BMSelectComponent,
                ],
                providers: [],
            },] }
];

export { BMATFormsModule, BMDurationInputComponent, BMInputSearchComponent, BMMultiselectComponent, BMOptionDirective, BMSelectComponent };
//# sourceMappingURL=bmat-angular-forms.js.map