@skyux/tabs 4.6.9

package/esm2015/modules/tabs/tabs.module.js

@@ -0,0 +1,41 @@
+import { __decorate } from "tslib";
+import { CommonModule } from '@angular/common';
+import { NgModule } from '@angular/core';
+import { RouterModule } from '@angular/router';
+import { SkyI18nModule } from '@skyux/i18n';
+import { SkyIconModule } from '@skyux/indicators';
+import { SkyDropdownModule } from '@skyux/popovers';
+import { SkyThemeModule } from '@skyux/theme';
+import { SkyTabsResourcesModule } from '../shared/tabs-resources.module';
+import { SkyTabButtonComponent } from './tab-button.component';
+import { SkyTabComponent } from './tab.component';
+import { SkyTabsetNavButtonComponent } from './tabset-nav-button.component';
+import { SkyTabsetComponent } from './tabset.component';
+let SkyTabsModule = class SkyTabsModule {
+};
+SkyTabsModule = __decorate([
+    NgModule({
+        declarations: [
+            SkyTabButtonComponent,
+            SkyTabComponent,
+            SkyTabsetComponent,
+            SkyTabsetNavButtonComponent
+        ],
+        imports: [
+            CommonModule,
+            RouterModule,
+            SkyDropdownModule,
+            SkyI18nModule,
+            SkyIconModule,
+            SkyTabsResourcesModule,
+            SkyThemeModule
+        ],
+        exports: [
+            SkyTabComponent,
+            SkyTabsetComponent,
+            SkyTabsetNavButtonComponent
+        ]
+    })
+], SkyTabsModule);
+export { SkyTabsModule };
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/modules/tabs/tabset-active-tab-unregistered-args.js

@@ -0,0 +1 @@
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidGFic2V0LWFjdGl2ZS10YWItdW5yZWdpc3RlcmVkLWFyZ3MuanMiLCJzb3VyY2VSb290Ijoibmc6Ly9Ac2t5dXgvdGFicy8iLCJzb3VyY2VzIjpbIm1vZHVsZXMvdGFicy90YWJzZXQtYWN0aXZlLXRhYi11bnJlZ2lzdGVyZWQtYXJncy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBUaGUgYXJndW1lbnRzIGZvciB0aGUgdGFic2V0IHNlcnZpY2UncyBgYWN0aXZlVGFiVW5yZWdpc3RlcmVkYCBldmVudC5cbiAqIEBpbnRlcm5hbFxuICovXG5leHBvcnQgaW50ZXJmYWNlIFNreVRhYnNldEFjdGl2ZVRhYlVucmVnaXN0ZXJlZEFyZ3Mge1xuXG4gIC8qKlxuICAgKiBUaGUgYXJyYXkgaW5kZXggb2YgdGhlIGFjdGl2ZSB0YWIsIHdoZW4gaXQgaGFzIGJlZW4gdW5yZWdpc3RlcmVkLlxuICAgKi9cbiAgYXJyYXlJbmRleDogbnVtYmVyO1xuXG59XG4iXX0=

package/esm2015/modules/tabs/tabset-adapter.service.js

@@ -0,0 +1,53 @@
+import { __decorate } from "tslib";
+import { Injectable } from '@angular/core';
+import { BehaviorSubject } from 'rxjs';
+/**
+ * @internal
+ */
+let SkyTabsetAdapterService = class SkyTabsetAdapterService {
+    constructor() {
+        this._overflowChange = new BehaviorSubject(false);
+    }
+    get overflowChange() {
+        return this._overflowChange.asObservable();
+    }
+    registerTabset(tabsetRef) {
+        this.tabsetRef = tabsetRef;
+        this.tabsOffsetLeft = this.getTabsOffsetLeft(tabsetRef.nativeElement);
+    }
+    /**
+     * Detects if the tab buttons are wider than the tabset container.
+     */
+    detectOverflow() {
+        const nativeElement = this.tabsetRef.nativeElement;
+        const tabsetRect = nativeElement
+            .querySelector('.sky-tabset')
+            .getBoundingClientRect();
+        const tabButtonsRect = nativeElement
+            .querySelector('.sky-tabset-tabs')
+            .getBoundingClientRect();
+        const tabExtraButtonsRect = nativeElement
+            .querySelector('.sky-tabset-btns')
+            .getBoundingClientRect();
+        const tabButtonsWidth = tabButtonsRect.width + tabExtraButtonsRect.width + this.tabsOffsetLeft;
+        const newOverflow = (tabButtonsWidth > tabsetRect.width);
+        if (this.currentOverflow !== newOverflow) {
+            this.currentOverflow = newOverflow;
+            this._overflowChange.next(this.currentOverflow);
+        }
+    }
+    /**
+     * Returns the number of pixels to the left of the first tab.
+     */
+    getTabsOffsetLeft(tabsetEl) {
+        const tabsetRect = tabsetEl.getBoundingClientRect();
+        // The dropdown element is the first "tab" and always exists in the DOM, even when hidden.
+        const firstTabRect = tabsetEl.querySelector('.sky-tabset-dropdown').getBoundingClientRect();
+        return firstTabRect.left - tabsetRect.left;
+    }
+};
+SkyTabsetAdapterService = __decorate([
+    Injectable()
+], SkyTabsetAdapterService);
+export { SkyTabsetAdapterService };
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/modules/tabs/tabset-buttons-display-mode.js

@@ -0,0 +1 @@
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidGFic2V0LWJ1dHRvbnMtZGlzcGxheS1tb2RlLmpzIiwic291cmNlUm9vdCI6Im5nOi8vQHNreXV4L3RhYnMvIiwic291cmNlcyI6WyJtb2R1bGVzL3RhYnMvdGFic2V0LWJ1dHRvbnMtZGlzcGxheS1tb2RlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiIiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgdHlwZSBTa3lUYWJzZXRCdXR0b25zRGlzcGxheU1vZGUgPSAnZHJvcGRvd24nIHwgJ3RhYnMnO1xuIl19

package/esm2015/modules/tabs/tabset-nav-button.component.js

