ngx-bootstrap 3.0.1 → 3.1.4

package/tabs/esm5/ng-transclude.directive.js

@@ -0,0 +1,65 @@
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes} checked by tsc
+ */
+import { Directive, Input, TemplateRef, ViewContainerRef } from '@angular/core';
+var NgTranscludeDirective = /** @class */ (function () {
+    function NgTranscludeDirective(viewRef) {
+        this.viewRef = viewRef;
+    }
+    Object.defineProperty(NgTranscludeDirective.prototype, "ngTransclude", {
+        /* tslint:disable-next-line:no-any */
+        get: /**
+         * @return {?}
+         */
+        function () {
+            return this._ngTransclude;
+        },
+        set: /**
+         * @param {?} templateRef
+         * @return {?}
+         */
+        /* tslint:disable-next-line:no-any */
+        function (templateRef) {
+            this._ngTransclude = templateRef;
+            if (templateRef) {
+                this.viewRef.createEmbeddedView(templateRef);
+            }
+        },
+        enumerable: true,
+        configurable: true
+    });
+    NgTranscludeDirective.decorators = [
+        { type: Directive, args: [{
+                    selector: '[ngTransclude]'
+                },] }
+    ];
+    /** @nocollapse */
+    NgTranscludeDirective.ctorParameters = function () { return [
+        { type: ViewContainerRef, },
+    ]; };
+    NgTranscludeDirective.propDecorators = {
+        "ngTransclude": [{ type: Input },],
+    };
+    return NgTranscludeDirective;
+}());
+export { NgTranscludeDirective };
+function NgTranscludeDirective_tsickle_Closure_declarations() {
+    /** @type {!Array<{type: !Function, args: (undefined|!Array<?>)}>} */
+    NgTranscludeDirective.decorators;
+    /**
+     * @nocollapse
+     * @type {function(): !Array<(null|{type: ?, decorators: (undefined|!Array<{type: !Function, args: (undefined|!Array<?>)}>)})>}
+     */
+    NgTranscludeDirective.ctorParameters;
+    /** @type {!Object<string,!Array<{type: !Function, args: (undefined|!Array<?>)}>>} */
+    NgTranscludeDirective.propDecorators;
+    /** @type {?} */
+    NgTranscludeDirective.prototype.viewRef;
+    /** @type {?} */
+    NgTranscludeDirective.prototype._viewRef;
+    /** @type {?} */
+    NgTranscludeDirective.prototype._ngTransclude;
+}
+
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibmctdHJhbnNjbHVkZS5kaXJlY3RpdmUuanMiLCJzb3VyY2VSb290Ijoibmc6Ly9uZ3gtYm9vdHN0cmFwL3RhYnMvIiwic291cmNlcyI6WyJuZy10cmFuc2NsdWRlLmRpcmVjdGl2ZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7O0FBQUEsT0FBTyxFQUFFLFNBQVMsRUFBRSxLQUFLLEVBQUUsV0FBVyxFQUFFLGdCQUFnQixFQUFFLE1BQU0sZUFBZSxDQUFDOztJQTBCOUUsK0JBQVksT0FBeUI7UUFDbkMsSUFBSSxDQUFDLE9BQU8sR0FBRyxPQUFPLENBQUM7S0FDeEI7MEJBZEcsK0NBQVk7UUFPaEIscUNBQXFDOzs7O1FBQ3JDO1lBQ0UsTUFBTSxDQUFDLElBQUksQ0FBQyxhQUFhLENBQUM7U0FDM0I7Ozs7OztrQkFWZ0IsV0FBNkI7WUFDNUMsSUFBSSxDQUFDLGFBQWEsR0FBRyxXQUFXLENBQUM7WUFDakMsRUFBRSxDQUFDLENBQUMsV0FBVyxDQUFDLENBQUMsQ0FBQztnQkFDaEIsSUFBSSxDQUFDLE9BQU8sQ0FBQyxrQkFBa0IsQ0FBQyxXQUFXLENBQUMsQ0FBQzthQUM5Qzs7Ozs7O2dCQWhCSixTQUFTLFNBQUM7b0JBQ1QsUUFBUSxFQUFFLGdCQUFnQjtpQkFDM0I7Ozs7Z0JBSnVDLGdCQUFnQjs7O2lDQVlyRCxLQUFLOztnQ0FaUjs7U0FLYSxxQkFBcUIiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBEaXJlY3RpdmUsIElucHV0LCBUZW1wbGF0ZVJlZiwgVmlld0NvbnRhaW5lclJlZiB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuXG5ARGlyZWN0aXZlKHtcbiAgc2VsZWN0b3I6ICdbbmdUcmFuc2NsdWRlXSdcbn0pXG5leHBvcnQgY2xhc3MgTmdUcmFuc2NsdWRlRGlyZWN0aXZlIHtcbiAgdmlld1JlZjogVmlld0NvbnRhaW5lclJlZjtcblxuICBwcm90ZWN0ZWQgX3ZpZXdSZWY6IFZpZXdDb250YWluZXJSZWY7XG4gIC8qIHRzbGludDpkaXNhYmxlLW5leHQtbGluZTpuby1hbnkgKi9cbiAgcHJvdGVjdGVkIF9uZ1RyYW5zY2x1ZGU6IFRlbXBsYXRlUmVmPGFueT47XG5cbiAgQElucHV0KClcbiAgLyogdHNsaW50OmRpc2FibGUtbmV4dC1saW5lOm5vLWFueSAqL1xuICBzZXQgbmdUcmFuc2NsdWRlKHRlbXBsYXRlUmVmOiBUZW1wbGF0ZVJlZjxhbnk+KSB7XG4gICAgdGhpcy5fbmdUcmFuc2NsdWRlID0gdGVtcGxhdGVSZWY7XG4gICAgaWYgKHRlbXBsYXRlUmVmKSB7XG4gICAgICB0aGlzLnZpZXdSZWYuY3JlYXRlRW1iZWRkZWRWaWV3KHRlbXBsYXRlUmVmKTtcbiAgICB9XG4gIH1cblxuICAvKiB0c2xpbnQ6ZGlzYWJsZS1uZXh0LWxpbmU6bm8tYW55ICovXG4gIGdldCBuZ1RyYW5zY2x1ZGUoKTogVGVtcGxhdGVSZWY8YW55PiB7XG4gICAgcmV0dXJuIHRoaXMuX25nVHJhbnNjbHVkZTtcbiAgfVxuXG4gIGNvbnN0cnVjdG9yKHZpZXdSZWY6IFZpZXdDb250YWluZXJSZWYpIHtcbiAgICB0aGlzLnZpZXdSZWYgPSB2aWV3UmVmO1xuICB9XG59XG4iXX0=

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

