@natec/mef-dev-ui-kit 0.0.1

package/esm2020/lib/pg-components/tabs/tabs-nav.component.mjs

@@ -0,0 +1,335 @@
+import { Component, ContentChild, ContentChildren, Input, Optional, ViewChild, ViewEncapsulation } from '@angular/core';
+import { fromEvent, merge, of as observableOf } from 'rxjs';
+import { auditTime, startWith } from 'rxjs/operators';
+import { toBoolean } from '../util/convert';
+import { pgTabLabelDirective } from './tab-label.directive';
+import { pgTabsInkBarDirective } from './tabs-ink-bar.directive';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/cdk/bidi";
+import * as i2 from "@angular/cdk/observers";
+import * as i3 from "./tabs-ink-bar.directive";
+const EXAGGERATED_OVERSCROLL = 64;
+export class pgTabsNavComponent {
+    constructor(_elementRef, _ngZone, _renderer, _dir) {
+        this._elementRef = _elementRef;
+        this._ngZone = _ngZone;
+        this._renderer = _renderer;
+        this._dir = _dir;
+        this._animated = true;
+        this._hideBar = false;
+        this._showPagination = true;
+        this._showPaginationControls = false;
+        this._disableScrollAfter = true;
+        this._disableScrollBefore = true;
+        this._scrollDistance = 0;
+        this._selectedIndexChanged = false;
+        this._realignInkBar = null;
+        this._selectedIndex = 0;
+        this._tabPositionMode = 'horizontal';
+        this._tabPosition = 'top';
+        this.Size = 'default';
+        this._type = 'line';
+    }
+    set Animated(value) {
+        this._animated = toBoolean(value);
+    }
+    get Animated() {
+        return this._animated;
+    }
+    set Position(value) {
+        this._tabPosition = value;
+    }
+    get Position() {
+        return this._tabPosition;
+    }
+    set HideBar(value) {
+        this._hideBar = toBoolean(value);
+    }
+    get HideBar() {
+        return this._hideBar;
+    }
+    set Type(value) {
+        this._type = value;
+    }
+    get Type() {
+        return this._type;
+    }
+    set ShowPagination(value) {
+        this._showPagination = toBoolean(value);
+    }
+    get ShowPagination() {
+        return this._showPagination;
+    }
+    set PositionMode(value) {
+        this._tabPositionMode = value;
+        this._alignInkBarToSelectedTab();
+        if (this.ShowPagination) {
+            this._updatePagination();
+        }
+    }
+    get PositionMode() {
+        return this._tabPositionMode;
+    }
+    set selectedIndex(value) {
+        this._selectedIndexChanged = this._selectedIndex !== value;
+        this._selectedIndex = value;
+    }
+    get selectedIndex() {
+        return this._selectedIndex;
+    }
+    _onContentChanges() {
+        if (this.ShowPagination) {
+            this._updatePagination();
+        }
+        this._alignInkBarToSelectedTab();
+    }
+    _scrollHeader(scrollDir) {
+        // Move the scroll distance one-third the length of the tab list's viewport.
+        this.scrollDistance += ((scrollDir === 'before' ? -1 : 1) * this.viewWidthHeightPix) / 3;
+    }
+    ngAfterContentChecked() {
+        if (this._tabLabelCount !== this._labelWrappers.length) {
+            if (this.ShowPagination) {
+                this._updatePagination();
+            }
+            this._tabLabelCount = this._labelWrappers.length;
+        }
+        if (this._selectedIndexChanged) {
+            this._scrollToLabel(this._selectedIndex);
+            if (this.ShowPagination) {
+                this._checkScrollingControls();
+            }
+            this._alignInkBarToSelectedTab();
+            this._selectedIndexChanged = false;
+        }
+        if (this._scrollDistanceChanged) {
+            if (this.ShowPagination) {
+                this._updateTabScrollPosition();
+            }
+            this._scrollDistanceChanged = false;
+        }
+    }
+    ngAfterContentInit() {
+        this._realignInkBar = this._ngZone.runOutsideAngular(() => {
+            const dirChange = this._dir ? this._dir.change : observableOf(null);
+            const resize = typeof window !== 'undefined' ? fromEvent(window, 'resize').pipe(auditTime(10)) : observableOf(null);
+            //@ts-ignore
+            return merge(dirChange, resize)
+                .pipe(startWith(null))
+                .subscribe(() => {
+                if (this.ShowPagination) {
+                    this._updatePagination();
+                }
+                this._alignInkBarToSelectedTab();
+            });
+        });
+    }
+    _updateTabScrollPosition() {
+        const scrollDistance = this.scrollDistance;
+        if (this.PositionMode === 'horizontal') {
+            const translateX = this._getLayoutDirection() === 'ltr' ? -scrollDistance : scrollDistance;
+            this._renderer.setStyle(this._tabList.nativeElement, 'transform', `translate3d(${translateX}px, 0, 0)`);
+        }
+        else {
+            this._renderer.setStyle(this._tabList.nativeElement, 'transform', `translate3d(0,${-scrollDistance}px, 0)`);
+        }
+    }
+    _updatePagination() {
+        this._checkPaginationEnabled();
+        this._checkScrollingControls();
+        this._updateTabScrollPosition();
+    }
+    _checkPaginationEnabled() {
+        this._showPaginationControls = this.tabListScrollWidthHeightPix > this.elementRefOffSetWidthHeight;
+        if (!this._showPaginationControls) {
+            this.scrollDistance = 0;
+        }
+    }
+    _scrollToLabel(labelIndex) {
+        const selectedLabel = this._labelWrappers ? this._labelWrappers.toArray()[labelIndex] : null;
+        if (!selectedLabel) {
+            return;
+        }
+        // The view length is the visible width of the tab labels.
+        let labelBeforePos;
+        let labelAfterPos;
+        if (this.PositionMode === 'horizontal') {
+            if (this._getLayoutDirection() === 'ltr') {
+                labelBeforePos = selectedLabel.getOffsetLeft();
+                labelAfterPos = labelBeforePos + selectedLabel.getOffsetWidth();
+            }
+            else {
+                labelAfterPos = this._tabList.nativeElement.offsetWidth - selectedLabel.getOffsetLeft();
+                labelBeforePos = labelAfterPos - selectedLabel.getOffsetWidth();
+            }
+        }
+        else {
+            labelBeforePos = selectedLabel.getOffsetTop();
+            labelAfterPos = labelBeforePos + selectedLabel.getOffsetHeight();
+        }
+        const beforeVisiblePos = this.scrollDistance;
+        const afterVisiblePos = this.scrollDistance + this.viewWidthHeightPix;
+        if (labelBeforePos < beforeVisiblePos) {
+            // Scroll header to move label to the before direction
+            this.scrollDistance -= beforeVisiblePos - labelBeforePos + EXAGGERATED_OVERSCROLL;
+        }
+        else if (labelAfterPos > afterVisiblePos) {
+            // Scroll header to move label to the after direction
+            this.scrollDistance += labelAfterPos - afterVisiblePos + EXAGGERATED_OVERSCROLL;
+        }
+    }
+    _checkScrollingControls() {
+        // Check if the pagination arrows should be activated.
+        this._disableScrollBefore = this.scrollDistance === 0;
+        this._disableScrollAfter = this.scrollDistance === this._getMaxScrollDistance();
+    }
+    /**
+     * Determines what is the maximum length in pixels that can be set for the scroll distance. This
+     * is equal to the difference in width between the tab list container and tab header container.
+     *
+     * This is an expensive call that forces a layout reflow to compute box and scroll metrics and
+     * should be called sparingly.
+     */
+    _getMaxScrollDistance() {
+        return this.tabListScrollWidthHeightPix - this.viewWidthHeightPix || 0;
+    }
+    /** Sets the distance in pixels that the tab header should be transformed in the X-axis. */
+    set scrollDistance(v) {
+        this._scrollDistance = Math.max(0, Math.min(this._getMaxScrollDistance(), v));
+        // Mark that the scroll distance has changed so that after the view is checked, the CSS
+        // transformation can move the header.
+        this._scrollDistanceChanged = true;
+        this._checkScrollingControls();
+    }
+    get scrollDistance() {
+        return this._scrollDistance;
+    }
+    get viewWidthHeightPix() {
+        let PAGINATION_PIX = 0;
+        if (this._showPaginationControls) {
+            PAGINATION_PIX = 64;
+        }
+        if (this.PositionMode === 'horizontal') {
+            return this._tabListContainer.nativeElement.offsetWidth - PAGINATION_PIX;
+        }
+        else {
+            return this._tabListContainer.nativeElement.offsetHeight - PAGINATION_PIX;
+        }
+    }
+    get tabListScrollWidthHeightPix() {
+        if (this.PositionMode === 'horizontal') {
+            return this._tabList.nativeElement.scrollWidth;
+        }
+        else {
+            return this._tabList.nativeElement.scrollHeight;
+        }
+    }
+    get elementRefOffSetWidthHeight() {
+        if (this.PositionMode === 'horizontal') {
+            return this._elementRef.nativeElement.offsetWidth;
+        }
+        else {
+            return this._elementRef.nativeElement.offsetHeight;
+        }
+    }
+    _getLayoutDirection() {
+        return this._dir && this._dir.value === 'rtl' ? 'rtl' : 'ltr';
+    }
+    _alignInkBarToSelectedTab() {
+        if (this.Type !== 'fillup') {
+            const selectedLabelWrapper = this._labelWrappers && this._labelWrappers.length
+                ? this._labelWrappers.toArray()[this.selectedIndex].elementRef.nativeElement
+                : null;
+            if (this._inkBar) {
+                this._inkBar.alignToElement(selectedLabelWrapper);
+            }
+        }
+    }
+}
+pgTabsNavComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.7", ngImport: i0, type: pgTabsNavComponent, deps: [{ token: i0.ElementRef }, { token: i0.NgZone }, { token: i0.Renderer2 }, { token: i1.Directionality, optional: true }], target: i0.ɵɵFactoryTarget.Component });
+pgTabsNavComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.2.7", type: pgTabsNavComponent, selector: "pg-tabs-nav", inputs: { Size: "Size", Animated: "Animated", Position: "Position", HideBar: "HideBar", Type: "Type", ShowPagination: "ShowPagination", PositionMode: "PositionMode", selectedIndex: "selectedIndex" }, queries: [{ propertyName: "_tabBarExtraContent", first: true, predicate: ["tabBarExtraContent"], descendants: true, static: true }, { propertyName: "_labelWrappers", predicate: pgTabLabelDirective }], viewQueries: [{ propertyName: "_inkBar", first: true, predicate: pgTabsInkBarDirective, descendants: true, static: true }, { propertyName: "_tabListContainer", first: true, predicate: ["tabListContainer"], descendants: true, static: true }, { propertyName: "_tabList", first: true, predicate: ["tabList"], descendants: true, static: true }], ngImport: i0, template: `
+    <div class="nav-tabs-wrapper" [class.scrolling]="_showPaginationControls" #tabListContainer>
+      <div class="nav-wrap">
+        <ul
+          class="nav nav-tabs nav-tabs-{{ _type }} nav-tabs-{{ _tabPosition }}"
+          [class.tabs-nav-animated]="Animated"
+          #tabList
+          (cdkObserveContent)="_onContentChanges()"
+        >
+          <div
+            class="active-bar"
+            pg-tabs-ink-bar
+            [hidden]="HideBar"
+            [Animated]="Animated"
+            [PositionMode]="PositionMode"
+            style="display: block;"
+          ></div>
+          <ng-content></ng-content>
+        </ul>
+      </div>
+    </div>
+  `, isInline: true, directives: [{ type: i2.CdkObserveContent, selector: "[cdkObserveContent]", inputs: ["cdkObserveContentDisabled", "debounce"], outputs: ["cdkObserveContent"], exportAs: ["cdkObserveContent"] }, { type: i3.pgTabsInkBarDirective, selector: "[pg-tabs-ink-bar]", inputs: ["Animated", "PositionMode"] }], encapsulation: i0.ViewEncapsulation.None });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.7", ngImport: i0, type: pgTabsNavComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'pg-tabs-nav',
+                    encapsulation: ViewEncapsulation.None,
+                    template: `
+    <div class="nav-tabs-wrapper" [class.scrolling]="_showPaginationControls" #tabListContainer>
+      <div class="nav-wrap">
+        <ul
+          class="nav nav-tabs nav-tabs-{{ _type }} nav-tabs-{{ _tabPosition }}"
+          [class.tabs-nav-animated]="Animated"
+          #tabList
+          (cdkObserveContent)="_onContentChanges()"
+        >
+          <div
+            class="active-bar"
+            pg-tabs-ink-bar
+            [hidden]="HideBar"
+            [Animated]="Animated"
+            [PositionMode]="PositionMode"
+            style="display: block;"
+          ></div>
+          <ng-content></ng-content>
+        </ul>
+      </div>
+    </div>
+  `,
+                    host: {}
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ElementRef }, { type: i0.NgZone }, { type: i0.Renderer2 }, { type: i1.Directionality, decorators: [{
+                    type: Optional
+                }] }]; }, propDecorators: { Size: [{
+                type: Input
+            }], Animated: [{
+                type: Input
+            }], Position: [{
+                type: Input
+            }], HideBar: [{
+                type: Input
+            }], Type: [{
+                type: Input
+            }], _tabBarExtraContent: [{
+                type: ContentChild,
+                args: ['tabBarExtraContent', { static: true }]
+            }], _labelWrappers: [{
+                type: ContentChildren,
+                args: [pgTabLabelDirective]
+            }], _inkBar: [{
+                type: ViewChild,
+                args: [pgTabsInkBarDirective, { static: true }]
+            }], _tabListContainer: [{
+                type: ViewChild,
+                args: ['tabListContainer', { static: true }]
+            }], _tabList: [{
+                type: ViewChild,
+                args: ['tabList', { static: true }]
+            }], ShowPagination: [{
+                type: Input
+            }], PositionMode: [{
+                type: Input
+            }], selectedIndex: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"tabs-nav.component.js","sourceRoot":"","sources":["../../../../../../projects/mef-dev-ui-tool-kit/src/lib/pg-components/tabs/tabs-nav.component.ts"],"names":[],"mappings":"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","sourcesContent":["/** code from https://github.com/angular/material2 */\r\nimport { Direction, Directionality } from '@angular/cdk/bidi';\r\nimport {\r\n  AfterContentChecked,\r\n  AfterContentInit,\r\n  Component,\r\n  ContentChild,\r\n  ContentChildren,\r\n  ElementRef,\r\n  HostBinding,\r\n  Input,\r\n  NgZone,\r\n  Optional,\r\n  QueryList,\r\n  Renderer2,\r\n  TemplateRef,\r\n  ViewChild,\r\n  ViewEncapsulation\r\n} from '@angular/core';\r\nimport { Subscription, fromEvent, merge, of as observableOf } from 'rxjs';\r\nimport { auditTime, startWith } from 'rxjs/operators';\r\nimport { toBoolean } from '../util/convert';\r\nimport { pgTabLabelDirective } from './tab-label.directive';\r\nimport { pgTabsInkBarDirective } from './tabs-ink-bar.directive';\r\n\r\nconst EXAGGERATED_OVERSCROLL = 64;\r\nexport type ScrollDirection = 'after' | 'before';\r\n\r\n/** duplicated defined https://github.com/angular/angular-cli/issues/2034 **/\r\nexport type TabPositionMode = 'horizontal' | 'vertical';\r\n\r\n@Component({\r\n  selector: 'pg-tabs-nav',\r\n  encapsulation: ViewEncapsulation.None,\r\n  template: `\r\n    <div class=\"nav-tabs-wrapper\" [class.scrolling]=\"_showPaginationControls\" #tabListContainer>\r\n      <div class=\"nav-wrap\">\r\n        <ul\r\n          class=\"nav nav-tabs nav-tabs-{{ _type }} nav-tabs-{{ _tabPosition }}\"\r\n          [class.tabs-nav-animated]=\"Animated\"\r\n          #tabList\r\n          (cdkObserveContent)=\"_onContentChanges()\"\r\n        >\r\n          <div\r\n            class=\"active-bar\"\r\n            pg-tabs-ink-bar\r\n            [hidden]=\"HideBar\"\r\n            [Animated]=\"Animated\"\r\n            [PositionMode]=\"PositionMode\"\r\n            style=\"display: block;\"\r\n          ></div>\r\n          <ng-content></ng-content>\r\n        </ul>\r\n      </div>\r\n    </div>\r\n  `,\r\n  host: {}\r\n})\r\nexport class pgTabsNavComponent implements AfterContentChecked, AfterContentInit {\r\n  private _animated = true;\r\n  private _hideBar = false;\r\n  private _showPagination = true;\r\n\r\n  _showPaginationControls = false;\r\n  _disableScrollAfter = true;\r\n  _disableScrollBefore = true;\r\n  _scrollDistance = 0;\r\n  _selectedIndexChanged = false;\r\n  _realignInkBar: Subscription | null = null;\r\n  _tabLabelCount: number;\r\n  _scrollDistanceChanged: boolean;\r\n  _selectedIndex = 0;\r\n  _tabPositionMode: TabPositionMode = 'horizontal';\r\n  _tabPosition = 'top';\r\n  @Input() Size = 'default';\r\n  _type = 'line';\r\n\r\n  @Input()\r\n  set Animated(value: boolean) {\r\n    this._animated = toBoolean(value);\r\n  }\r\n\r\n  get Animated(): boolean {\r\n    return this._animated;\r\n  }\r\n\r\n  @Input()\r\n  set Position(value: string) {\r\n    this._tabPosition = value;\r\n  }\r\n\r\n  get Position(): string {\r\n    return this._tabPosition;\r\n  }\r\n\r\n  @Input()\r\n  set HideBar(value: boolean) {\r\n    this._hideBar = toBoolean(value);\r\n  }\r\n\r\n  get HideBar(): boolean {\r\n    return this._hideBar;\r\n  }\r\n\r\n  @Input()\r\n  set Type(value: string) {\r\n    this._type = value;\r\n  }\r\n\r\n  get Type(): string {\r\n    return this._type;\r\n  }\r\n\r\n  @ContentChild('tabBarExtraContent', { static: true }) _tabBarExtraContent: TemplateRef<void>;\r\n  @ContentChildren(pgTabLabelDirective) _labelWrappers: QueryList<pgTabLabelDirective>;\r\n  @ViewChild(pgTabsInkBarDirective, { static: true }) _inkBar: pgTabsInkBarDirective;\r\n  @ViewChild('tabListContainer', { static: true }) _tabListContainer: ElementRef;\r\n  @ViewChild('tabList', { static: true }) _tabList: ElementRef;\r\n\r\n  @Input()\r\n  set ShowPagination(value: boolean) {\r\n    this._showPagination = toBoolean(value);\r\n  }\r\n\r\n  get ShowPagination(): boolean {\r\n    return this._showPagination;\r\n  }\r\n\r\n  @Input()\r\n  set PositionMode(value: TabPositionMode) {\r\n    this._tabPositionMode = value;\r\n    this._alignInkBarToSelectedTab();\r\n    if (this.ShowPagination) {\r\n      this._updatePagination();\r\n    }\r\n  }\r\n\r\n  get PositionMode(): TabPositionMode {\r\n    return this._tabPositionMode;\r\n  }\r\n\r\n  @Input()\r\n  set selectedIndex(value: number) {\r\n    this._selectedIndexChanged = this._selectedIndex !== value;\r\n\r\n    this._selectedIndex = value;\r\n  }\r\n\r\n  get selectedIndex(): number {\r\n    return this._selectedIndex;\r\n  }\r\n\r\n  constructor(\r\n    public _elementRef: ElementRef,\r\n    private _ngZone: NgZone,\r\n    private _renderer: Renderer2,\r\n    @Optional() private _dir: Directionality\r\n  ) {}\r\n\r\n  _onContentChanges(): void {\r\n    if (this.ShowPagination) {\r\n      this._updatePagination();\r\n    }\r\n    this._alignInkBarToSelectedTab();\r\n  }\r\n\r\n  _scrollHeader(scrollDir: ScrollDirection): void {\r\n    // Move the scroll distance one-third the length of the tab list's viewport.\r\n    this.scrollDistance += ((scrollDir === 'before' ? -1 : 1) * this.viewWidthHeightPix) / 3;\r\n  }\r\n\r\n  ngAfterContentChecked(): void {\r\n    if (this._tabLabelCount !== this._labelWrappers.length) {\r\n      if (this.ShowPagination) {\r\n        this._updatePagination();\r\n      }\r\n      this._tabLabelCount = this._labelWrappers.length;\r\n    }\r\n    if (this._selectedIndexChanged) {\r\n      this._scrollToLabel(this._selectedIndex);\r\n      if (this.ShowPagination) {\r\n        this._checkScrollingControls();\r\n      }\r\n      this._alignInkBarToSelectedTab();\r\n      this._selectedIndexChanged = false;\r\n    }\r\n    if (this._scrollDistanceChanged) {\r\n      if (this.ShowPagination) {\r\n        this._updateTabScrollPosition();\r\n      }\r\n      this._scrollDistanceChanged = false;\r\n    }\r\n  }\r\n\r\n  ngAfterContentInit(): void {\r\n    this._realignInkBar = this._ngZone.runOutsideAngular(() => {\r\n      const dirChange = this._dir ? this._dir.change : observableOf(null);\r\n      const resize = typeof window !== 'undefined' ? fromEvent(window, 'resize').pipe(auditTime(10)) : observableOf(null);\r\n      //@ts-ignore\r\n      return merge(dirChange, resize)\r\n        .pipe(startWith(null))\r\n        .subscribe(() => {\r\n          if (this.ShowPagination) {\r\n            this._updatePagination();\r\n          }\r\n          this._alignInkBarToSelectedTab();\r\n        });\r\n    });\r\n  }\r\n\r\n  _updateTabScrollPosition(): void {\r\n    const scrollDistance = this.scrollDistance;\r\n    if (this.PositionMode === 'horizontal') {\r\n      const translateX = this._getLayoutDirection() === 'ltr' ? -scrollDistance : scrollDistance;\r\n      this._renderer.setStyle(this._tabList.nativeElement, 'transform', `translate3d(${translateX}px, 0, 0)`);\r\n    } else {\r\n      this._renderer.setStyle(this._tabList.nativeElement, 'transform', `translate3d(0,${-scrollDistance}px, 0)`);\r\n    }\r\n  }\r\n\r\n  _updatePagination(): void {\r\n    this._checkPaginationEnabled();\r\n    this._checkScrollingControls();\r\n    this._updateTabScrollPosition();\r\n  }\r\n\r\n  _checkPaginationEnabled(): void {\r\n    this._showPaginationControls = this.tabListScrollWidthHeightPix > this.elementRefOffSetWidthHeight;\r\n\r\n    if (!this._showPaginationControls) {\r\n      this.scrollDistance = 0;\r\n    }\r\n  }\r\n\r\n  _scrollToLabel(labelIndex: number): void {\r\n    const selectedLabel = this._labelWrappers ? this._labelWrappers.toArray()[labelIndex] : null;\r\n\r\n    if (!selectedLabel) {\r\n      return;\r\n    }\r\n\r\n    // The view length is the visible width of the tab labels.\r\n\r\n    let labelBeforePos: number;\r\n    let labelAfterPos: number;\r\n    if (this.PositionMode === 'horizontal') {\r\n      if (this._getLayoutDirection() === 'ltr') {\r\n        labelBeforePos = selectedLabel.getOffsetLeft();\r\n        labelAfterPos = labelBeforePos + selectedLabel.getOffsetWidth();\r\n      } else {\r\n        labelAfterPos = this._tabList.nativeElement.offsetWidth - selectedLabel.getOffsetLeft();\r\n        labelBeforePos = labelAfterPos - selectedLabel.getOffsetWidth();\r\n      }\r\n    } else {\r\n      labelBeforePos = selectedLabel.getOffsetTop();\r\n      labelAfterPos = labelBeforePos + selectedLabel.getOffsetHeight();\r\n    }\r\n    const beforeVisiblePos = this.scrollDistance;\r\n    const afterVisiblePos = this.scrollDistance + this.viewWidthHeightPix;\r\n\r\n    if (labelBeforePos < beforeVisiblePos) {\r\n      // Scroll header to move label to the before direction\r\n      this.scrollDistance -= beforeVisiblePos - labelBeforePos + EXAGGERATED_OVERSCROLL;\r\n    } else if (labelAfterPos > afterVisiblePos) {\r\n      // Scroll header to move label to the after direction\r\n      this.scrollDistance += labelAfterPos - afterVisiblePos + EXAGGERATED_OVERSCROLL;\r\n    }\r\n  }\r\n\r\n  _checkScrollingControls(): void {\r\n    // Check if the pagination arrows should be activated.\r\n    this._disableScrollBefore = this.scrollDistance === 0;\r\n    this._disableScrollAfter = this.scrollDistance === this._getMaxScrollDistance();\r\n  }\r\n\r\n  /**\r\n   * Determines what is the maximum length in pixels that can be set for the scroll distance. This\r\n   * is equal to the difference in width between the tab list container and tab header container.\r\n   *\r\n   * This is an expensive call that forces a layout reflow to compute box and scroll metrics and\r\n   * should be called sparingly.\r\n   */\r\n  _getMaxScrollDistance(): number {\r\n    return this.tabListScrollWidthHeightPix - this.viewWidthHeightPix || 0;\r\n  }\r\n\r\n  /** Sets the distance in pixels that the tab header should be transformed in the X-axis. */\r\n  set scrollDistance(v: number) {\r\n    this._scrollDistance = Math.max(0, Math.min(this._getMaxScrollDistance(), v));\r\n\r\n    // Mark that the scroll distance has changed so that after the view is checked, the CSS\r\n    // transformation can move the header.\r\n    this._scrollDistanceChanged = true;\r\n\r\n    this._checkScrollingControls();\r\n  }\r\n\r\n  get scrollDistance(): number {\r\n    return this._scrollDistance;\r\n  }\r\n\r\n  get viewWidthHeightPix(): number {\r\n    let PAGINATION_PIX = 0;\r\n    if (this._showPaginationControls) {\r\n      PAGINATION_PIX = 64;\r\n    }\r\n    if (this.PositionMode === 'horizontal') {\r\n      return this._tabListContainer.nativeElement.offsetWidth - PAGINATION_PIX;\r\n    } else {\r\n      return this._tabListContainer.nativeElement.offsetHeight - PAGINATION_PIX;\r\n    }\r\n  }\r\n\r\n  get tabListScrollWidthHeightPix(): number {\r\n    if (this.PositionMode === 'horizontal') {\r\n      return this._tabList.nativeElement.scrollWidth;\r\n    } else {\r\n      return this._tabList.nativeElement.scrollHeight;\r\n    }\r\n  }\r\n\r\n  get elementRefOffSetWidthHeight(): number {\r\n    if (this.PositionMode === 'horizontal') {\r\n      return this._elementRef.nativeElement.offsetWidth;\r\n    } else {\r\n      return this._elementRef.nativeElement.offsetHeight;\r\n    }\r\n  }\r\n\r\n  _getLayoutDirection(): Direction {\r\n    return this._dir && this._dir.value === 'rtl' ? 'rtl' : 'ltr';\r\n  }\r\n\r\n  _alignInkBarToSelectedTab(): void {\r\n    if (this.Type !== 'fillup') {\r\n      const selectedLabelWrapper =\r\n        this._labelWrappers && this._labelWrappers.length\r\n          ? this._labelWrappers.toArray()[this.selectedIndex].elementRef.nativeElement\r\n          : null;\r\n      if (this._inkBar) {\r\n        this._inkBar.alignToElement(selectedLabelWrapper);\r\n      }\r\n    }\r\n  }\r\n}\r\n"]}