@@ -0,0 +1,122 @@
+import { __decorate } from "tslib";
+import { AfterViewInit, ChangeDetectorRef, Component, Input } from '@angular/core';
+import { SkyLibResourcesService } from '@skyux/i18n';
+import { forkJoin } from 'rxjs';
+import { take } from 'rxjs/operators';
+const buttonTypeNext = 'next';
+const buttonTypePrevious = 'previous';
+/**
+ * @internal
+ */
+let SkyTabsetNavButtonComponent = class SkyTabsetNavButtonComponent {
+    constructor(resourceService, changeDetector) {
+        this.resourceService = resourceService;
+        this.changeDetector = changeDetector;
+    }
+    set buttonText(value) {
+        this._buttonText = value;
+    }
+    get buttonText() {
+        if (this._buttonText) {
+            return this._buttonText;
+        }
+        switch (this.buttonType) {
+            case buttonTypePrevious:
+                return this.previousButtonText;
+            case buttonTypeNext:
+                return this.nextButtonText;
+            /* istanbul ignore next */
+            default:
+                return '';
+        }
+    }
+    get disabled() {
+        let tabToSelect;
+        switch (this.buttonType) {
+            case buttonTypePrevious:
+                tabToSelect = this.previousTab;
+                break;
+            case buttonTypeNext:
+                tabToSelect = this.nextTab;
+                break;
+            /* istanbul ignore next */
+            default:
+                break;
+        }
+        return !tabToSelect || tabToSelect.disabled;
+    }
+    get selectedTab() {
+        let selectedTab;
+        if (this.tabset && this.tabset.tabs) {
+            selectedTab = this.tabset.tabs.find((tab) => tab.tabIndex === this.tabset.lastActiveTabIndex);
+        }
+        return selectedTab;
+    }
+    get nextTab() {
+        let selectedTab = this.selectedTab;
+        if (selectedTab) {
+            let tabs = this.tabset.tabs.toArray();
+            return tabs[tabs.indexOf(selectedTab) + 1];
+        }
+        return undefined;
+    }
+    get previousTab() {
+        let selectedTab = this.selectedTab;
+        if (selectedTab) {
+            let tabs = this.tabset.tabs.toArray();
+            return tabs[tabs.indexOf(selectedTab) - 1];
+        }
+        return undefined;
+    }
+    ngAfterViewInit() {
+        forkJoin([
+            this.resourceService.getString('skyux_tabs_navigator_previous'),
+            this.resourceService.getString('skyux_tabs_navigator_next')
+        ])
+            .pipe(take(1))
+            .subscribe(resources => {
+            this.previousButtonText = resources[0];
+            this.nextButtonText = resources[1];
+            this.changeDetector.detectChanges();
+        });
+    }
+    buttonClick() {
+        let tabToSelect;
+        switch (this.buttonType) {
+            case buttonTypePrevious:
+                tabToSelect = this.previousTab;
+                break;
+            case buttonTypeNext:
+                tabToSelect = this.nextTab;
+                break;
+            /* istanbul ignore next */
+            default:
+                break;
+        }
+        /* istanbul ignore else */
+        if (tabToSelect && !tabToSelect.disabled) {
+            this.tabset.active = tabToSelect.tabIndex;
+        }
+    }
+};
+SkyTabsetNavButtonComponent.ctorParameters = () => [
+    { type: SkyLibResourcesService },
+    { type: ChangeDetectorRef }
+];
+__decorate([
+    Input()
+], SkyTabsetNavButtonComponent.prototype, "tabset", void 0);
+__decorate([
+    Input()
+], SkyTabsetNavButtonComponent.prototype, "buttonType", void 0);
+__decorate([
+    Input()
+], SkyTabsetNavButtonComponent.prototype, "buttonText", null);
+SkyTabsetNavButtonComponent = __decorate([
+    Component({
+        selector: 'sky-tabset-nav-button',
+        template: "<button\n  class=\"sky-btn sky-btn-default\"\n  type=\"button\"\n  [disabled]=\"disabled\"\n  (click)=\"buttonClick()\"\n>\n  {{ buttonText }}\n</button>\n"
+    })
+], SkyTabsetNavButtonComponent);
+export { SkyTabsetNavButtonComponent };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"tabset-nav-button.component.js","sourceRoot":"ng://@skyux/tabs/","sources":["modules/tabs/tabset-nav-button.component.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  AfterViewInit,\n  ChangeDetectorRef,\n  Component,\n  Input\n} from '@angular/core';\n\nimport {\n  SkyLibResourcesService\n} from '@skyux/i18n';\n\nimport {\n  forkJoin\n} from 'rxjs';\n\nimport {\n  take\n} from 'rxjs/operators';\n\nimport {\n  SkyTabsetComponent\n} from './tabset.component';\n\nimport {\n  SkyTabComponent\n} from './tab.component';\n\nconst buttonTypeNext = 'next';\n\nconst buttonTypePrevious = 'previous';\n\n/**\n * @internal\n */\n@Component({\n  selector: 'sky-tabset-nav-button',\n  templateUrl: './tabset-nav-button.component.html'\n})\nexport class SkyTabsetNavButtonComponent implements AfterViewInit {\n\n  @Input()\n  public tabset: SkyTabsetComponent;\n\n  @Input()\n  public buttonType: string;\n\n  @Input()\n  public set buttonText(value: string) {\n    this._buttonText = value;\n  }\n\n  public get buttonText(): string {\n    if (this._buttonText) {\n      return this._buttonText;\n    }\n\n    switch (this.buttonType) {\n      case buttonTypePrevious:\n        return this.previousButtonText;\n      case buttonTypeNext:\n        return this.nextButtonText;\n      /* istanbul ignore next */\n      default:\n        return '';\n    }\n  }\n\n  public get disabled(): boolean {\n    let tabToSelect: SkyTabComponent;\n\n    switch (this.buttonType) {\n      case buttonTypePrevious:\n        tabToSelect = this.previousTab;\n        break;\n      case buttonTypeNext:\n        tabToSelect = this.nextTab;\n        break;\n      /* istanbul ignore next */\n      default:\n        break;\n    }\n\n    return !tabToSelect || tabToSelect.disabled;\n  }\n\n  private get selectedTab(): SkyTabComponent {\n    let selectedTab: SkyTabComponent;\n\n    if (this.tabset && this.tabset.tabs) {\n      selectedTab = this.tabset.tabs.find((tab) => tab.tabIndex === this.tabset.lastActiveTabIndex);\n    }\n\n    return selectedTab;\n  }\n\n  private get nextTab(): SkyTabComponent {\n    let selectedTab = this.selectedTab;\n\n    if (selectedTab) {\n      let tabs = this.tabset.tabs.toArray();\n      return tabs[tabs.indexOf(selectedTab) + 1];\n    }\n\n    return undefined;\n  }\n\n  private get previousTab(): SkyTabComponent {\n    let selectedTab = this.selectedTab;\n\n    if (selectedTab) {\n      let tabs = this.tabset.tabs.toArray();\n      return tabs[tabs.indexOf(selectedTab) - 1];\n    }\n\n    return undefined;\n  }\n\n  private _buttonText: string;\n  private previousButtonText: string;\n  private nextButtonText: string;\n\n  constructor(private resourceService: SkyLibResourcesService, private changeDetector: ChangeDetectorRef) { }\n\n  public ngAfterViewInit() {\n    forkJoin([\n      this.resourceService.getString('skyux_tabs_navigator_previous'),\n      this.resourceService.getString('skyux_tabs_navigator_next')\n    ])\n      .pipe(take(1))\n      .subscribe(resources => {\n        this.previousButtonText = resources[0];\n        this.nextButtonText = resources[1];\n        this.changeDetector.detectChanges();\n      });\n  }\n\n  public buttonClick() {\n    let tabToSelect: SkyTabComponent;\n\n    switch (this.buttonType) {\n      case buttonTypePrevious:\n        tabToSelect = this.previousTab;\n        break;\n      case buttonTypeNext:\n        tabToSelect = this.nextTab;\n        break;\n      /* istanbul ignore next */\n      default:\n        break;\n    }\n\n    /* istanbul ignore else */\n    if (tabToSelect && !tabToSelect.disabled) {\n      this.tabset.active = tabToSelect.tabIndex;\n    }\n  }\n}\n"]}

package/esm2015/modules/tabs/tabset-permalink.service.js