@@ -0,0 +1,10 @@
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes} checked by tsc
+ */
+/**
+ * Generated bundle index. Do not edit.
+ */
+export { NgTranscludeDirective, TabDirective, TabHeadingDirective, TabsetComponent, TabsetConfig, TabsModule } from './public_api';
+
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibmd4LWJvb3RzdHJhcC10YWJzLmpzIiwic291cmNlUm9vdCI6Im5nOi8vbmd4LWJvb3RzdHJhcC90YWJzLyIsInNvdXJjZXMiOlsibmd4LWJvb3RzdHJhcC10YWJzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7Ozs7QUFJQSxvSEFBYyxjQUFjLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIEdlbmVyYXRlZCBidW5kbGUgaW5kZXguIERvIG5vdCBlZGl0LlxuICovXG5cbmV4cG9ydCAqIGZyb20gJy4vcHVibGljX2FwaSc7XG4iXX0=

package/tabs/esm5/public_api.js

@@ -0,0 +1,12 @@
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes} checked by tsc
+ */
+export { NgTranscludeDirective } from './ng-transclude.directive';
+export { TabDirective } from './tab.directive';
+export { TabHeadingDirective } from './tab-heading.directive';
+export { TabsetComponent } from './tabset.component';
+export { TabsetConfig } from './tabset.config';
+export { TabsModule } from './tabs.module';
+
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljX2FwaS5qcyIsInNvdXJjZVJvb3QiOiJuZzovL25neC1ib290c3RyYXAvdGFicy8iLCJzb3VyY2VzIjpbInB1YmxpY19hcGkudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7OztBQUFBLE9BQU8sRUFBRSxxQkFBcUIsRUFBRSxNQUFNLDJCQUEyQixDQUFDO0FBQ2xFLE9BQU8sRUFBRSxZQUFZLEVBQUUsTUFBTSxpQkFBaUIsQ0FBQztBQUMvQyxPQUFPLEVBQUUsbUJBQW1CLEVBQUUsTUFBTSx5QkFBeUIsQ0FBQztBQUM5RCxPQUFPLEVBQUUsZUFBZSxFQUFFLE1BQU0sb0JBQW9CLENBQUM7QUFDckQsT0FBTyxFQUFFLFlBQVksRUFBRSxNQUFNLGlCQUFpQixDQUFDO0FBQy9DLE9BQU8sRUFBRSxVQUFVLEVBQUUsTUFBTSxlQUFlLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgeyBOZ1RyYW5zY2x1ZGVEaXJlY3RpdmUgfSBmcm9tICcuL25nLXRyYW5zY2x1ZGUuZGlyZWN0aXZlJztcbmV4cG9ydCB7IFRhYkRpcmVjdGl2ZSB9IGZyb20gJy4vdGFiLmRpcmVjdGl2ZSc7XG5leHBvcnQgeyBUYWJIZWFkaW5nRGlyZWN0aXZlIH0gZnJvbSAnLi90YWItaGVhZGluZy5kaXJlY3RpdmUnO1xuZXhwb3J0IHsgVGFic2V0Q29tcG9uZW50IH0gZnJvbSAnLi90YWJzZXQuY29tcG9uZW50JztcbmV4cG9ydCB7IFRhYnNldENvbmZpZyB9IGZyb20gJy4vdGFic2V0LmNvbmZpZyc7XG5leHBvcnQgeyBUYWJzTW9kdWxlIH0gZnJvbSAnLi90YWJzLm1vZHVsZSc7XG4iXX0=

