ngx-bootstrap 3.0.1 → 3.1.4

package/typeahead/esm5/ngx-bootstrap-typeahead.js

@@ -0,0 +1,10 @@
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes} checked by tsc
+ */
+/**
+ * Generated bundle index. Do not edit.
+ */
+export { latinMap, TypeaheadOptions, TypeaheadMatch, escapeRegexp, getValueFromObject, tokenize, latinize, TypeaheadContainerComponent, TypeaheadDirective, TypeaheadModule, TypeaheadConfig } from './public_api';
+
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibmd4LWJvb3RzdHJhcC10eXBlYWhlYWQuanMiLCJzb3VyY2VSb290Ijoibmc6Ly9uZ3gtYm9vdHN0cmFwL3R5cGVhaGVhZC8iLCJzb3VyY2VzIjpbIm5neC1ib290c3RyYXAtdHlwZWFoZWFkLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7Ozs7QUFJQSxvTUFBYyxjQUFjLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIEdlbmVyYXRlZCBidW5kbGUgaW5kZXguIERvIG5vdCBlZGl0LlxuICovXG5cbmV4cG9ydCAqIGZyb20gJy4vcHVibGljX2FwaSc7XG4iXX0=

package/typeahead/esm5/public_api.js

@@ -0,0 +1,14 @@
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes} checked by tsc
+ */
+export { latinMap } from './latin-map';
+export { TypeaheadOptions } from './typeahead-options.class';
+export { TypeaheadMatch } from './typeahead-match.class';
+export { escapeRegexp, getValueFromObject, tokenize, latinize } from './typeahead-utils';
+export { TypeaheadContainerComponent } from './typeahead-container.component';
+export { TypeaheadDirective } from './typeahead.directive';
+export { TypeaheadModule } from './typeahead.module';
+export { TypeaheadConfig } from './typeahead.config';
+
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljX2FwaS5qcyIsInNvdXJjZVJvb3QiOiJuZzovL25neC1ib290c3RyYXAvdHlwZWFoZWFkLyIsInNvdXJjZXMiOlsicHVibGljX2FwaS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7O0FBQUEsT0FBTyxFQUFFLFFBQVEsRUFBRSxNQUFNLGFBQWEsQ0FBQztBQUN2QyxPQUFPLEVBQUUsZ0JBQWdCLEVBQUUsTUFBTSwyQkFBMkIsQ0FBQztBQUM3RCxPQUFPLEVBQUUsY0FBYyxFQUFFLE1BQU0seUJBQXlCLENBQUM7QUFFekQsT0FBTyxFQUNMLFlBQVksRUFDWixrQkFBa0IsRUFDbEIsUUFBUSxFQUNSLFFBQVEsRUFDVCxNQUFNLG1CQUFtQixDQUFDO0FBQzNCLE9BQU8sRUFBRSwyQkFBMkIsRUFBRSxNQUFNLGlDQUFpQyxDQUFDO0FBQzlFLE9BQU8sRUFBRSxrQkFBa0IsRUFBRSxNQUFNLHVCQUF1QixDQUFDO0FBQzNELE9BQU8sRUFBRSxlQUFlLEVBQUUsTUFBTSxvQkFBb0IsQ0FBQztBQUNyRCxPQUFPLEVBQUUsZUFBZSxFQUFFLE1BQU0sb0JBQW9CLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgeyBsYXRpbk1hcCB9IGZyb20gJy4vbGF0aW4tbWFwJztcbmV4cG9ydCB7IFR5cGVhaGVhZE9wdGlvbnMgfSBmcm9tICcuL3R5cGVhaGVhZC1vcHRpb25zLmNsYXNzJztcbmV4cG9ydCB7IFR5cGVhaGVhZE1hdGNoIH0gZnJvbSAnLi90eXBlYWhlYWQtbWF0Y2guY2xhc3MnO1xuXG5leHBvcnQge1xuICBlc2NhcGVSZWdleHAsXG4gIGdldFZhbHVlRnJvbU9iamVjdCxcbiAgdG9rZW5pemUsXG4gIGxhdGluaXplXG59IGZyb20gJy4vdHlwZWFoZWFkLXV0aWxzJztcbmV4cG9ydCB7IFR5cGVhaGVhZENvbnRhaW5lckNvbXBvbmVudCB9IGZyb20gJy4vdHlwZWFoZWFkLWNvbnRhaW5lci5jb21wb25lbnQnO1xuZXhwb3J0IHsgVHlwZWFoZWFkRGlyZWN0aXZlIH0gZnJvbSAnLi90eXBlYWhlYWQuZGlyZWN0aXZlJztcbmV4cG9ydCB7IFR5cGVhaGVhZE1vZHVsZSB9IGZyb20gJy4vdHlwZWFoZWFkLm1vZHVsZSc7XG5leHBvcnQgeyBUeXBlYWhlYWRDb25maWcgfSBmcm9tICcuL3R5cGVhaGVhZC5jb25maWcnO1xuIl19

package/typeahead/esm5/typeahead-container.component.js