@@ -0,0 +1,123 @@
+import { __decorate } from "tslib";
+import { Location } from '@angular/common';
+import { Injectable } from '@angular/core';
+import { ActivatedRoute, Router } from '@angular/router';
+import { Subject } from 'rxjs';
+/**
+ * @internal
+ */
+let SkyTabsetPermalinkService = class SkyTabsetPermalinkService {
+    constructor(activatedRoute, location, router) {
+        this.activatedRoute = activatedRoute;
+        this.location = location;
+        this.router = router;
+        this._popStateChange = new Subject();
+    }
+    get popStateChange() {
+        return this._popStateChange.asObservable();
+    }
+    ngOnDestroy() {
+        if (this.subscription) {
+            this.subscription.unsubscribe();
+        }
+    }
+    init() {
+        this.subscription = this.location.subscribe(() => {
+            this._popStateChange.next();
+        });
+    }
+    /**
+     * Returns the value of a URL query param.
+     */
+    getParam(name) {
+        return this.getParams()[name];
+    }
+    /**
+     * Sets the value of a URL query param.
+     */
+    setParam(name, value) {
+        const params = this.getParams();
+        if (value === null) {
+            delete params[name];
+        }
+        else {
+            params[name] = value;
+        }
+        // Update the URL without triggering a navigation state change.
+        // See: https://stackoverflow.com/a/46486677
+        const url = this.router.createUrlTree(['.'], {
+            relativeTo: this.activatedRoute,
+            queryParams: params,
+            queryParamsHandling: 'merge'
+        }).toString();
+        // Abort redirect if the current URL is equal to the new URL.
+        if (this.location.isCurrentPathEqualTo(url)) {
+            return;
+        }
+        this.location.go(url);
+    }
+    /**
+     * Removes the provided query param from the URL.
+     */
+    clearParam(name) {
+        /*tslint:disable-next-line:no-null-keyword*/
+        this.setParam(name, null);
+    }
+    /**
+     * Returns a relative URL that includes the provided query parameter. The value is inteded to be
+     * used by an HTML anchor element.
+     */
+    getParamHref(name, value) {
+        if (!name) {
+            /*tslint:disable-next-line:no-null-keyword*/
+            return null;
+        }
+        const params = this.getParams();
+        params[name] = value;
+        const baseUrl = this.location.path().split('?')[0];
+        const paramString = Object.keys(params).map(k => `${k}=${params[k]}`).join('&');
+        return this.location.prepareExternalUrl(`${baseUrl}?${paramString}`);
+    }
+    /**
+     * Converts the provided string into a value that can be safely used in a URL.
+     */
+    urlify(value) {
+        if (!value) {
+            return '';
+        }
+        const sanitized = value.toLowerCase()
+            // Remove special characters.
+            .replace(/[\_\~\`\@\!\#\$\%\^\&\*\(\)\[\]\{\}\;\:\'\/\\\<\>\,\.\?\=\+\|"]/g, '')
+            // Replace space characters with a dash.
+            .replace(/\s/g, '-')
+            // Remove any double-dashes.
+            .replace(/--/g, '-');
+        return sanitized;
+    }
+    /**
+     * Returns all query params that exist in the current URL.
+     */
+    getParams() {
+        const params = {};
+        const path = this.location.path();
+        if (path.indexOf('?') === -1) {
+            return params;
+        }
+        const existingParamPairs = path.split('?')[1].split('&');
+        existingParamPairs.forEach((pair) => {
+            const fragments = pair.split('=');
+            params[fragments[0]] = decodeURIComponent(fragments[1]);
+        });
+        return params;
+    }
+};
+SkyTabsetPermalinkService.ctorParameters = () => [
+    { type: ActivatedRoute },
+    { type: Location },
+    { type: Router }
+];
+SkyTabsetPermalinkService = __decorate([
+    Injectable()
+], SkyTabsetPermalinkService);
+export { SkyTabsetPermalinkService };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"tabset-permalink.service.js","sourceRoot":"ng://@skyux/tabs/","sources":["modules/tabs/tabset-permalink.service.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  Location\n} from '@angular/common';\n\nimport {\n  Injectable,\n  OnDestroy\n} from '@angular/core';\n\nimport {\n  ActivatedRoute,\n  Router\n} from '@angular/router';\n\nimport {\n  Observable,\n  Subject,\n  SubscriptionLike\n} from 'rxjs';\n\n/**\n * @internal\n */\ninterface PermalinkParams {\n  [_: string]: string;\n}\n\n/**\n * @internal\n */\n@Injectable()\nexport class SkyTabsetPermalinkService implements OnDestroy {\n\n  public get popStateChange(): Observable<void> {\n    return this._popStateChange.asObservable();\n  }\n\n  private _popStateChange = new Subject<void>();\n\n  private subscription: SubscriptionLike;\n\n  constructor(\n    private activatedRoute: ActivatedRoute,\n    private location: Location,\n    private router: Router\n  ) { }\n\n  public ngOnDestroy(): void {\n    if (this.subscription) {\n      this.subscription.unsubscribe();\n    }\n  }\n\n  public init(): void {\n    this.subscription = this.location.subscribe(() => {\n      this._popStateChange.next();\n    });\n  }\n\n  /**\n   * Returns the value of a URL query param.\n   */\n  public getParam(name: string): string {\n    return this.getParams()[name];\n  }\n\n  /**\n   * Sets the value of a URL query param.\n   */\n  public setParam(name: string, value: string | null): void {\n    const params = this.getParams();\n\n    if (value === null) {\n      delete params[name];\n    } else {\n      params[name] = value;\n    }\n\n    // Update the URL without triggering a navigation state change.\n    // See: https://stackoverflow.com/a/46486677\n    const url = this.router.createUrlTree(['.'], {\n      relativeTo: this.activatedRoute,\n      queryParams: params,\n      queryParamsHandling: 'merge'\n    }).toString();\n\n    // Abort redirect if the current URL is equal to the new URL.\n    if (this.location.isCurrentPathEqualTo(url)) {\n      return;\n    }\n\n    this.location.go(url);\n  }\n\n  /**\n   * Removes the provided query param from the URL.\n   */\n  public clearParam(name: string): void {\n    /*tslint:disable-next-line:no-null-keyword*/\n    this.setParam(name, null);\n  }\n\n  /**\n   * Returns a relative URL that includes the provided query parameter. The value is inteded to be\n   * used by an HTML anchor element.\n   */\n  public getParamHref(name: string, value: string): string | null {\n    if (!name) {\n      /*tslint:disable-next-line:no-null-keyword*/\n      return null;\n    }\n\n    const params = this.getParams();\n    params[name] = value;\n\n    const baseUrl = this.location.path().split('?')[0];\n    const paramString = Object.keys(params).map(k => `${k}=${params[k]}`).join('&');\n\n    return this.location.prepareExternalUrl(`${baseUrl}?${paramString}`);\n  }\n\n  /**\n   * Converts the provided string into a value that can be safely used in a URL.\n   */\n  public urlify(value: string): string {\n    if (!value) {\n      return '';\n    }\n\n    const sanitized = value.toLowerCase()\n\n      // Remove special characters.\n      .replace(/[\\_\\~\\`\\@\\!\\#\\$\\%\\^\\&\\*\\(\\)\\[\\]\\{\\}\\;\\:\\'\\/\\\\\\<\\>\\,\\.\\?\\=\\+\\|\"]/g, '')\n\n      // Replace space characters with a dash.\n      .replace(/\\s/g, '-')\n\n      // Remove any double-dashes.\n      .replace(/--/g, '-');\n\n    return sanitized;\n  }\n\n  /**\n   * Returns all query params that exist in the current URL.\n   */\n  private getParams(): PermalinkParams {\n    const params: PermalinkParams = {};\n\n    const path = this.location.path();\n    if (path.indexOf('?') === -1) {\n      return params;\n    }\n\n    const existingParamPairs = path.split('?')[1].split('&');\n    existingParamPairs.forEach((pair) => {\n      const fragments = pair.split('=');\n      params[fragments[0]] = decodeURIComponent(fragments[1]);\n    });\n\n    return params;\n  }\n\n}\n"]}

package/esm2015/modules/tabs/tabset-style.js

@@ -0,0 +1 @@
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidGFic2V0LXN0eWxlLmpzIiwic291cmNlUm9vdCI6Im5nOi8vQHNreXV4L3RhYnMvIiwic291cmNlcyI6WyJtb2R1bGVzL3RhYnMvdGFic2V0LXN0eWxlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiIiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgdHlwZSBTa3lUYWJzZXRTdHlsZSA9ICd0YWJzJyB8ICd3aXphcmQnO1xuIl19

package/esm2015/modules/tabs/tabset-tab-indexes-change.js

@@ -0,0 +1 @@
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidGFic2V0LXRhYi1pbmRleGVzLWNoYW5nZS5qcyIsInNvdXJjZVJvb3QiOiJuZzovL0Bza3l1eC90YWJzLyIsInNvdXJjZXMiOlsibW9kdWxlcy90YWJzL3RhYnNldC10YWItaW5kZXhlcy1jaGFuZ2UudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7XG4gIFNreVRhYkluZGV4XG59IGZyb20gJy4vdGFiLWluZGV4JztcblxuZXhwb3J0IGludGVyZmFjZSBTa3lUYWJzZXRUYWJJbmRleGVzQ2hhbmdlIHtcblxuICB0YWJzPzoge1xuXG4gICAgdGFiSGVhZGluZzogc3RyaW5nO1xuXG4gICAgdGFiSW5kZXg6IFNreVRhYkluZGV4O1xuXG4gIH1bXTtcblxufVxuIl19

package/esm2015/modules/tabs/tabset.component.js

@@ -0,0 +1,403 @@
+import { __decorate } from "tslib";
+import { AfterViewInit, ChangeDetectionStrategy, ChangeDetectorRef, Component, ContentChildren, ElementRef, EventEmitter, Input, OnDestroy, Output, QueryList, ViewEncapsulation } from '@angular/core';
+import { combineLatest, race, Subject } from 'rxjs';
+import { distinctUntilChanged, takeUntil } from 'rxjs/operators';
+import { SkyTabComponent } from './tab.component';
+import { SkyTabsetAdapterService } from './tabset-adapter.service';
+import { SkyTabsetPermalinkService } from './tabset-permalink.service';
+import { SkyTabsetService } from './tabset.service';
+let SkyTabsetComponent = class SkyTabsetComponent {
+    constructor(changeDetector, elementRef, adapterService, permalinkService, tabsetService) {
+        this.changeDetector = changeDetector;
+        this.elementRef = elementRef;
+        this.adapterService = adapterService;
+        this.permalinkService = permalinkService;
+        this.tabsetService = tabsetService;
+        /**
+         * Fires when the active tab changes. This event emits the index of the active tab.
+         */
+        this.activeChange = new EventEmitter();
+        /**
+         * Fires when users click the button to add a new tab.
+         * The new tab button is added to the tab area when you specify a listener for this event.
+         */
+        this.newTab = new EventEmitter();
+        /**
+         * Fires when users click the button to open a tab.
+         * The open tab button is added to the tab area when you specify a listener for this event.
+         */
+        this.openTab = new EventEmitter();
+        /**
+         * Fires when any tab's `tabIndex` value changes.
+         */
+        this.tabIndexesChange = new EventEmitter();
+        this.tabButtons = [];
+        this.ngUnsubscribe = new Subject();
+        this.tabComponentsStateChangeUnsubscribe = new Subject();
+    }
+    /**
+     * Activates a tab by its `tabIndex` property.
+     */
+    set active(value) {
+        if (value === undefined ||
+            this.tabsetService.tabIndexesEqual(value, this._active)) {
+            return;
+        }
+        this._active = value;
+        if (this.tabs) {
+            this.tabsetService.setActiveTabIndex(value);
+        }
+        else {
+            // On init, wait for children tabs to render before broadcasting the active tab index.
+            setTimeout(() => {
+                if (this.tabsetService.isValidTabIndex(value)) {
+                    // On init, yield to the permalink ID, if it exists.
+                    if (this.getActiveTabIndexByPermalinkId() === undefined) {
+                        this.tabsetService.setActiveTabIndex(value);
+                    }
+                }
+                else {
+                    // Activate the first tab if the new tab index is invalid.
+                    this._active = this.tabsetService.activateFirstTab();
+                }
+            });
+        }
+    }
+    get active() {
+        return this._active;
+    }
+    /**
+     * Distinguishes a tabset's unique state in the URL by generating a query parameter
+     * that is written as `?<queryParam>-active-tab=<sanitized-tab-heading>`.
+     * The query parameter's value is parsed automatically from the selected tab's heading text,
+     * but you can supply a custom query parameter value for each tab with its `permalinkValue`.
+     */
+    set permalinkId(value) {
+        if (!value) {
+            return;
+        }
+        const sanitized = this.permalinkService.urlify(value);
+        this._permalinkId = `${sanitized}-active-tab`;
+    }
+    get permalinkId() {
+        return this._permalinkId || '';
+    }
+    /**
+     * Specifies the behavior for a series of tabs.
+     * @deprecated The property was designed to create wizards by setting tabStyle="wizard" on tabsets in modals,
+     * but this wizard implementation was replaced by the
+     * [progress indicator component](https://developer.blackbaud.com/skyux/components/progress-indicator).
+     * @default 'tabs'
+     */
+    set tabStyle(value) {
+        /*istanbul ignore else*/
+        if (value && value.toLowerCase() === 'wizard') {
+            console.warn('The tabset wizard is deprecated. Please implement the new approach using ' +
+                'progress indicator as documented here: https://developer.blackbaud.com/skyux/components/wizard.');
+        }
+        this._tabStyle = value;
+    }
+    get tabStyle() {
+        return this._tabStyle || 'tabs';
+    }
+    set tabDisplayMode(value) {
+        this._tabDisplayMode = value;
+        this.changeDetector.markForCheck();
+    }
+    get tabDisplayMode() {
+        return this._tabDisplayMode || 'tabs';
+    }
+    ngAfterViewInit() {
+        this.initTabComponents();
+        this.listenTabComponentsStructuralChange();
+        const initialTabIndex = this.getInitialTabIndex();
+        this.tabsetService.setActiveTabIndex(initialTabIndex);
+        this.listenTabButtonsOverflowChange();
+        this.listenLocationPopStateChange();
+        // If the currently active tab is getting unregistered, activate the next one.
+        this.tabsetService.activeTabUnregistered
+            .pipe(takeUntil(this.ngUnsubscribe))
+            .subscribe(tab => {
+            // Wait for the new tabs to render before activating.
+            setTimeout(() => {
+                this.tabsetService.activateNearestTab(tab.arrayIndex);
+            });
+        });
+        // Let the tabset render the initial active index before listening for changes.
+        setTimeout(() => {
+            this.listenTabComponentsStateChange();
+            this.listenActiveIndexChange();
+            this.permalinkService.init();
+        });
+    }
+    ngOnDestroy() {
+        this.ngUnsubscribe.next();
+        this.ngUnsubscribe.complete();
+        this.unsubscribeTabComponentsStateChange();
+        this.permalinkService.clearParam(this.permalinkId);
+    }
+    onWindowResize() {
+        this.adapterService.detectOverflow();
+    }
+    onTabCloseClick(tabButton) {
+        const tabComponent = this.tabs.find(tab => this.tabsetService.tabIndexesEqual(tab.tabIndex, tabButton.tabIndex));
+        tabComponent.close.emit();
+    }
+    onTabButtonClick(tabButton) {
+        this.tabsetService.setActiveTabIndex(tabButton.tabIndex);
+    }
+    onNewTabClick() {
+        this.newTab.emit();
+    }
+    onOpenTabClick() {
+        this.openTab.emit();
+    }
+    /**
+     * Sets the initial active tab index based on the following criteria.
+     * 1. Does the URL include a query param that reflects this tabset's active tab?
+     * 2. Does one of the tab components have their `active` property set to `true`?
+     * 3. Is the tabset component's `active` property set to a specific tab index?
+     */
+    getInitialTabIndex() {
+        var _a;
+        let activeIndex = this.getActiveTabIndexByPermalinkId();
+        if (activeIndex === undefined) {
+            activeIndex = (_a = this.getActiveTabComponent()) === null || _a === void 0 ? void 0 : _a.tabIndex;
+            if (activeIndex === undefined) {
+                activeIndex = this.active;
+            }
+        }
+        return activeIndex;
+    }
+    listenActiveIndexChange() {
+        this.tabsetService.activeTabIndex
+            .pipe(distinctUntilChanged(), takeUntil(this.ngUnsubscribe))
+            .subscribe(activeIndex => {
+            this.updateTabsetComponent(activeIndex);
+        });
+    }
+    listenTabComponentsStructuralChange() {
+        this.tabs.changes
+            .pipe(takeUntil(this.ngUnsubscribe))
+            .subscribe(() => {
+            this.resetTabComponents();
+        });
+    }
+    listenTabComponentsStateChange() {
+        combineLatest(this.tabs.map(tab => tab.activeChange))
+            .pipe(takeUntil(race(this.tabComponentsStateChangeUnsubscribe, this.ngUnsubscribe)))
+            .subscribe(() => {
+            // Wait for the tab components to render changes before finding the active one.
+            setTimeout(() => {
+                var _a;
+                const tabIndex = (_a = this.getActiveTabComponent()) === null || _a === void 0 ? void 0 : _a.tabIndex;
+                this.tabsetService.setActiveTabIndex(tabIndex);
+            });
+        });
+        combineLatest(this.tabs.map(tab => tab.tabIndexChange))
+            .pipe(takeUntil(race(this.tabComponentsStateChangeUnsubscribe, this.ngUnsubscribe)))
+            .subscribe(() => {
+            // Don't emit the first change.
+            if (this.lastActiveTabIndex !== undefined) {
+                // Wait for the tab components to render changes before updating the view.
+                setTimeout(() => {
+                    this.updateTabsetComponent(this.tabsetService.currentActiveTabIndex, true);
+                    this.emitTabIndexChange();
+                });
+            }
+        });
+        combineLatest(this.tabs.map(tab => tab.stateChange))
+            .pipe(takeUntil(race(this.tabComponentsStateChangeUnsubscribe, this.ngUnsubscribe)))
+            .subscribe(() => {
+            // Wait for the tab components to render changes before finding the active one.
+            setTimeout(() => {
+                this.updateTabsetComponent(this.tabsetService.currentActiveTabIndex, true);
+            });
+        });
+    }
+    initTabComponents() {
+        this.tabs.forEach(tab => tab.init());
+    }
+    resetTabComponents() {
+        var _a;
+        this.unsubscribeTabComponentsStateChange();
+        this.tabsetService.unregisterAll();
+        // If there are no tab components, do a hard reset of the view.
+        if (this.tabs.length === 0) {
+            this.updateTabsetComponent(0, true);
+            return;
+        }
+        this.initTabComponents();
+        const activeIndex = (_a = this.getActiveTabComponent()) === null || _a === void 0 ? void 0 : _a.tabIndex;
+        this.tabsetService.setActiveTabIndex(activeIndex, {
+            emitChange: false
+        });
+        this.listenTabComponentsStateChange();
+    }
+    emitTabIndexChange() {
+        this.tabIndexesChange.emit({
+            tabs: this.tabs.map(tab => ({
+                tabHeading: tab.tabHeading,
+                tabIndex: tab.tabIndex
+            }))
+        });
+    }
+    unsubscribeTabComponentsStateChange() {
+        this.tabComponentsStateChangeUnsubscribe.next();
+        this.tabComponentsStateChangeUnsubscribe.complete();
+        this.tabComponentsStateChangeUnsubscribe = new Subject();
+    }
+    listenTabButtonsOverflowChange() {
+        this.adapterService.registerTabset(this.elementRef);
+        this.adapterService.overflowChange
+            .pipe(takeUntil(this.ngUnsubscribe))
+            .subscribe(isOverflowing => {
+            this.tabDisplayMode = (isOverflowing) ? 'dropdown' : 'tabs';
+            this.changeDetector.markForCheck();
+        });
+    }
+    /**
+     * Listen for back/forward history button presses to detect query param changes in the URL.
+     */
+    listenLocationPopStateChange() {
+        this.permalinkService.popStateChange
+            .pipe(takeUntil(this.ngUnsubscribe))
+            .subscribe(() => {
+            this.setActiveTabIndexByPermalinkId();
+        });
+    }
+    setActiveTabIndexByPermalinkId() {
+        const activeIndex = this.getActiveTabIndexByPermalinkId();
+        this.tabsetService.setActiveTabIndex(activeIndex);
+    }
+    getActiveTabIndexByPermalinkId() {
+        var _a;
+        if (this.permalinkId) {
+            const paramValue = this.permalinkService.getParam(this.permalinkId);
+            if (paramValue) {
+                return (_a = this.tabs.find(tab => tab.permalinkValue === paramValue)) === null || _a === void 0 ? void 0 : _a.tabIndex;
+            }
+        }
+    }
+    getActiveTabComponent() {
+        return this.tabs.toArray().reverse().find(tab => tab.active === true);
+    }
+    createTabButtons(activeIndex) {
+        return this.tabs.map(tab => ({
+            active: this.tabsetService.tabIndexesEqual(tab.tabIndex, activeIndex),
+            closeable: tab.closeable,
+            ariaControls: tab.tabPanelId,
+            disabled: tab.disabled,
+            /*tslint:disable-next-line:no-null-keyword*/
+            buttonHref: (tab.disabled) ? null : this.permalinkService.getParamHref(this.permalinkId, tab.permalinkValue),
+            buttonId: tab.tabButtonId,
+            buttonTextCount: tab.tabHeaderCount,
+            buttonText: tab.tabHeading,
+            tabIndex: tab.tabIndex
+        }));
+    }
+    updateTabButtons(activeIndex) {
+        this.tabButtons.forEach(button => {
+            button.active = this.tabsetService.tabIndexesEqual(button.tabIndex, activeIndex);
+        });
+    }
+    /**
+     * Updates the UI and state of the tabset component after the tab index or
+     * tab components have changed.
+     * @param activeIndex The currently active tab index.
+     * @param regenerateTabButtons Indicates if tab button view models should be regenerated.
+     * Setting this value to `false` will simply update the existing tab buttons. Setting this value
+     * to `true` is only necessary when the underlying tab components have changed and the tab
+     * buttons must reflect those changes.
+     */
+    updateTabsetComponent(activeIndex, regenerateTabButtons = false) {
+        var _a;
+        // Activate/deactivate tab components.
+        this.tabs.forEach(tab => {
+            this.tabsetService.tabIndexesEqual(tab.tabIndex, activeIndex)
+                ? tab.activate()
+                : tab.deactivate();
+        });
+        // Update the tab button models.
+        if (regenerateTabButtons || !this.tabButtons.length) {
+            this.tabButtons = this.createTabButtons(activeIndex);
+        }
+        else {
+            this.updateTabButtons(activeIndex);
+        }
+        // Update the dropdown trigger button text.
+        this.dropdownTriggerButtonText = (_a = this.tabButtons.find(b => {
+            return this.tabsetService.tabIndexesEqual(b.tabIndex, activeIndex);
+        })) === null || _a === void 0 ? void 0 : _a.buttonText;
+        // Set the query params based on active tab.
+        if (this.permalinkId) {
+            const activeTabComponent = this.tabs.find(tab => {
+                return this.tabsetService.tabIndexesEqual(tab.tabIndex, activeIndex);
+            });
+            this.permalinkService.setParam(this.permalinkId, activeTabComponent.permalinkValue);
+        }
+        // Wait for tab button view models to render before gauging dimensions.
+        setTimeout(() => {
+            this.adapterService.detectOverflow();
+        });
+        this.changeDetector.markForCheck();
+        // Emit the new active index value to consumers.
+        if (this.lastActiveTabIndex !== activeIndex) {
+            this.lastActiveTabIndex = activeIndex;
+            this.activeChange.emit(activeIndex);
+        }
+    }
+};
+SkyTabsetComponent.ctorParameters = () => [
+    { type: ChangeDetectorRef },
+    { type: ElementRef },
+    { type: SkyTabsetAdapterService },
+    { type: SkyTabsetPermalinkService },
+    { type: SkyTabsetService }
+];
+__decorate([
+    Input()
+], SkyTabsetComponent.prototype, "active", null);
+__decorate([
+    Input()
+], SkyTabsetComponent.prototype, "ariaLabel", void 0);
+__decorate([
+    Input()
+], SkyTabsetComponent.prototype, "ariaLabelledBy", void 0);
+__decorate([
+    Input()
+], SkyTabsetComponent.prototype, "permalinkId", null);
+__decorate([
+    Input()
+], SkyTabsetComponent.prototype, "tabStyle", null);
+__decorate([
+    Output()
+], SkyTabsetComponent.prototype, "activeChange", void 0);
+__decorate([
+    Output()
+], SkyTabsetComponent.prototype, "newTab", void 0);
+__decorate([
+    Output()
+], SkyTabsetComponent.prototype, "openTab", void 0);
+__decorate([
+    Output()
+], SkyTabsetComponent.prototype, "tabIndexesChange", void 0);
+__decorate([
+    ContentChildren(SkyTabComponent)
+], SkyTabsetComponent.prototype, "tabs", void 0);
+SkyTabsetComponent = __decorate([
+    Component({
+        selector: 'sky-tabset',
+        template: "<div\n  class=\"sky-tabset\"\n  role=\"tablist\"\n  [attr.aria-label]=\"ariaLabel\"\n  [attr.aria-labelledby]=\"ariaLabelledBy\"\n  [ngClass]=\"'sky-tabset-mode-' + tabDisplayMode + ' sky-tabset-style-' + tabStyle\"\n  (window:resize)=\"onWindowResize()\"\n>\n  <span class=\"sky-tabset-dropdown\">\n    <sky-dropdown *ngIf=\"tabDisplayMode === 'dropdown'\"\n      buttonType=\"tab\"\n    >\n      <sky-dropdown-button>\n        {{ dropdownTriggerButtonText }}\n      </sky-dropdown-button>\n      <sky-dropdown-menu>\n        <sky-dropdown-item *ngFor=\"let tabButton of tabButtons\"\n          class=\"sky-tab-dropdown-menu-item\"\n        >\n          <div\n            class=\"sky-tab-dropdown-item\"\n            [ngClass]=\"{\n              'sky-tab-dropdown-item-selected': tabButton.active\n            }\"\n          >\n            <ng-container *ngTemplateOutlet=\"tabButtonTemplate; context: {\n              $implicit: tabButton\n            }\"></ng-container>\n          </div>\n        </sky-dropdown-item>\n      </sky-dropdown-menu>\n    </sky-dropdown>\n  </span>\n  <span\n    class=\"sky-tabset-tabs\"\n  >\n    <ng-container *ngFor=\"let tabButton of tabButtons\">\n      <ng-container *ngTemplateOutlet=\"tabButtonTemplate; context: {\n        $implicit: tabButton\n      }\"></ng-container>\n    </ng-container>\n  </span>\n  <span\n    class=\"sky-tabset-btns\"\n  >\n    <button *ngIf=\"newTab.observers.length > 0\"\n      class=\"sky-btn sky-btn-icon sky-tabset-btn-new sky-margin-inline-compact\"\n      type=\"button\"\n      [attr.aria-label]=\"'skyux_tab_add' | skyLibResources\"\n      [skyThemeClass]=\"{\n        'sky-margin-inline-sm': 'modern'\n      }\"\n      (click)=\"onNewTabClick()\"\n    >\n      <sky-icon\n        icon=\"plus-circle\"\n        size=\"lg\"\n      >\n      </sky-icon>\n    </button>\n    <button *ngIf=\"openTab.observers.length > 0\"\n      class=\"sky-btn sky-btn-icon sky-tabset-btn-open sky-margin-inline-compact\"\n      type=\"button\"\n      [attr.aria-label]=\"'skyux_tab_open' | skyLibResources\"\n      [skyThemeClass]=\"{\n        'sky-margin-inline-sm': 'modern'\n      }\"\n      (click)=\"onOpenTabClick()\"\n    >\n      <sky-icon\n        icon=\"folder-open-o\"\n        size=\"lg\"\n      >\n      </sky-icon>\n    </button>\n  </span>\n</div>\n<ng-content></ng-content>\n\n<ng-template\n  let-tabButton\n  #tabButtonTemplate\n>\n  <sky-tab-button\n    [active]=\"tabButton.active\"\n    [ariaControls]=\"tabButton.ariaControls\"\n    [buttonHref]=\"tabButton.buttonHref\"\n    [buttonId]=\"tabButton.buttonId\"\n    [buttonText]=\"tabButton.buttonText\"\n    [buttonTextCount]=\"tabButton.buttonTextCount\"\n    [closeable]=\"tabButton.closeable\"\n    [disabled]=\"tabButton.disabled\"\n    [tabStyle]=\"tabStyle\"\n    (buttonClick)=\"onTabButtonClick(tabButton)\"\n    (closeClick)=\"onTabCloseClick(tabButton)\"\n  ></sky-tab-button>\n</ng-template>\n",
+        providers: [
+            SkyTabsetAdapterService,
+            SkyTabsetPermalinkService,
+            SkyTabsetService
+        ],
+        changeDetection: ChangeDetectionStrategy.OnPush,
+        encapsulation: ViewEncapsulation.None,
+        styles: [".sky-tabset{align-items:center;border-bottom:2px solid #0974a1;display:flex;list-style-type:none;margin:0;overflow:hidden;padding:0 0 0 15px;white-space:nowrap}.sky-tabset.sky-tabset-style-wizard{border-bottom:none;padding-bottom:10px;padding-left:0}.sky-tabset-btns{order:1;padding-left:10px}.sky-tabset-dropdown{order:0;max-width:100%}.sky-tabset-mode-dropdown{line-height:0}.sky-tabset-mode-dropdown .sky-tabset-tabs{visibility:hidden;order:2}.sky-tab-dropdown-menu-item sky-tab-button{display:flex;min-width:300px}.sky-tab-dropdown-menu-item .sky-dropdown-item{margin:0}.sky-tab-dropdown-menu-item .sky-btn-tab-wrapper{width:100%;margin-right:0}.sky-tab-dropdown-menu-item .sky-btn-tab{margin:0;border-radius:0;width:100%;display:flex}.sky-tab-dropdown-menu-item .sky-btn-tab>.sky-tab-heading{flex:1 1 auto}.sky-tab-dropdown-menu-item .sky-btn-tab>.sky-btn-tab-close{flex:0 1 auto}.sky-tabset-tabs{order:0;white-space:nowrap}.sky-tabset-btn-new,.sky-tabset-btn-open{color:#0974a1}.sky-theme-modern .sky-tabset{border-bottom:1px solid #d2d2d2;overflow:visible}.sky-theme-modern .sky-tab-dropdown-menu-item .sky-btn-tab-wrapper{margin-right:0}"]
+    })
+], SkyTabsetComponent);
+export { SkyTabsetComponent };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"tabset.component.js","sourceRoot":"ng://@skyux/tabs/","sources":["modules/tabs/tabset.component.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  AfterViewInit,\n  ChangeDetectionStrategy,\n  ChangeDetectorRef,\n  Component,\n  ContentChildren,\n  ElementRef,\n  EventEmitter,\n  Input,\n  OnDestroy,\n  Output,\n  QueryList,\n  ViewEncapsulation\n} from '@angular/core';\n\nimport {\n  combineLatest,\n  race,\n  Subject\n} from 'rxjs';\n\nimport {\n  distinctUntilChanged,\n  takeUntil\n} from 'rxjs/operators';\n\nimport {\n  SkyTabIndex\n} from './tab-index';\n\nimport {\n  SkyTabsetStyle\n} from './tabset-style';\n\nimport {\n  SkyTabComponent\n} from './tab.component';\n\nimport {\n  SkyTabsetAdapterService\n} from './tabset-adapter.service';\n\nimport {\n  SkyTabsetButtonsDisplayMode\n} from './tabset-buttons-display-mode';\n\nimport {\n  SkyTabsetPermalinkService\n} from './tabset-permalink.service';\n\nimport {\n  SkyTabsetService\n} from './tabset.service';\n\nimport {\n  SkyTabsetTabIndexesChange\n} from './tabset-tab-indexes-change';\n\n/**\n * @internal\n */\ninterface TabButtonViewModel {\n  active: boolean;\n  ariaControls: string;\n  buttonHref: string;\n  buttonId: string;\n  buttonText: string;\n  buttonTextCount: string;\n  closeable: boolean;\n  disabled: boolean;\n  tabIndex: SkyTabIndex;\n}\n\n@Component({\n  selector: 'sky-tabset',\n  styleUrls: ['./tabset.component.scss'],\n  templateUrl: './tabset.component.html',\n  providers: [\n    SkyTabsetAdapterService,\n    SkyTabsetPermalinkService,\n    SkyTabsetService\n  ],\n  changeDetection: ChangeDetectionStrategy.OnPush,\n  encapsulation: ViewEncapsulation.None\n})\nexport class SkyTabsetComponent implements AfterViewInit, OnDestroy {\n\n  /**\n   * Activates a tab by its `tabIndex` property.\n   */\n  @Input()\n  public set active(value: SkyTabIndex) {\n    if (\n      value === undefined ||\n      this.tabsetService.tabIndexesEqual(value, this._active)\n    ) {\n      return;\n    }\n\n    this._active = value;\n\n    if (this.tabs) {\n      this.tabsetService.setActiveTabIndex(value);\n    } else {\n      // On init, wait for children tabs to render before broadcasting the active tab index.\n      setTimeout(() => {\n        if (this.tabsetService.isValidTabIndex(value)) {\n          // On init, yield to the permalink ID, if it exists.\n          if (this.getActiveTabIndexByPermalinkId() === undefined) {\n            this.tabsetService.setActiveTabIndex(value);\n          }\n        } else {\n          // Activate the first tab if the new tab index is invalid.\n          this._active = this.tabsetService.activateFirstTab();\n        }\n      });\n    }\n  }\n\n  public get active(): SkyTabIndex {\n    return this._active;\n  }\n\n  /**\n   * Specifies an ARIA label for the tabset. This sets the tabset's `aria-label` attribute\n   * [to support accessibility](https://developer.blackbaud.com/skyux/learn/accessibility).\n   * If the tabset includes a visible label, use `ariaLabelledBy` instead.\n   */\n  @Input()\n  public ariaLabel: string;\n\n  /**\n   * Specifies the HTML element ID (without the leading `#`) of the element that labels\n   * the tabset. This sets the tabset's `aria-labelledby` attribute\n   * [to support accessibility](https://developer.blackbaud.com/skyux/learn/accessibility).\n   * If the tabset does not include a visible label, use `ariaLabel` instead.\n   */\n  @Input()\n  public ariaLabelledBy: string;\n\n  /**\n   * Distinguishes a tabset's unique state in the URL by generating a query parameter\n   * that is written as `?<queryParam>-active-tab=<sanitized-tab-heading>`.\n   * The query parameter's value is parsed automatically from the selected tab's heading text,\n   * but you can supply a custom query parameter value for each tab with its `permalinkValue`.\n   */\n  @Input()\n  public set permalinkId(value: string) {\n    if (!value) {\n      return;\n    }\n\n    const sanitized = this.permalinkService.urlify(value);\n    this._permalinkId = `${sanitized}-active-tab`;\n  }\n\n  public get permalinkId(): string {\n    return this._permalinkId || '';\n  }\n\n  /**\n   * Specifies the behavior for a series of tabs.\n   * @deprecated The property was designed to create wizards by setting tabStyle=\"wizard\" on tabsets in modals,\n   * but this wizard implementation was replaced by the\n   * [progress indicator component](https://developer.blackbaud.com/skyux/components/progress-indicator).\n   * @default 'tabs'\n   */\n  @Input()\n  public set tabStyle(value: SkyTabsetStyle) {\n    /*istanbul ignore else*/\n    if (value && value.toLowerCase() === 'wizard') {\n      console.warn(\n        'The tabset wizard is deprecated. Please implement the new approach using ' +\n        'progress indicator as documented here: https://developer.blackbaud.com/skyux/components/wizard.'\n      );\n    }\n\n    this._tabStyle = value;\n  }\n\n  public get tabStyle(): SkyTabsetStyle {\n    return this._tabStyle || 'tabs';\n  }\n\n  /**\n   * Fires when the active tab changes. This event emits the index of the active tab.\n   */\n  @Output()\n  public activeChange = new EventEmitter<SkyTabIndex>();\n\n  /**\n   * Fires when users click the button to add a new tab.\n   * The new tab button is added to the tab area when you specify a listener for this event.\n   */\n  @Output()\n  public newTab = new EventEmitter<void>();\n\n  /**\n   * Fires when users click the button to open a tab.\n   * The open tab button is added to the tab area when you specify a listener for this event.\n   */\n  @Output()\n  public openTab = new EventEmitter<void>();\n\n  /**\n   * Fires when any tab's `tabIndex` value changes.\n   */\n  @Output()\n  public tabIndexesChange = new EventEmitter<SkyTabsetTabIndexesChange>();\n\n  public set tabDisplayMode(value: SkyTabsetButtonsDisplayMode) {\n    this._tabDisplayMode = value;\n    this.changeDetector.markForCheck();\n  }\n\n  public get tabDisplayMode(): SkyTabsetButtonsDisplayMode {\n    return this._tabDisplayMode || 'tabs';\n  }\n\n  @ContentChildren(SkyTabComponent)\n  public tabs: QueryList<SkyTabComponent>;\n\n  public dropdownTriggerButtonText: string;\n\n  /**\n   * This property is used by the deprecated tabset-nav-button component.\n   * @internal\n   */\n  public lastActiveTabIndex: SkyTabIndex;\n\n  public tabButtons: TabButtonViewModel[] = [];\n\n  private ngUnsubscribe = new Subject<void>();\n\n  private tabComponentsStateChangeUnsubscribe = new Subject<void>();\n\n  private _active: SkyTabIndex;\n\n  private _permalinkId: string;\n\n  private _tabDisplayMode: SkyTabsetButtonsDisplayMode;\n\n  private _tabStyle: SkyTabsetStyle;\n\n  constructor(\n    private changeDetector: ChangeDetectorRef,\n    private elementRef: ElementRef,\n    private adapterService: SkyTabsetAdapterService,\n    private permalinkService: SkyTabsetPermalinkService,\n    private tabsetService: SkyTabsetService\n  ) { }\n\n  public ngAfterViewInit(): void {\n\n    this.initTabComponents();\n    this.listenTabComponentsStructuralChange();\n\n    const initialTabIndex = this.getInitialTabIndex();\n    this.tabsetService.setActiveTabIndex(initialTabIndex);\n\n    this.listenTabButtonsOverflowChange();\n    this.listenLocationPopStateChange();\n\n    // If the currently active tab is getting unregistered, activate the next one.\n    this.tabsetService.activeTabUnregistered\n      .pipe(takeUntil(this.ngUnsubscribe))\n      .subscribe(tab => {\n        // Wait for the new tabs to render before activating.\n        setTimeout(() => {\n          this.tabsetService.activateNearestTab(tab.arrayIndex);\n        });\n      });\n\n    // Let the tabset render the initial active index before listening for changes.\n    setTimeout(() => {\n      this.listenTabComponentsStateChange();\n      this.listenActiveIndexChange();\n      this.permalinkService.init();\n    });\n  }\n\n  public ngOnDestroy(): void {\n    this.ngUnsubscribe.next();\n    this.ngUnsubscribe.complete();\n    this.unsubscribeTabComponentsStateChange();\n    this.permalinkService.clearParam(this.permalinkId);\n  }\n\n  public onWindowResize(): void {\n    this.adapterService.detectOverflow();\n  }\n\n  public onTabCloseClick(tabButton: TabButtonViewModel): void {\n    const tabComponent = this.tabs.find(tab =>\n      this.tabsetService.tabIndexesEqual(tab.tabIndex, tabButton.tabIndex)\n    );\n\n    tabComponent.close.emit();\n  }\n\n  public onTabButtonClick(tabButton: TabButtonViewModel): void {\n    this.tabsetService.setActiveTabIndex(tabButton.tabIndex);\n  }\n\n  public onNewTabClick(): void {\n    this.newTab.emit();\n  }\n\n  public onOpenTabClick(): void {\n    this.openTab.emit();\n  }\n\n  /**\n   * Sets the initial active tab index based on the following criteria.\n   * 1. Does the URL include a query param that reflects this tabset's active tab?\n   * 2. Does one of the tab components have their `active` property set to `true`?\n   * 3. Is the tabset component's `active` property set to a specific tab index?\n   */\n  private getInitialTabIndex(): SkyTabIndex {\n    let activeIndex: SkyTabIndex = this.getActiveTabIndexByPermalinkId();\n    if (activeIndex === undefined) {\n      activeIndex = this.getActiveTabComponent()?.tabIndex;\n      if (activeIndex === undefined) {\n        activeIndex = this.active;\n      }\n    }\n\n    return activeIndex;\n  }\n\n  private listenActiveIndexChange(): void {\n    this.tabsetService.activeTabIndex\n      .pipe(\n        distinctUntilChanged(),\n        takeUntil(this.ngUnsubscribe)\n      )\n      .subscribe(activeIndex => {\n        this.updateTabsetComponent(activeIndex);\n      });\n  }\n\n  private listenTabComponentsStructuralChange(): void {\n    this.tabs.changes\n      .pipe(takeUntil(this.ngUnsubscribe))\n      .subscribe(() => {\n        this.resetTabComponents();\n      });\n  }\n\n  private listenTabComponentsStateChange(): void {\n    combineLatest(this.tabs.map(tab => tab.activeChange))\n      .pipe(takeUntil(race(this.tabComponentsStateChangeUnsubscribe, this.ngUnsubscribe)))\n      .subscribe(() => {\n        // Wait for the tab components to render changes before finding the active one.\n        setTimeout(() => {\n          const tabIndex = this.getActiveTabComponent()?.tabIndex;\n          this.tabsetService.setActiveTabIndex(tabIndex);\n        });\n      });\n\n    combineLatest(this.tabs.map(tab => tab.tabIndexChange))\n      .pipe(takeUntil(race(this.tabComponentsStateChangeUnsubscribe, this.ngUnsubscribe)))\n      .subscribe(() => {\n        // Don't emit the first change.\n        if (this.lastActiveTabIndex !== undefined) {\n          // Wait for the tab components to render changes before updating the view.\n          setTimeout(() => {\n            this.updateTabsetComponent(this.tabsetService.currentActiveTabIndex, true);\n            this.emitTabIndexChange();\n          });\n        }\n      });\n\n    combineLatest(this.tabs.map(tab => tab.stateChange))\n      .pipe(takeUntil(race(this.tabComponentsStateChangeUnsubscribe, this.ngUnsubscribe)))\n      .subscribe(() => {\n        // Wait for the tab components to render changes before finding the active one.\n        setTimeout(() => {\n          this.updateTabsetComponent(this.tabsetService.currentActiveTabIndex, true);\n        });\n      });\n  }\n\n  private initTabComponents(): void {\n    this.tabs.forEach(tab => tab.init());\n  }\n\n  private resetTabComponents(): void {\n    this.unsubscribeTabComponentsStateChange();\n    this.tabsetService.unregisterAll();\n\n    // If there are no tab components, do a hard reset of the view.\n    if (this.tabs.length === 0) {\n      this.updateTabsetComponent(0, true);\n      return;\n    }\n\n    this.initTabComponents();\n    const activeIndex = this.getActiveTabComponent()?.tabIndex;\n    this.tabsetService.setActiveTabIndex(activeIndex, {\n      emitChange: false\n    });\n    this.listenTabComponentsStateChange();\n  }\n\n  private emitTabIndexChange(): void {\n    this.tabIndexesChange.emit({\n      tabs: this.tabs.map(tab => ({\n        tabHeading: tab.tabHeading,\n        tabIndex: tab.tabIndex\n      }))\n    });\n  }\n\n  private unsubscribeTabComponentsStateChange(): void {\n    this.tabComponentsStateChangeUnsubscribe.next();\n    this.tabComponentsStateChangeUnsubscribe.complete();\n    this.tabComponentsStateChangeUnsubscribe = new Subject<void>();\n  }\n\n  private listenTabButtonsOverflowChange(): void {\n    this.adapterService.registerTabset(this.elementRef);\n    this.adapterService.overflowChange\n      .pipe(takeUntil(this.ngUnsubscribe))\n      .subscribe(isOverflowing => {\n        this.tabDisplayMode = (isOverflowing) ? 'dropdown' : 'tabs';\n        this.changeDetector.markForCheck();\n      });\n  }\n\n  /**\n   * Listen for back/forward history button presses to detect query param changes in the URL.\n   */\n  private listenLocationPopStateChange(): void {\n    this.permalinkService.popStateChange\n      .pipe(takeUntil(this.ngUnsubscribe))\n      .subscribe(() => {\n        this.setActiveTabIndexByPermalinkId();\n      });\n  }\n\n  private setActiveTabIndexByPermalinkId(): void {\n    const activeIndex = this.getActiveTabIndexByPermalinkId();\n    this.tabsetService.setActiveTabIndex(activeIndex);\n  }\n\n  private getActiveTabIndexByPermalinkId(): SkyTabIndex {\n    if (this.permalinkId) {\n      const paramValue = this.permalinkService.getParam(this.permalinkId);\n      if (paramValue) {\n        return this.tabs.find(tab => tab.permalinkValue === paramValue)?.tabIndex;\n      }\n    }\n  }\n\n  private getActiveTabComponent(): SkyTabComponent {\n    return this.tabs.toArray().reverse().find(tab => tab.active === true);\n  }\n\n  private createTabButtons(activeIndex: SkyTabIndex): TabButtonViewModel[] {\n    return this.tabs.map(tab => ({\n      active: this.tabsetService.tabIndexesEqual(tab.tabIndex, activeIndex),\n      closeable: tab.closeable,\n      ariaControls: tab.tabPanelId,\n      disabled: tab.disabled,\n      /*tslint:disable-next-line:no-null-keyword*/\n      buttonHref: (tab.disabled) ? null : this.permalinkService.getParamHref(\n        this.permalinkId,\n        tab.permalinkValue\n      ),\n      buttonId: tab.tabButtonId,\n      buttonTextCount: tab.tabHeaderCount,\n      buttonText: tab.tabHeading,\n      tabIndex: tab.tabIndex\n    }));\n  }\n\n  private updateTabButtons(activeIndex: SkyTabIndex): void {\n    this.tabButtons.forEach(button => {\n      button.active = this.tabsetService.tabIndexesEqual(button.tabIndex, activeIndex);\n    });\n  }\n\n  /**\n   * Updates the UI and state of the tabset component after the tab index or\n   * tab components have changed.\n   * @param activeIndex The currently active tab index.\n   * @param regenerateTabButtons Indicates if tab button view models should be regenerated.\n   * Setting this value to `false` will simply update the existing tab buttons. Setting this value\n   * to `true` is only necessary when the underlying tab components have changed and the tab\n   * buttons must reflect those changes.\n   */\n  private updateTabsetComponent(\n    activeIndex: SkyTabIndex,\n    regenerateTabButtons = false\n  ): void {\n\n    // Activate/deactivate tab components.\n    this.tabs.forEach(tab => {\n      this.tabsetService.tabIndexesEqual(tab.tabIndex, activeIndex)\n        ? tab.activate()\n        : tab.deactivate();\n    });\n\n    // Update the tab button models.\n    if (regenerateTabButtons || !this.tabButtons.length) {\n      this.tabButtons = this.createTabButtons(activeIndex);\n    } else {\n      this.updateTabButtons(activeIndex);\n    }\n\n    // Update the dropdown trigger button text.\n    this.dropdownTriggerButtonText = this.tabButtons.find(b => {\n      return this.tabsetService.tabIndexesEqual(b.tabIndex, activeIndex);\n    })?.buttonText;\n\n    // Set the query params based on active tab.\n    if (this.permalinkId) {\n      const activeTabComponent = this.tabs.find(tab => {\n        return this.tabsetService.tabIndexesEqual(tab.tabIndex, activeIndex);\n      });\n      this.permalinkService.setParam(this.permalinkId, activeTabComponent.permalinkValue);\n    }\n\n    // Wait for tab button view models to render before gauging dimensions.\n    setTimeout(() => {\n      this.adapterService.detectOverflow();\n    });\n\n    this.changeDetector.markForCheck();\n\n    // Emit the new active index value to consumers.\n    if (this.lastActiveTabIndex !== activeIndex) {\n      this.lastActiveTabIndex = activeIndex;\n      this.activeChange.emit(activeIndex);\n    }\n  }\n}\n"]}