package/tabs/esm5/tab-heading.directive.js

@@ -0,0 +1,38 @@
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes} checked by tsc
+ */
+import { Directive, TemplateRef } from '@angular/core';
+import { TabDirective } from './tab.directive';
+/**
+ * Should be used to mark <ng-template> element as a template for tab heading
+ */
+var TabHeadingDirective = /** @class */ (function () {
+    /* tslint:disable-next-line:no-any */
+    function TabHeadingDirective(templateRef, tab) {
+        tab.headingRef = templateRef;
+    }
+    TabHeadingDirective.decorators = [
+        { type: Directive, args: [{ selector: '[tabHeading]' },] }
+    ];
+    /** @nocollapse */
+    TabHeadingDirective.ctorParameters = function () { return [
+        { type: TemplateRef, },
+        { type: TabDirective, },
+    ]; };
+    return TabHeadingDirective;
+}());
+export { TabHeadingDirective };
+function TabHeadingDirective_tsickle_Closure_declarations() {
+    /** @type {!Array<{type: !Function, args: (undefined|!Array<?>)}>} */
+    TabHeadingDirective.decorators;
+    /**
+     * @nocollapse
+     * @type {function(): !Array<(null|{type: ?, decorators: (undefined|!Array<{type: !Function, args: (undefined|!Array<?>)}>)})>}
+     */
+    TabHeadingDirective.ctorParameters;
+    /** @type {?} */
+    TabHeadingDirective.prototype.templateRef;
+}
+
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidGFiLWhlYWRpbmcuZGlyZWN0aXZlLmpzIiwic291cmNlUm9vdCI6Im5nOi8vbmd4LWJvb3RzdHJhcC90YWJzLyIsInNvdXJjZXMiOlsidGFiLWhlYWRpbmcuZGlyZWN0aXZlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7QUFBQSxPQUFPLEVBQUUsU0FBUyxFQUFFLFdBQVcsRUFBRSxNQUFNLGVBQWUsQ0FBQztBQUV2RCxPQUFPLEVBQUUsWUFBWSxFQUFFLE1BQU0saUJBQWlCLENBQUM7Ozs7O0lBUTdDLHFDQUFxQztJQUNyQyw2QkFBWSxXQUE2QixFQUFFLEdBQWlCO1FBQzFELEdBQUcsQ0FBQyxVQUFVLEdBQUcsV0FBVyxDQUFDO0tBQzlCOztnQkFSRixTQUFTLFNBQUMsRUFBRSxRQUFRLEVBQUUsY0FBYyxFQUFFOzs7O2dCQUxuQixXQUFXO2dCQUV0QixZQUFZOzs4QkFGckI7O1NBTWEsbUJBQW1CIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgRGlyZWN0aXZlLCBUZW1wbGF0ZVJlZiB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuXG5pbXBvcnQgeyBUYWJEaXJlY3RpdmUgfSBmcm9tICcuL3RhYi5kaXJlY3RpdmUnO1xuXG4vKiogU2hvdWxkIGJlIHVzZWQgdG8gbWFyayA8bmctdGVtcGxhdGU+IGVsZW1lbnQgYXMgYSB0ZW1wbGF0ZSBmb3IgdGFiIGhlYWRpbmcgKi9cbkBEaXJlY3RpdmUoeyBzZWxlY3RvcjogJ1t0YWJIZWFkaW5nXScgfSlcbmV4cG9ydCBjbGFzcyBUYWJIZWFkaW5nRGlyZWN0aXZlIHtcbiAgLyogdHNsaW50OmRpc2FibGUtbmV4dC1saW5lOm5vLWFueSAqL1xuICB0ZW1wbGF0ZVJlZjogVGVtcGxhdGVSZWY8YW55PjtcblxuICAvKiB0c2xpbnQ6ZGlzYWJsZS1uZXh0LWxpbmU6bm8tYW55ICovXG4gIGNvbnN0cnVjdG9yKHRlbXBsYXRlUmVmOiBUZW1wbGF0ZVJlZjxhbnk+LCB0YWI6IFRhYkRpcmVjdGl2ZSkge1xuICAgIHRhYi5oZWFkaW5nUmVmID0gdGVtcGxhdGVSZWY7XG4gIH1cbn1cbiJdfQ==