@@ -0,0 +1,414 @@
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes} checked by tsc
+ */
+import { Component, ElementRef, HostListener, QueryList, ViewChild, ViewChildren, Renderer2 } from '@angular/core';
+import { isBs3, Utils } from 'ngx-bootstrap/utils';
+import { latinize } from './typeahead-utils';
+var TypeaheadContainerComponent = /** @class */ (function () {
+    function TypeaheadContainerComponent(element, renderer) {
+        this.renderer = renderer;
+        this.isFocused = false;
+        this._matches = [];
+        this.isScrolledIntoView = function (elem) {
+            var /** @type {?} */ containerViewTop = this.ulElement.nativeElement.scrollTop;
+            var /** @type {?} */ containerViewBottom = containerViewTop + Number(this.ulElement.nativeElement.offsetHeight);
+            var /** @type {?} */ elemTop = elem.offsetTop;
+            var /** @type {?} */ elemBottom = elemTop + elem.offsetHeight;
+            return ((elemBottom <= containerViewBottom) && (elemTop >= containerViewTop));
+        };
+        this.element = element;
+    }
+    Object.defineProperty(TypeaheadContainerComponent.prototype, "isBs4", {
+        get: /**
+         * @return {?}
+         */
+        function () {
+            return !isBs3();
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(TypeaheadContainerComponent.prototype, "active", {
+        get: /**
+         * @return {?}
+         */
+        function () {
+            return this._active;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(TypeaheadContainerComponent.prototype, "matches", {
+        get: /**
+         * @return {?}
+         */
+        function () {
+            return this._matches;
+        },
+        set: /**
+         * @param {?} value
+         * @return {?}
+         */
+        function (value) {
+            var _this = this;
+            this._matches = value;
+            this.needScrollbar = this.typeaheadScrollable && this.typeaheadOptionsInScrollableView < this.matches.length;
+            if (this.typeaheadScrollable) {
+                setTimeout(function () {
+                    _this.setScrollableMode();
+                });
+            }
+            if (this._matches.length > 0) {
+                this._active = this._matches[0];
+                if (this._active.isHeader()) {
+                    this.nextActiveMatch();
+                }
+            }
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(TypeaheadContainerComponent.prototype, "optionsListTemplate", {
+        // tslint:disable-next-line:no-any
+        get: /**
+         * @return {?}
+         */
+        function () {
+            return this.parent ? this.parent.optionsListTemplate : undefined;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(TypeaheadContainerComponent.prototype, "typeaheadScrollable", {
+        get: /**
+         * @return {?}
+         */
+        function () {
+            return this.parent ? this.parent.typeaheadScrollable : false;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(TypeaheadContainerComponent.prototype, "typeaheadOptionsInScrollableView", {
+        get: /**
+         * @return {?}
+         */
+        function () {
+            return this.parent ? this.parent.typeaheadOptionsInScrollableView : 5;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(TypeaheadContainerComponent.prototype, "itemTemplate", {
+        // tslint:disable-next-line:no-any
+        get: /**
+         * @return {?}
+         */
+        function () {
+            return this.parent ? this.parent.typeaheadItemTemplate : undefined;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    /**
+     * @return {?}
+     */
+    TypeaheadContainerComponent.prototype.selectActiveMatch = /**
+     * @return {?}
+     */
+    function () {
+        this.selectMatch(this._active);
+    };
+    /**
+     * @return {?}
+     */
+    TypeaheadContainerComponent.prototype.prevActiveMatch = /**
+     * @return {?}
+     */
+    function () {
+        var /** @type {?} */ index = this.matches.indexOf(this._active);
+        this._active = this.matches[index - 1 < 0 ? this.matches.length - 1 : index - 1];
+        if (this._active.isHeader()) {
+            this.prevActiveMatch();
+        }
+        if (this.typeaheadScrollable) {
+            this.scrollPrevious(index);
+        }
+    };
+    /**
+     * @return {?}
+     */
+    TypeaheadContainerComponent.prototype.nextActiveMatch = /**
+     * @return {?}
+     */
+    function () {
+        var /** @type {?} */ index = this.matches.indexOf(this._active);
+        this._active = this.matches[index + 1 > this.matches.length - 1 ? 0 : index + 1];
+        if (this._active.isHeader()) {
+            this.nextActiveMatch();
+        }
+        if (this.typeaheadScrollable) {
+            this.scrollNext(index);
+        }
+    };
+    /**
+     * @param {?} value
+     * @return {?}
+     */
+    TypeaheadContainerComponent.prototype.selectActive = /**
+     * @param {?} value
+     * @return {?}
+     */
+    function (value) {
+        this.isFocused = true;
+        this._active = value;
+    };
+    /**
+     * @param {?} match
+     * @param {?} query
+     * @return {?}
+     */
+    TypeaheadContainerComponent.prototype.highlight = /**
+     * @param {?} match
+     * @param {?} query
+     * @return {?}
+     */
+    function (match, query) {
+        var /** @type {?} */ itemStr = match.value;
+        var /** @type {?} */ itemStrHelper = (this.parent && this.parent.typeaheadLatinize
+            ? latinize(itemStr)
+            : itemStr).toLowerCase();
+        var /** @type {?} */ startIdx;
+        var /** @type {?} */ tokenLen;
+        // Replaces the capture string with the same string inside of a "strong" tag
+        if (typeof query === 'object') {
+            var /** @type {?} */ queryLen = query.length;
+            for (var /** @type {?} */ i = 0; i < queryLen; i += 1) {
+                // query[i] is already latinized and lower case
+                startIdx = itemStrHelper.indexOf(query[i]);
+                tokenLen = query[i].length;
+                if (startIdx >= 0 && tokenLen > 0) {
+                    itemStr =
+                        itemStr.substring(0, startIdx) + "<strong>" + itemStr.substring(startIdx, startIdx + tokenLen) + "</strong>" +
+                            ("" + itemStr.substring(startIdx + tokenLen));
+                    itemStrHelper =
+                        itemStrHelper.substring(0, startIdx) + "        " + ' '.repeat(tokenLen) + "         " +
+                            ("" + itemStrHelper.substring(startIdx + tokenLen));
+                }
+            }
+        }
+        else if (query) {
+            // query is already latinized and lower case
+            startIdx = itemStrHelper.indexOf(query);
+            tokenLen = query.length;
+            if (startIdx >= 0 && tokenLen > 0) {
+                itemStr =
+                    itemStr.substring(0, startIdx) + "<strong>" + itemStr.substring(startIdx, startIdx + tokenLen) + "</strong>" +
+                        ("" + itemStr.substring(startIdx + tokenLen));
+            }
+        }
+        return itemStr;
+    };
+    /**
+     * @return {?}
+     */
+    TypeaheadContainerComponent.prototype.focusLost = /**
+     * @return {?}
+     */
+    function () {
+        this.isFocused = false;
+    };
+    /**
+     * @param {?} value
+     * @return {?}
+     */
+    TypeaheadContainerComponent.prototype.isActive = /**
+     * @param {?} value
+     * @return {?}
+     */
+    function (value) {
+        return this._active === value;
+    };
+    /**
+     * @param {?} value
+     * @param {?=} e
+     * @return {?}
+     */
+    TypeaheadContainerComponent.prototype.selectMatch = /**
+     * @param {?} value
+     * @param {?=} e
+     * @return {?}
+     */
+    function (value, e) {
+        var _this = this;
+        if (e === void 0) { e = void 0; }
+        if (e) {
+            e.stopPropagation();
+            e.preventDefault();
+        }
+        this.parent.changeModel(value);
+        setTimeout(function () { return _this.parent.typeaheadOnSelect.emit(value); }, 0);
+        return false;
+    };
+    /**
+     * @return {?}
+     */
+    TypeaheadContainerComponent.prototype.setScrollableMode = /**
+     * @return {?}
+     */
+    function () {
+        if (!this.ulElement) {
+            this.ulElement = this.element;
+        }
+        if (this.liElements.first) {
+            var /** @type {?} */ ulStyles = Utils.getStyles(this.ulElement.nativeElement);
+            var /** @type {?} */ liStyles = Utils.getStyles(this.liElements.first.nativeElement);
+            var /** @type {?} */ ulPaddingBottom = parseFloat((ulStyles['padding-bottom'] ? ulStyles['padding-bottom'] : '')
+                .replace('px', ''));
+            var /** @type {?} */ ulPaddingTop = parseFloat((ulStyles['padding-top'] ? ulStyles['padding-top'] : '0')
+                .replace('px', ''));
+            var /** @type {?} */ optionHeight = parseFloat((liStyles.height ? liStyles.height : '0')
+                .replace('px', ''));
+            var /** @type {?} */ height = this.typeaheadOptionsInScrollableView * optionHeight;
+            this.guiHeight = height + ulPaddingTop + ulPaddingBottom + "px";
+        }
+        this.renderer.setStyle(this.element.nativeElement, 'visibility', 'visible');
+    };
+    /**
+     * @param {?} index
+     * @return {?}
+     */
+    TypeaheadContainerComponent.prototype.scrollPrevious = /**
+     * @param {?} index
+     * @return {?}
+     */
+    function (index) {
+        if (index === 0) {
+            this.scrollToBottom();
+            return;
+        }
+        if (this.liElements) {
+            var /** @type {?} */ liElement = this.liElements.toArray()[index - 1];
+            if (liElement && !this.isScrolledIntoView(liElement.nativeElement)) {
+                this.ulElement.nativeElement.scrollTop = liElement.nativeElement.offsetTop;
+            }
+        }
+    };
+    /**
+     * @param {?} index
+     * @return {?}
+     */
+    TypeaheadContainerComponent.prototype.scrollNext = /**
+     * @param {?} index
+     * @return {?}
+     */
+    function (index) {
+        if (index + 1 > this.matches.length - 1) {
+            this.scrollToTop();
+            return;
+        }
+        if (this.liElements) {
+            var /** @type {?} */ liElement = this.liElements.toArray()[index + 1];
+            if (liElement && !this.isScrolledIntoView(liElement.nativeElement)) {
+                this.ulElement.nativeElement.scrollTop =
+                    liElement.nativeElement.offsetTop -
+                        Number(this.ulElement.nativeElement.offsetHeight) +
+                        Number(liElement.nativeElement.offsetHeight);
+            }
+        }
+    };
+    /**
+     * @return {?}
+     */
+    TypeaheadContainerComponent.prototype.scrollToBottom = /**
+     * @return {?}
+     */
+    function () {
+        this.ulElement.nativeElement.scrollTop = this.ulElement.nativeElement.scrollHeight;
+    };
+    /**
+     * @return {?}
+     */
+    TypeaheadContainerComponent.prototype.scrollToTop = /**
+     * @return {?}
+     */
+    function () {
+        this.ulElement.nativeElement.scrollTop = 0;
+    };
+    TypeaheadContainerComponent.decorators = [
+        { type: Component, args: [{
+                    selector: 'typeahead-container',
+                    // tslint:disable-next-line
+                    template: "<!-- inject options list template -->\n<ng-template [ngTemplateOutlet]=\"optionsListTemplate || (isBs4 ? bs4Template : bs3Template)\"\n             [ngTemplateOutletContext]=\"{matches:matches, itemTemplate:itemTemplate, query:query}\"></ng-template>\n\n<!-- default options item template -->\n<ng-template #bsItemTemplate let-match=\"match\" let-query=\"query\"><span [innerHtml]=\"highlight(match, query)\"></span>\n</ng-template>\n\n<!-- Bootstrap 3 options list template -->\n<ng-template #bs3Template>\n  <ul class=\"dropdown-menu\"\n      #ulElement\n      [style.overflow-y]=\"needScrollbar ? 'scroll': 'auto'\"\n      [style.height]=\"needScrollbar ? guiHeight: 'auto'\">\n    <ng-template ngFor let-match let-i=\"index\" [ngForOf]=\"matches\">\n      <li #liElements *ngIf=\"match.isHeader()\" class=\"dropdown-header\">{{ match }}</li>\n      <li #liElements *ngIf=\"!match.isHeader()\" [class.active]=\"isActive(match)\" (mouseenter)=\"selectActive(match)\">\n        <a href=\"#\" (click)=\"selectMatch(match, $event)\" tabindex=\"-1\">\n          <ng-template [ngTemplateOutlet]=\"itemTemplate || bsItemTemplate\"\n                       [ngTemplateOutletContext]=\"{item:match.item, index:i, match:match, query:query}\"></ng-template>\n        </a>\n      </li>\n    </ng-template>\n  </ul>\n</ng-template>\n\n<!-- Bootstrap 4 options list template -->\n<ng-template #bs4Template>\n  <ng-template ngFor let-match let-i=\"index\" [ngForOf]=\"matches\">\n    <h6 *ngIf=\"match.isHeader()\" class=\"dropdown-header\">{{ match }}</h6>\n    <ng-template [ngIf]=\"!match.isHeader()\">\n      <button #liElements\n              class=\"dropdown-item\"\n              (click)=\"selectMatch(match, $event)\"\n              (mouseenter)=\"selectActive(match)\"\n              [class.active]=\"isActive(match)\">\n        <ng-template [ngTemplateOutlet]=\"itemTemplate || bsItemTemplate\"\n                     [ngTemplateOutletContext]=\"{item:match.item, index:i, match:match, query:query}\"></ng-template>\n      </button>\n    </ng-template>\n  </ng-template>\n</ng-template>\n",
+                    host: {
+                        class: 'dropdown open',
+                        '[class.dropdown-menu]': 'isBs4',
+                        '[style.overflow-y]': "isBs4 && needScrollbar ? 'scroll': 'visible'",
+                        '[style.height]': "isBs4 && needScrollbar ? guiHeight: 'auto'",
+                        '[style.visibility]': "typeaheadScrollable ? 'hidden' : 'visible'",
+                        '[class.dropup]': 'dropup',
+                        style: 'position: absolute;display: block;'
+                    }
+                }] }
+    ];
+    /** @nocollapse */
+    TypeaheadContainerComponent.ctorParameters = function () { return [
+        { type: ElementRef, },
+        { type: Renderer2, },
+    ]; };
+    TypeaheadContainerComponent.propDecorators = {
+        "ulElement": [{ type: ViewChild, args: ['ulElement',] },],
+        "liElements": [{ type: ViewChildren, args: ['liElements',] },],
+        "focusLost": [{ type: HostListener, args: ['mouseleave',] }, { type: HostListener, args: ['blur',] },],
+    };
+    return TypeaheadContainerComponent;
+}());
+export { TypeaheadContainerComponent };
+function TypeaheadContainerComponent_tsickle_Closure_declarations() {
+    /** @type {!Array<{type: !Function, args: (undefined|!Array<?>)}>} */
+    TypeaheadContainerComponent.decorators;
+    /**
+     * @nocollapse
+     * @type {function(): !Array<(null|{type: ?, decorators: (undefined|!Array<{type: !Function, args: (undefined|!Array<?>)}>)})>}
+     */
+    TypeaheadContainerComponent.ctorParameters;
+    /** @type {!Object<string,!Array<{type: !Function, args: (undefined|!Array<?>)}>>} */
+    TypeaheadContainerComponent.propDecorators;
+    /** @type {?} */
+    TypeaheadContainerComponent.prototype.parent;
+    /** @type {?} */
+    TypeaheadContainerComponent.prototype.query;
+    /** @type {?} */
+    TypeaheadContainerComponent.prototype.element;
+    /** @type {?} */
+    TypeaheadContainerComponent.prototype.isFocused;
+    /** @type {?} */
+    TypeaheadContainerComponent.prototype.top;
+    /** @type {?} */
+    TypeaheadContainerComponent.prototype.left;
+    /** @type {?} */
+    TypeaheadContainerComponent.prototype.display;
+    /** @type {?} */
+    TypeaheadContainerComponent.prototype.placement;
+    /** @type {?} */
+    TypeaheadContainerComponent.prototype.dropup;
+    /** @type {?} */
+    TypeaheadContainerComponent.prototype.guiHeight;
+    /** @type {?} */
+    TypeaheadContainerComponent.prototype.needScrollbar;
+    /** @type {?} */
+    TypeaheadContainerComponent.prototype._active;
+    /** @type {?} */
+    TypeaheadContainerComponent.prototype._matches;
+    /** @type {?} */
+    TypeaheadContainerComponent.prototype.ulElement;
+    /** @type {?} */
+    TypeaheadContainerComponent.prototype.liElements;
+    /** @type {?} */
+    TypeaheadContainerComponent.prototype.isScrolledIntoView;
+    /** @type {?} */
+    TypeaheadContainerComponent.prototype.renderer;
+}
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"typeahead-container.component.js","sourceRoot":"ng://ngx-bootstrap/typeahead/","sources":["typeahead-container.component.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  Component,\n  ElementRef,\n  HostListener,\n  QueryList,\n  TemplateRef,\n  ViewChild,\n  ViewChildren,\n  Renderer2\n} from '@angular/core';\n\nimport { isBs3, Utils } from 'ngx-bootstrap/utils';\nimport { latinize } from './typeahead-utils';\nimport { TypeaheadMatch } from './typeahead-match.class';\nimport { TypeaheadDirective } from './typeahead.directive';\n\n@Component({\n  selector: 'typeahead-container',\n  // tslint:disable-next-line\n  templateUrl: './typeahead-container.component.html',\n  host: {\n    class: 'dropdown open',\n    '[class.dropdown-menu]': 'isBs4',\n    '[style.overflow-y]' : `isBs4 && needScrollbar ? 'scroll': 'visible'`,\n    '[style.height]': `isBs4 && needScrollbar ? guiHeight: 'auto'`,\n    '[style.visibility]': `typeaheadScrollable ? 'hidden' : 'visible'`,\n    '[class.dropup]': 'dropup',\n    style: 'position: absolute;display: block;'\n  }\n})\nexport class TypeaheadContainerComponent {\n  parent: TypeaheadDirective;\n  query: string[] | string;\n  element: ElementRef;\n  isFocused = false;\n  top: string;\n  left: string;\n  display: string;\n  placement: string;\n  dropup: boolean;\n  guiHeight: string;\n  needScrollbar: boolean;\n\n  get isBs4(): boolean {\n    return !isBs3();\n  }\n\n  protected _active: TypeaheadMatch;\n  protected _matches: TypeaheadMatch[] = [];\n\n  @ViewChild('ulElement')\n  private ulElement: ElementRef;\n\n  @ViewChildren('liElements')\n  private liElements: QueryList<ElementRef>;\n\n  constructor(element: ElementRef, private renderer: Renderer2) {\n    this.element = element;\n  }\n\n  get active(): TypeaheadMatch {\n    return this._active;\n  }\n\n  get matches(): TypeaheadMatch[] {\n    return this._matches;\n  }\n\n  set matches(value: TypeaheadMatch[]) {\n    this._matches = value;\n    this.needScrollbar = this.typeaheadScrollable && this.typeaheadOptionsInScrollableView < this.matches.length;\n    if (this.typeaheadScrollable) {\n      setTimeout(() => {\n        this.setScrollableMode();\n      });\n    }\n\n    if (this._matches.length > 0) {\n      this._active = this._matches[0];\n      if (this._active.isHeader()) {\n        this.nextActiveMatch();\n      }\n    }\n  }\n// tslint:disable-next-line:no-any\n  get optionsListTemplate(): TemplateRef<any> {\n    return this.parent ? this.parent.optionsListTemplate : undefined;\n  }\n\n  get typeaheadScrollable(): boolean {\n    return this.parent ? this.parent.typeaheadScrollable : false;\n  }\n\n\n  get typeaheadOptionsInScrollableView(): number {\n    return this.parent ? this.parent.typeaheadOptionsInScrollableView : 5;\n  }\n// tslint:disable-next-line:no-any\n  get itemTemplate(): TemplateRef<any> {\n    return this.parent ? this.parent.typeaheadItemTemplate : undefined;\n  }\n\n  selectActiveMatch(): void {\n    this.selectMatch(this._active);\n  }\n\n  prevActiveMatch(): void {\n    const index = this.matches.indexOf(this._active);\n    this._active = this.matches[\n      index - 1 < 0 ? this.matches.length - 1 : index - 1\n      ];\n    if (this._active.isHeader()) {\n      this.prevActiveMatch();\n    }\n    if (this.typeaheadScrollable) {\n      this.scrollPrevious(index);\n    }\n  }\n\n  nextActiveMatch(): void {\n    const index = this.matches.indexOf(this._active);\n    this._active = this.matches[\n      index + 1 > this.matches.length - 1 ? 0 : index + 1\n      ];\n    if (this._active.isHeader()) {\n      this.nextActiveMatch();\n    }\n    if (this.typeaheadScrollable) {\n      this.scrollNext(index);\n    }\n  }\n\n  selectActive(value: TypeaheadMatch): void {\n    this.isFocused = true;\n    this._active = value;\n  }\n\n  highlight(match: TypeaheadMatch, query: string[] | string): string {\n    let itemStr: string = match.value;\n    let itemStrHelper: string = (this.parent && this.parent.typeaheadLatinize\n      ? latinize(itemStr)\n      : itemStr).toLowerCase();\n    let startIdx: number;\n    let tokenLen: number;\n    // Replaces the capture string with the same string inside of a \"strong\" tag\n    if (typeof query === 'object') {\n      const queryLen: number = query.length;\n      for (let i = 0; i < queryLen; i += 1) {\n        // query[i] is already latinized and lower case\n        startIdx = itemStrHelper.indexOf(query[i]);\n        tokenLen = query[i].length;\n        if (startIdx >= 0 && tokenLen > 0) {\n          itemStr =\n            `${itemStr.substring(0, startIdx)}<strong>${itemStr.substring(startIdx, startIdx + tokenLen)}</strong>` +\n            `${itemStr.substring(startIdx + tokenLen)}`;\n          itemStrHelper =\n            `${itemStrHelper.substring(0, startIdx)}        ${' '.repeat(tokenLen)}         ` +\n            `${itemStrHelper.substring(startIdx + tokenLen)}`;\n        }\n      }\n    } else if (query) {\n      // query is already latinized and lower case\n      startIdx = itemStrHelper.indexOf(query);\n      tokenLen = query.length;\n      if (startIdx >= 0 && tokenLen > 0) {\n        itemStr =\n          `${itemStr.substring(0, startIdx)}<strong>${itemStr.substring(startIdx, startIdx + tokenLen)}</strong>` +\n          `${itemStr.substring(startIdx + tokenLen)}`;\n      }\n    }\n\n    return itemStr;\n  }\n\n  @HostListener('mouseleave')\n  @HostListener('blur')\n  focusLost(): void {\n    this.isFocused = false;\n  }\n\n  isActive(value: TypeaheadMatch): boolean {\n    return this._active === value;\n  }\n\n  selectMatch(value: TypeaheadMatch, e: Event = void 0): boolean {\n    if (e) {\n      e.stopPropagation();\n      e.preventDefault();\n    }\n    this.parent.changeModel(value);\n    setTimeout(() => this.parent.typeaheadOnSelect.emit(value), 0);\n\n    return false;\n  }\n\n  setScrollableMode(): void {\n    if (!this.ulElement) {\n      this.ulElement = this.element;\n    }\n    if (this.liElements.first) {\n      const ulStyles = Utils.getStyles(this.ulElement.nativeElement);\n      const liStyles = Utils.getStyles(this.liElements.first.nativeElement);\n      const ulPaddingBottom = parseFloat((ulStyles['padding-bottom'] ? ulStyles['padding-bottom'] : '')\n        .replace('px', ''));\n      const ulPaddingTop = parseFloat((ulStyles['padding-top'] ? ulStyles['padding-top'] : '0')\n        .replace('px', ''));\n      const optionHeight = parseFloat((liStyles.height ? liStyles.height : '0')\n        .replace('px', ''));\n      const height = this.typeaheadOptionsInScrollableView * optionHeight;\n      this.guiHeight = `${height + ulPaddingTop + ulPaddingBottom}px`;\n    }\n    this.renderer.setStyle(this.element.nativeElement, 'visibility', 'visible');\n  }\n\n  scrollPrevious(index: number): void {\n    if (index === 0) {\n      this.scrollToBottom();\n\n      return;\n    }\n    if (this.liElements) {\n      const liElement = this.liElements.toArray()[index - 1];\n      if (liElement && !this.isScrolledIntoView(liElement.nativeElement)) {\n        this.ulElement.nativeElement.scrollTop = liElement.nativeElement.offsetTop;\n      }\n    }\n  }\n\n  scrollNext(index: number): void {\n    if (index + 1 > this.matches.length - 1) {\n      this.scrollToTop();\n\n      return;\n    }\n    if (this.liElements) {\n      const liElement = this.liElements.toArray()[index + 1];\n      if (liElement && !this.isScrolledIntoView(liElement.nativeElement)) {\n        this.ulElement.nativeElement.scrollTop =\n          liElement.nativeElement.offsetTop -\n          Number(this.ulElement.nativeElement.offsetHeight) +\n          Number(liElement.nativeElement.offsetHeight);\n      }\n    }\n  }\n\n\n  private isScrolledIntoView = function (elem: HTMLElement) {\n    const containerViewTop: number = this.ulElement.nativeElement.scrollTop;\n    const containerViewBottom = containerViewTop + Number(this.ulElement.nativeElement.offsetHeight);\n    const elemTop = elem.offsetTop;\n    const elemBottom = elemTop + elem.offsetHeight;\n\n    return ((elemBottom <= containerViewBottom) && (elemTop >= containerViewTop));\n  };\n\n  private scrollToBottom(): void {\n    this.ulElement.nativeElement.scrollTop = this.ulElement.nativeElement.scrollHeight;\n  }\n\n  private scrollToTop(): void {\n    this.ulElement.nativeElement.scrollTop = 0;\n  }\n}\n"]}

package/typeahead/esm5/typeahead-match.class.js

@@ -0,0 +1,44 @@
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes} checked by tsc
+ */
+var TypeaheadMatch = /** @class */ (function () {
+    // tslint:disable-next-line:no-any
+    function TypeaheadMatch(item, value, header) {
+        if (value === void 0) { value = item; }
+        if (header === void 0) { header = false; }
+        this.item = item;
+        this.value = value;
+        this.header = header;
+    }
+    /**
+     * @return {?}
+     */
+    TypeaheadMatch.prototype.isHeader = /**
+     * @return {?}
+     */
+    function () {
+        return this.header;
+    };
+    /**
+     * @return {?}
+     */
+    TypeaheadMatch.prototype.toString = /**
+     * @return {?}
+     */
+    function () {
+        return this.value;
+    };
+    return TypeaheadMatch;
+}());
+export { TypeaheadMatch };
+function TypeaheadMatch_tsickle_Closure_declarations() {
+    /** @type {?} */
+    TypeaheadMatch.prototype.value;
+    /** @type {?} */
+    TypeaheadMatch.prototype.item;
+    /** @type {?} */
+    TypeaheadMatch.prototype.header;
+}
+
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHlwZWFoZWFkLW1hdGNoLmNsYXNzLmpzIiwic291cmNlUm9vdCI6Im5nOi8vbmd4LWJvb3RzdHJhcC90eXBlYWhlYWQvIiwic291cmNlcyI6WyJ0eXBlYWhlYWQtbWF0Y2guY2xhc3MudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7OztBQUFBLElBQUE7SUFPQSxrQ0FBa0M7SUFDaEMsd0JBQVksSUFBUyxFQUFFLEtBQW9CLEVBQUUsTUFBYztRQUFwQyxzQkFBQSxFQUFBLFlBQW9CO1FBQUUsdUJBQUEsRUFBQSxjQUFjO1FBQ3pELElBQUksQ0FBQyxJQUFJLEdBQUcsSUFBSSxDQUFDO1FBQ2pCLElBQUksQ0FBQyxLQUFLLEdBQUcsS0FBSyxDQUFDO1FBQ25CLElBQUksQ0FBQyxNQUFNLEdBQUcsTUFBTSxDQUFDO0tBQ3RCOzs7O0lBRUQsaUNBQVE7OztJQUFSO1FBQ0UsTUFBTSxDQUFDLElBQUksQ0FBQyxNQUFNLENBQUM7S0FDcEI7Ozs7SUFFRCxpQ0FBUTs7O0lBQVI7UUFDRSxNQUFNLENBQUMsSUFBSSxDQUFDLEtBQUssQ0FBQztLQUNuQjt5QkFwQkg7SUFxQkMsQ0FBQTtBQXJCRCwwQkFxQkMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgY2xhc3MgVHlwZWFoZWFkTWF0Y2gge1xuICByZWFkb25seSB2YWx1ZTogc3RyaW5nO1xuXG4vLyB0c2xpbnQ6ZGlzYWJsZS1uZXh0LWxpbmU6bm8tYW55XG4gIHJlYWRvbmx5IGl0ZW06IGFueTtcbiAgcHJvdGVjdGVkIGhlYWRlcjogYm9vbGVhbjtcblxuLy8gdHNsaW50OmRpc2FibGUtbmV4dC1saW5lOm5vLWFueVxuICBjb25zdHJ1Y3RvcihpdGVtOiBhbnksIHZhbHVlOiBzdHJpbmcgPSBpdGVtLCBoZWFkZXIgPSBmYWxzZSkge1xuICAgIHRoaXMuaXRlbSA9IGl0ZW07XG4gICAgdGhpcy52YWx1ZSA9IHZhbHVlO1xuICAgIHRoaXMuaGVhZGVyID0gaGVhZGVyO1xuICB9XG5cbiAgaXNIZWFkZXIoKTogYm9vbGVhbiB7XG4gICAgcmV0dXJuIHRoaXMuaGVhZGVyO1xuICB9XG5cbiAgdG9TdHJpbmcoKTogc3RyaW5nIHtcbiAgICByZXR1cm4gdGhpcy52YWx1ZTtcbiAgfVxufVxuIl19

package/typeahead/esm5/typeahead-options.class.js

@@ -0,0 +1,21 @@
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes} checked by tsc
+ */
+var TypeaheadOptions = /** @class */ (function () {
+    function TypeaheadOptions(options) {
+        Object.assign(this, options);
+    }
+    return TypeaheadOptions;
+}());
+export { TypeaheadOptions };
+function TypeaheadOptions_tsickle_Closure_declarations() {
+    /** @type {?} */
+    TypeaheadOptions.prototype.placement;
+    /** @type {?} */
+    TypeaheadOptions.prototype.animation;
+    /** @type {?} */
+    TypeaheadOptions.prototype.typeaheadRef;
+}
+
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHlwZWFoZWFkLW9wdGlvbnMuY2xhc3MuanMiLCJzb3VyY2VSb290Ijoibmc6Ly9uZ3gtYm9vdHN0cmFwL3R5cGVhaGVhZC8iLCJzb3VyY2VzIjpbInR5cGVhaGVhZC1vcHRpb25zLmNsYXNzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7QUFFQSxJQUFBO0lBS0UsMEJBQVksT0FBeUI7UUFDbkMsTUFBTSxDQUFDLE1BQU0sQ0FBQyxJQUFJLEVBQUUsT0FBTyxDQUFDLENBQUM7S0FDOUI7MkJBVEg7SUFVQyxDQUFBO0FBUkQsNEJBUUMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBUeXBlYWhlYWREaXJlY3RpdmUgfSBmcm9tICcuL3R5cGVhaGVhZC5kaXJlY3RpdmUnO1xuXG5leHBvcnQgY2xhc3MgVHlwZWFoZWFkT3B0aW9ucyB7XG4gIHBsYWNlbWVudDogc3RyaW5nO1xuICBhbmltYXRpb246IGJvb2xlYW47XG4gIHR5cGVhaGVhZFJlZjogVHlwZWFoZWFkRGlyZWN0aXZlO1xuXG4gIGNvbnN0cnVjdG9yKG9wdGlvbnM6IFR5cGVhaGVhZE9wdGlvbnMpIHtcbiAgICBPYmplY3QuYXNzaWduKHRoaXMsIG9wdGlvbnMpO1xuICB9XG59XG4iXX0=

package/typeahead/esm5/typeahead-utils.js

@@ -0,0 +1,94 @@
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes} checked by tsc
+ */
+import * as tslib_1 from "tslib";
+import { latinMap } from './latin-map';
+/**
+ * @param {?} str
+ * @return {?}
+ */
+export function latinize(str) {
+    if (!str) {
+        return '';
+    }
+    return str.replace(/[^A-Za-z0-9\[\] ]/g, function (a) {
+        return latinMap[a] || a;
+    });
+}
+/**
+ * @param {?} queryToEscape
+ * @return {?}
+ */
+export function escapeRegexp(queryToEscape) {
+    // Regex: capture the whole query string and replace it with the string
+    // that will be used to match the results, for example if the capture is
+    // 'a' the result will be \a
+    return queryToEscape.replace(/([.?*+^$[\]\\(){}|-])/g, '\\$1');
+}
+/**
+ * @param {?} str
+ * @param {?=} wordRegexDelimiters
+ * @param {?=} phraseRegexDelimiters
+ * @return {?}
+ */
+export function tokenize(str, wordRegexDelimiters, phraseRegexDelimiters) {
+    if (wordRegexDelimiters === void 0) { wordRegexDelimiters = ' '; }
+    if (phraseRegexDelimiters === void 0) { phraseRegexDelimiters = ''; }
+    /* tslint:enable */
+    var /** @type {?} */ regexStr = "(?:[" + phraseRegexDelimiters + "])([^" + phraseRegexDelimiters + "]+)" +
+        ("(?:[" + phraseRegexDelimiters + "])|([^" + wordRegexDelimiters + "]+)");
+    var /** @type {?} */ preTokenized = str.split(new RegExp(regexStr, 'g'));
+    var /** @type {?} */ result = [];
+    var /** @type {?} */ preTokenizedLength = preTokenized.length;
+    var /** @type {?} */ token;
+    var /** @type {?} */ replacePhraseDelimiters = new RegExp("[" + phraseRegexDelimiters + "]+", 'g');
+    for (var /** @type {?} */ i = 0; i < preTokenizedLength; i += 1) {
+        token = preTokenized[i];
+        if (token && token.length && token !== wordRegexDelimiters) {
+            result.push(token.replace(replacePhraseDelimiters, ''));
+        }
+    }
+    return result;
+}
+/**
+ * @param {?} object
+ * @param {?} option
+ * @return {?}
+ */
+export function getValueFromObject(object, option) {
+    if (!option || typeof object !== 'object') {
+        return object.toString();
+    }
+    if (option.endsWith('()')) {
+        var /** @type {?} */ functionName = option.slice(0, option.length - 2);
+        return object[functionName]().toString();
+    }
+    var /** @type {?} */ properties = option
+        .replace(/\[(\w+)\]/g, '.$1')
+        .replace(/^\./, '');
+    var /** @type {?} */ propertiesArray = properties.split('.');
+    try {
+        for (var propertiesArray_1 = tslib_1.__values(propertiesArray), propertiesArray_1_1 = propertiesArray_1.next(); !propertiesArray_1_1.done; propertiesArray_1_1 = propertiesArray_1.next()) {
+            var property = propertiesArray_1_1.value;
+            if (property in object) {
+                // tslint:disable-next-line
+                object = object[property];
+            }
+        }
+    }
+    catch (e_1_1) { e_1 = { error: e_1_1 }; }
+    finally {
+        try {
+            if (propertiesArray_1_1 && !propertiesArray_1_1.done && (_a = propertiesArray_1.return)) _a.call(propertiesArray_1);
+        }
+        finally { if (e_1) throw e_1.error; }
+    }
+    if (!object) {
+        return '';
+    }
+    return object.toString();
+    var e_1, _a;
+}
+
+//# sourceMappingURL=data:application/json;base64,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