package/esm2020/lib/pg-components/tabs/tabs.module.mjs

@@ -0,0 +1,24 @@
+import { ObserversModule } from '@angular/cdk/observers';
+import { CommonModule } from '@angular/common';
+import { NgModule } from '@angular/core';
+import { pgTabBodyComponent } from './tab-body.component';
+import { pgTabLabelDirective } from './tab-label.directive';
+import { pgTabComponent } from './tab.component';
+import { pgTabsInkBarDirective } from './tabs-ink-bar.directive';
+import { pgTabsNavComponent } from './tabs-nav.component';
+import { pgTabSetComponent } from './tabset.component';
+import * as i0 from "@angular/core";
+export class pgTabsModule {
+}
+pgTabsModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.7", ngImport: i0, type: pgTabsModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+pgTabsModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "12.0.0", version: "13.2.7", ngImport: i0, type: pgTabsModule, declarations: [pgTabComponent, pgTabSetComponent, pgTabsNavComponent, pgTabLabelDirective, pgTabsInkBarDirective, pgTabBodyComponent], imports: [CommonModule, ObserversModule], exports: [pgTabComponent, pgTabSetComponent, pgTabsNavComponent, pgTabLabelDirective, pgTabsInkBarDirective, pgTabBodyComponent] });
+pgTabsModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "13.2.7", ngImport: i0, type: pgTabsModule, imports: [[CommonModule, ObserversModule]] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.7", ngImport: i0, type: pgTabsModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    declarations: [pgTabComponent, pgTabSetComponent, pgTabsNavComponent, pgTabLabelDirective, pgTabsInkBarDirective, pgTabBodyComponent],
+                    exports: [pgTabComponent, pgTabSetComponent, pgTabsNavComponent, pgTabLabelDirective, pgTabsInkBarDirective, pgTabBodyComponent],
+                    imports: [CommonModule, ObserversModule]
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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