package/tabs/esm5/tab.directive.js

@@ -0,0 +1,194 @@
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes} checked by tsc
+ */
+import { Directive, EventEmitter, HostBinding, Input, Output, ElementRef, Renderer2 } from '@angular/core';
+import { TabsetComponent } from './tabset.component';
+var TabDirective = /** @class */ (function () {
+    function TabDirective(tabset, elementRef, renderer) {
+        this.elementRef = elementRef;
+        this.renderer = renderer;
+        /**
+         * fired when tab became active, $event:Tab equals to selected instance of Tab component
+         */
+        this.select = new EventEmitter();
+        /**
+         * fired when tab became inactive, $event:Tab equals to deselected instance of Tab component
+         */
+        this.deselect = new EventEmitter();
+        /**
+         * fired before tab will be removed, $event:Tab equals to instance of removed tab
+         */
+        this.removed = new EventEmitter();
+        this.addClass = true;
+        this.tabset = tabset;
+        this.tabset.addTab(this);
+    }
+    Object.defineProperty(TabDirective.prototype, "customClass", {
+        get: /**
+         * if set, will be added to the tab's class attribute. Multiple classes are supported.
+         * @return {?}
+         */
+        function () {
+            return this._customClass;
+        },
+        set: /**
+         * @param {?} customClass
+         * @return {?}
+         */
+        function (customClass) {
+            var _this = this;
+            if (this.customClass) {
+                this.customClass.split(' ').forEach(function (cssClass) {
+                    _this.renderer.removeClass(_this.elementRef.nativeElement, cssClass);
+                });
+            }
+            this._customClass = customClass ? customClass.trim() : null;
+            if (this.customClass) {
+                this.customClass.split(' ').forEach(function (cssClass) {
+                    _this.renderer.addClass(_this.elementRef.nativeElement, cssClass);
+                });
+            }
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(TabDirective.prototype, "active", {
+        get: /**
+         * tab active state toggle
+         * @return {?}
+         */
+        function () {
+            return this._active;
+        },
+        set: /**
+         * @param {?} active
+         * @return {?}
+         */
+        function (active) {
+            var _this = this;
+            if (this._active === active) {
+                return;
+            }
+            if ((this.disabled && active) || !active) {
+                if (this._active && !active) {
+                    this.deselect.emit(this);
+                    this._active = active;
+                }
+                return;
+            }
+            this._active = active;
+            this.select.emit(this);
+            this.tabset.tabs.forEach(function (tab) {
+                if (tab !== _this) {
+                    tab.active = false;
+                }
+            });
+        },
+        enumerable: true,
+        configurable: true
+    });
+    /**
+     * @return {?}
+     */
+    TabDirective.prototype.ngOnInit = /**
+     * @return {?}
+     */
+    function () {
+        this.removable = this.removable;
+    };
+    /**
+     * @return {?}
+     */
+    TabDirective.prototype.ngOnDestroy = /**
+     * @return {?}
+     */
+    function () {
+        this.tabset.removeTab(this, { reselect: false, emit: false });
+    };
+    TabDirective.decorators = [
+        { type: Directive, args: [{ selector: 'tab, [tab]' },] }
+    ];
+    /** @nocollapse */
+    TabDirective.ctorParameters = function () { return [
+        { type: TabsetComponent, },
+        { type: ElementRef, },
+        { type: Renderer2, },
+    ]; };
+    TabDirective.propDecorators = {
+        "heading": [{ type: Input },],
+        "id": [{ type: HostBinding, args: ['attr.id',] }, { type: Input },],
+        "disabled": [{ type: Input },],
+        "removable": [{ type: Input },],
+        "customClass": [{ type: Input },],
+        "active": [{ type: HostBinding, args: ['class.active',] }, { type: Input },],
+        "select": [{ type: Output },],
+        "deselect": [{ type: Output },],
+        "removed": [{ type: Output },],
+        "addClass": [{ type: HostBinding, args: ['class.tab-pane',] },],
+    };
+    return TabDirective;
+}());
+export { TabDirective };
+function TabDirective_tsickle_Closure_declarations() {
+    /** @type {!Array<{type: !Function, args: (undefined|!Array<?>)}>} */
+    TabDirective.decorators;
+    /**
+     * @nocollapse
+     * @type {function(): !Array<(null|{type: ?, decorators: (undefined|!Array<{type: !Function, args: (undefined|!Array<?>)}>)})>}
+     */
+    TabDirective.ctorParameters;
+    /** @type {!Object<string,!Array<{type: !Function, args: (undefined|!Array<?>)}>>} */
+    TabDirective.propDecorators;
+    /**
+     * tab header text
+     * @type {?}
+     */
+    TabDirective.prototype.heading;
+    /**
+     * tab id. The same id with suffix '-link' will be added to the corresponding &lt;li&gt; element
+     * @type {?}
+     */
+    TabDirective.prototype.id;
+    /**
+     * if true tab can not be activated
+     * @type {?}
+     */
+    TabDirective.prototype.disabled;
+    /**
+     * if true tab can be removable, additional button will appear
+     * @type {?}
+     */
+    TabDirective.prototype.removable;
+    /**
+     * fired when tab became active, $event:Tab equals to selected instance of Tab component
+     * @type {?}
+     */
+    TabDirective.prototype.select;
+    /**
+     * fired when tab became inactive, $event:Tab equals to deselected instance of Tab component
+     * @type {?}
+     */
+    TabDirective.prototype.deselect;
+    /**
+     * fired before tab will be removed, $event:Tab equals to instance of removed tab
+     * @type {?}
+     */
+    TabDirective.prototype.removed;
+    /** @type {?} */
+    TabDirective.prototype.addClass;
+    /** @type {?} */
+    TabDirective.prototype.headingRef;
+    /** @type {?} */
+    TabDirective.prototype.tabset;
+    /** @type {?} */
+    TabDirective.prototype._active;
+    /** @type {?} */
+    TabDirective.prototype._customClass;
+    /** @type {?} */
+    TabDirective.prototype.elementRef;
+    /** @type {?} */
+    TabDirective.prototype.renderer;
+}
+
+//# sourceMappingURL=data:application/json;base64,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

package/tabs/esm5/tabs.module.js

@@ -0,0 +1,57 @@
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes} checked by tsc
+ */
+import { CommonModule } from '@angular/common';
+import { NgModule } from '@angular/core';
+import { NgTranscludeDirective } from './ng-transclude.directive';
+import { TabHeadingDirective } from './tab-heading.directive';
+import { TabDirective } from './tab.directive';
+import { TabsetComponent } from './tabset.component';
+import { TabsetConfig } from './tabset.config';
+var TabsModule = /** @class */ (function () {
+    function TabsModule() {
+    }
+    /**
+     * @return {?}
+     */
+    TabsModule.forRoot = /**
+     * @return {?}
+     */
+    function () {
+        return {
+            ngModule: TabsModule,
+            providers: [TabsetConfig]
+        };
+    };
+    TabsModule.decorators = [
+        { type: NgModule, args: [{
+                    imports: [CommonModule],
+                    declarations: [
+                        NgTranscludeDirective,
+                        TabDirective,
+                        TabsetComponent,
+                        TabHeadingDirective
+                    ],
+                    exports: [
+                        TabDirective,
+                        TabsetComponent,
+                        TabHeadingDirective,
+                        NgTranscludeDirective
+                    ]
+                },] }
+    ];
+    return TabsModule;
+}());
+export { TabsModule };
+function TabsModule_tsickle_Closure_declarations() {
+    /** @type {!Array<{type: !Function, args: (undefined|!Array<?>)}>} */
+    TabsModule.decorators;
+    /**
+     * @nocollapse
+     * @type {function(): !Array<(null|{type: ?, decorators: (undefined|!Array<{type: !Function, args: (undefined|!Array<?>)}>)})>}
+     */
+    TabsModule.ctorParameters;
+}
+
+//# sourceMappingURL=data:application/json;base64,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

package/tabs/esm5/tabset.component.js

@@ -0,0 +1,231 @@
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes} checked by tsc
+ */
+import { Component, HostBinding, Input, Renderer2 } from '@angular/core';
+import { TabsetConfig } from './tabset.config';
+var TabsetComponent = /** @class */ (function () {
+    function TabsetComponent(config, renderer) {
+        this.renderer = renderer;
+        this.clazz = true;
+        this.tabs = [];
+        this.classMap = {};
+        Object.assign(this, config);
+    }
+    Object.defineProperty(TabsetComponent.prototype, "vertical", {
+        get: /**
+         * if true tabs will be placed vertically
+         * @return {?}
+         */
+        function () {
+            return this._vertical;
+        },
+        set: /**
+         * @param {?} value
+         * @return {?}
+         */
+        function (value) {
+            this._vertical = value;
+            this.setClassMap();
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(TabsetComponent.prototype, "justified", {
+        get: /**
+         * if true tabs fill the container and have a consistent width
+         * @return {?}
+         */
+        function () {
+            return this._justified;
+        },
+        set: /**
+         * @param {?} value
+         * @return {?}
+         */
+        function (value) {
+            this._justified = value;
+            this.setClassMap();
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(TabsetComponent.prototype, "type", {
+        get: /**
+         * navigation context class: 'tabs' or 'pills'
+         * @return {?}
+         */
+        function () {
+            return this._type;
+        },
+        set: /**
+         * @param {?} value
+         * @return {?}
+         */
+        function (value) {
+            this._type = value;
+            this.setClassMap();
+        },
+        enumerable: true,
+        configurable: true
+    });
+    /**
+     * @return {?}
+     */
+    TabsetComponent.prototype.ngOnDestroy = /**
+     * @return {?}
+     */
+    function () {
+        this.isDestroyed = true;
+    };
+    /**
+     * @param {?} tab
+     * @return {?}
+     */
+    TabsetComponent.prototype.addTab = /**
+     * @param {?} tab
+     * @return {?}
+     */
+    function (tab) {
+        this.tabs.push(tab);
+        tab.active = this.tabs.length === 1 && typeof tab.active === 'undefined';
+    };
+    /**
+     * @param {?} tab
+     * @param {?=} options
+     * @return {?}
+     */
+    TabsetComponent.prototype.removeTab = /**
+     * @param {?} tab
+     * @param {?=} options
+     * @return {?}
+     */
+    function (tab, options) {
+        if (options === void 0) { options = { reselect: true, emit: true }; }
+        var /** @type {?} */ index = this.tabs.indexOf(tab);
+        if (index === -1 || this.isDestroyed) {
+            return;
+        }
+        // Select a new tab if the tab to be removed is selected and not destroyed
+        if (options.reselect && tab.active && this.hasAvailableTabs(index)) {
+            var /** @type {?} */ newActiveIndex = this.getClosestTabIndex(index);
+            this.tabs[newActiveIndex].active = true;
+        }
+        if (options.emit) {
+            tab.removed.emit(tab);
+        }
+        this.tabs.splice(index, 1);
+        if (tab.elementRef.nativeElement.parentNode) {
+            this.renderer.removeChild(tab.elementRef.nativeElement.parentNode, tab.elementRef.nativeElement);
+        }
+    };
+    /**
+     * @param {?} index
+     * @return {?}
+     */
+    TabsetComponent.prototype.getClosestTabIndex = /**
+     * @param {?} index
+     * @return {?}
+     */
+    function (index) {
+        var /** @type {?} */ tabsLength = this.tabs.length;
+        if (!tabsLength) {
+            return -1;
+        }
+        for (var /** @type {?} */ step = 1; step <= tabsLength; step += 1) {
+            var /** @type {?} */ prevIndex = index - step;
+            var /** @type {?} */ nextIndex = index + step;
+            if (this.tabs[prevIndex] && !this.tabs[prevIndex].disabled) {
+                return prevIndex;
+            }
+            if (this.tabs[nextIndex] && !this.tabs[nextIndex].disabled) {
+                return nextIndex;
+            }
+        }
+        return -1;
+    };
+    /**
+     * @param {?} index
+     * @return {?}
+     */
+    TabsetComponent.prototype.hasAvailableTabs = /**
+     * @param {?} index
+     * @return {?}
+     */
+    function (index) {
+        var /** @type {?} */ tabsLength = this.tabs.length;
+        if (!tabsLength) {
+            return false;
+        }
+        for (var /** @type {?} */ i = 0; i < tabsLength; i += 1) {
+            if (!this.tabs[i].disabled && i !== index) {
+                return true;
+            }
+        }
+        return false;
+    };
+    /**
+     * @return {?}
+     */
+    TabsetComponent.prototype.setClassMap = /**
+     * @return {?}
+     */
+    function () {
+        this.classMap = (_a = {
+                'nav-stacked': this.vertical,
+                'flex-column': this.vertical,
+                'nav-justified': this.justified
+            },
+            _a["nav-" + this.type] = true,
+            _a);
+        var _a;
+    };
+    TabsetComponent.decorators = [
+        { type: Component, args: [{
+                    selector: 'tabset',
+                    template: "<ul class=\"nav\" [ngClass]=\"classMap\" (click)=\"$event.preventDefault()\">\n  <li *ngFor=\"let tabz of tabs\" [ngClass]=\"['nav-item', tabz.customClass || '']\"\n      [class.active]=\"tabz.active\" [class.disabled]=\"tabz.disabled\">\n    <a href=\"javascript:void(0);\" class=\"nav-link\"\n       [attr.id]=\"tabz.id ? tabz.id + '-link' : ''\"\n       [class.active]=\"tabz.active\" [class.disabled]=\"tabz.disabled\"\n       (click)=\"tabz.active = true\">\n      <span [ngTransclude]=\"tabz.headingRef\">{{ tabz.heading }}</span>\n      <span *ngIf=\"tabz.removable\" (click)=\"$event.preventDefault(); removeTab(tabz);\" class=\"bs-remove-tab\"> &#10060;</span>\n    </a>\n  </li>\n</ul>\n<div class=\"tab-content\">\n  <ng-content></ng-content>\n</div>\n"
+                }] }
+    ];
+    /** @nocollapse */
+    TabsetComponent.ctorParameters = function () { return [
+        { type: TabsetConfig, },
+        { type: Renderer2, },
+    ]; };
+    TabsetComponent.propDecorators = {
+        "vertical": [{ type: Input },],
+        "justified": [{ type: Input },],
+        "type": [{ type: Input },],
+        "clazz": [{ type: HostBinding, args: ['class.tab-container',] },],
+    };
+    return TabsetComponent;
+}());
+export { TabsetComponent };
+function TabsetComponent_tsickle_Closure_declarations() {
+    /** @type {!Array<{type: !Function, args: (undefined|!Array<?>)}>} */
+    TabsetComponent.decorators;
+    /**
+     * @nocollapse
+     * @type {function(): !Array<(null|{type: ?, decorators: (undefined|!Array<{type: !Function, args: (undefined|!Array<?>)}>)})>}
+     */
+    TabsetComponent.ctorParameters;
+    /** @type {!Object<string,!Array<{type: !Function, args: (undefined|!Array<?>)}>>} */
+    TabsetComponent.propDecorators;
+    /** @type {?} */
+    TabsetComponent.prototype.clazz;
+    /** @type {?} */
+    TabsetComponent.prototype.tabs;
+    /** @type {?} */
+    TabsetComponent.prototype.classMap;
+    /** @type {?} */
+    TabsetComponent.prototype.isDestroyed;
+    /** @type {?} */
+    TabsetComponent.prototype._vertical;
+    /** @type {?} */
+    TabsetComponent.prototype._justified;
+    /** @type {?} */
+    TabsetComponent.prototype._type;
+    /** @type {?} */
+    TabsetComponent.prototype.renderer;
+}
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"tabset.component.js","sourceRoot":"ng://ngx-bootstrap/tabs/","sources":["tabset.component.ts"],"names":[],"mappings":"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","sourcesContent":["import { Component, HostBinding, Input, OnDestroy, Renderer2 } from '@angular/core';\n\nimport { TabDirective } from './tab.directive';\nimport { TabsetConfig } from './tabset.config';\n// todo: add active event to tab\n// todo: fix? mixing static and dynamic tabs position tabs in order of creation\n@Component({\n  selector: 'tabset',\n  templateUrl: './tabset.component.html'\n})\nexport class TabsetComponent implements OnDestroy {\n  /** if true tabs will be placed vertically */\n  @Input()\n  get vertical(): boolean {\n    return this._vertical;\n  }\n  set vertical(value: boolean) {\n    this._vertical = value;\n    this.setClassMap();\n  }\n\n  /** if true tabs fill the container and have a consistent width */\n  @Input()\n  get justified(): boolean {\n    return this._justified;\n  }\n  set justified(value: boolean) {\n    this._justified = value;\n    this.setClassMap();\n  }\n\n  /** navigation context class: 'tabs' or 'pills' */\n  @Input()\n  get type(): string {\n    return this._type;\n  }\n  set type(value: string) {\n    this._type = value;\n    this.setClassMap();\n  }\n\n  @HostBinding('class.tab-container') clazz = true;\n\n  tabs: TabDirective[] = [];\n  classMap: { [key: string]: boolean } = {};\n\n  protected isDestroyed: boolean;\n  protected _vertical: boolean;\n  protected _justified: boolean;\n  protected _type: string;\n\n  constructor(config: TabsetConfig, private renderer: Renderer2) {\n    Object.assign(this, config);\n  }\n\n  ngOnDestroy(): void {\n    this.isDestroyed = true;\n  }\n\n  addTab(tab: TabDirective): void {\n    this.tabs.push(tab);\n    tab.active = this.tabs.length === 1 && typeof tab.active === 'undefined';\n  }\n\n  removeTab(\n    tab: TabDirective,\n    options = { reselect: true, emit: true }\n  ): void {\n    const index = this.tabs.indexOf(tab);\n    if (index === -1 || this.isDestroyed) {\n      return;\n    }\n    // Select a new tab if the tab to be removed is selected and not destroyed\n    if (options.reselect && tab.active && this.hasAvailableTabs(index)) {\n      const newActiveIndex = this.getClosestTabIndex(index);\n      this.tabs[newActiveIndex].active = true;\n    }\n    if (options.emit) {\n      tab.removed.emit(tab);\n    }\n    this.tabs.splice(index, 1);\n    if (tab.elementRef.nativeElement.parentNode) {\n      this.renderer.removeChild(\n        tab.elementRef.nativeElement.parentNode,\n        tab.elementRef.nativeElement\n      );\n    }\n  }\n\n  protected getClosestTabIndex(index: number): number {\n    const tabsLength = this.tabs.length;\n    if (!tabsLength) {\n      return -1;\n    }\n\n    for (let step = 1; step <= tabsLength; step += 1) {\n      const prevIndex = index - step;\n      const nextIndex = index + step;\n      if (this.tabs[prevIndex] && !this.tabs[prevIndex].disabled) {\n        return prevIndex;\n      }\n      if (this.tabs[nextIndex] && !this.tabs[nextIndex].disabled) {\n        return nextIndex;\n      }\n    }\n\n    return -1;\n  }\n\n  protected hasAvailableTabs(index: number): boolean {\n    const tabsLength = this.tabs.length;\n    if (!tabsLength) {\n      return false;\n    }\n\n    for (let i = 0; i < tabsLength; i += 1) {\n      if (!this.tabs[i].disabled && i !== index) {\n        return true;\n      }\n    }\n\n    return false;\n  }\n\n  protected setClassMap(): void {\n    this.classMap = {\n      'nav-stacked': this.vertical,\n      'flex-column': this.vertical,\n      'nav-justified': this.justified,\n      [`nav-${this.type}`]: true\n    };\n  }\n}\n"]}