@fundamental-ngx/core 0.35.3 → 0.35.4-rc.10

package/overflow-layout/esm2020/overflow-layout.service.mjs

@@ -0,0 +1,241 @@
+import { FocusKeyManager } from '@angular/cdk/a11y';
+import { ElementRef, Injectable, Optional } from '@angular/core';
+import { resizeObservable } from '@fundamental-ngx/core/utils';
+import { debounceTime, distinctUntilChanged, filter, skip, Subject, Subscription } from 'rxjs';
+import * as i0 from "@angular/core";
+import * as i1 from "@fundamental-ngx/core/utils";
+export class OverflowLayoutListeningResult {
+    constructor() {
+        this.showMore = false;
+        this.items = [];
+        this.hiddenItems = [];
+        this.visibleItems = [];
+    }
+}
+export class OverflowLayoutService {
+    /** @hidden */
+    constructor(_elRef, _rtlService) {
+        this._elRef = _elRef;
+        this._rtlService = _rtlService;
+        /**
+         * Overflow Layout calculation result.
+         */
+        this.result = new OverflowLayoutListeningResult();
+        /** @hidden */
+        this._listenToItemResize = true;
+        /** @hidden */
+        this._subscription = new Subscription();
+        /** @hidden */
+        this._allItems = [];
+        /** @hidden */
+        this._hiddenItems = [];
+        /** @hidden */
+        this._overflowItems = [];
+        /** @hidden */
+        this._detectChanges$ = new Subject();
+        /** @hidden */
+        this._result$ = new Subject();
+        /** @hidden */
+        this._dir = 'ltr';
+    }
+    /**
+     * Observable which emits when changes detection is required.
+     */
+    get detectChanges() {
+        return this._detectChanges$.asObservable();
+    }
+    /**
+     * Observable which emits when new calculation result is available.
+     */
+    get onResult() {
+        return this._result$.asObservable();
+    }
+    /** @hidden */
+    ngOnDestroy() {
+        this._subscription.unsubscribe();
+    }
+    startListening(config) {
+        this.setConfig(config);
+        this.fitVisibleItems();
+        this._setFocusKeyManager();
+        this._listenToChanges();
+        this._subscribeToRtl();
+    }
+    setConfig(config) {
+        this.config = config;
+    }
+    _emitResult() {
+        this._result$.next(this.result);
+    }
+    /** @hidden */
+    _listenToChanges() {
+        this._subscription.add(this.config.items.changes.subscribe(() => {
+            setTimeout(() => {
+                this.fitVisibleItems();
+            });
+        }));
+        this._listenToSizeChanges(this._elRef.nativeElement, this.config.itemsWrapper);
+    }
+    /** @hidden */
+    _listenToSizeChanges(...elements) {
+        elements.forEach((element) => this._subscription.add(resizeObservable(element)
+            .pipe(skip(1), filter(() => this._listenToItemResize), distinctUntilChanged(), debounceTime(30))
+            .subscribe(() => {
+            setTimeout(() => {
+                this.fitVisibleItems();
+            });
+        })));
+    }
+    /** @hidden */
+    fitVisibleItems() {
+        this._listenToItemResize = false;
+        this._allItems = this.config.items.toArray();
+        let allItems = this.config.items.toArray();
+        let visibleContainerItems = this.config.visibleItems.toArray();
+        allItems.forEach((item, index) => {
+            // Softly hide previously completely hidden item in order to correctly calculate it's size.
+            item.softHidden = true;
+            item.hidden = false;
+            item.index = index;
+            item.first = index === 0;
+            item.last = index === allItems.length - 1;
+            visibleContainerItems[index].containerRef.hidden = false;
+        });
+        this._detectChanges$.next();
+        allItems = this.config.direction === 'right' ? allItems : allItems.reverse();
+        visibleContainerItems =
+            this.config.direction === 'right' ? visibleContainerItems : visibleContainerItems.reverse();
+        this.result.showMore = false;
+        this._emitResult();
+        const containerWidth = this._elRef.nativeElement.getBoundingClientRect().width;
+        const itemsContainerWidth = this.config.itemsWrapper.getBoundingClientRect().width;
+        if (containerWidth >= itemsContainerWidth &&
+            this.config.visibleItems.length <= this.config.maxVisibleItems &&
+            this._hiddenItems.length === 0) {
+            // Make all items fully visible.
+            allItems.forEach((item) => {
+                item.softHidden = false;
+            });
+            this.result.showMore = false;
+            this.result.hiddenItems = this._hiddenItems;
+            this._emitResult();
+            this._listenToItemResize = true;
+            return;
+        }
+        this.result.showMore = true;
+        this._emitResult();
+        let fittingElmCount = 0;
+        let fittingElmsWidth = 0;
+        let shouldHideItems = false;
+        const showMoreContainerWidth = Math.ceil(this.config.showMoreContainer.getBoundingClientRect().width);
+        let layoutWidth = Math.ceil(this.config.layoutContainerElement.getBoundingClientRect().width);
+        // Try to find all forced visible items
+        const forcedItemsIndexes = this._getForcedItemsIndexes();
+        forcedItemsIndexes.forEach((itemIndex) => {
+            const container = this.config.visibleItems.get(itemIndex);
+            if (!container) {
+                return;
+            }
+            const elementSize = this._getElementWidth(container.elementRef.nativeElement);
+            layoutWidth -= elementSize;
+        });
+        if (layoutWidth < 0 && forcedItemsIndexes.length > 0) {
+            console.warn('There is no enough space to fit all forced visible items into the container. Please adjust their visibility accordingly.');
+        }
+        this._detectChanges$.next();
+        visibleContainerItems.forEach((item, index) => {
+            const itemRef = allItems[index];
+            if (shouldHideItems && !itemRef.overflowItem.forceVisibility) {
+                item.containerRef.hidden = true;
+                item.softHidden = false;
+                itemRef.hidden = true;
+                return;
+            }
+            const elementSize = this._getElementWidth(item.elementRef.nativeElement);
+            const combinedWidth = fittingElmsWidth + elementSize;
+            const condition = (combinedWidth <= layoutWidth ||
+                (item === this.config.visibleItems.last &&
+                    combinedWidth <= layoutWidth + showMoreContainerWidth)) &&
+                fittingElmCount < this.config.maxVisibleItems;
+            if (condition) {
+                fittingElmsWidth += elementSize;
+                fittingElmCount++;
+            }
+            else if (!itemRef.overflowItem.forceVisibility) {
+                shouldHideItems = true;
+                item.softHidden = false;
+                item.containerRef.hidden = true;
+                itemRef.hidden = true;
+            }
+        });
+        // Reverse original order back.
+        allItems = this.config.direction === 'right' ? allItems : allItems.reverse();
+        allItems.forEach((item) => {
+            item.softHidden = false;
+        });
+        let hiddenItems = allItems.filter((i) => i.hidden);
+        hiddenItems = !this.config.reverseHiddenItems ? hiddenItems.reverse() : hiddenItems;
+        const visibleItems = allItems.filter((i) => !i.hidden);
+        visibleItems.forEach((item, index) => {
+            item.index = index;
+            item.first = index === 0;
+            item.last = index === visibleItems.length - 1;
+        });
+        this._hiddenItems = hiddenItems.map((item, index) => {
+            item.first = index === 0;
+            item.last = index === hiddenItems.length - 1;
+            item.index = index;
+            return item;
+        });
+        this.result.showMore = this._hiddenItems.length > 0;
+        this.result.hiddenItems = this._hiddenItems;
+        this._emitResult();
+        this._listenToItemResize = true;
+    }
+    /** @hidden */
+    _setFocusKeyManager() {
+        if (!this.config.enableKeyboardNavigation) {
+            return;
+        }
+        this._dir = this._rtlService?.rtl.value ? 'rtl' : 'ltr';
+        this._keyboardEventsManager = new FocusKeyManager(this._overflowItems)
+            .withWrap()
+            .withHorizontalOrientation(this._dir)
+            .skipPredicate((item) => !item.focusable || item.hidden);
+    }
+    /** @hidden Rtl change subscription */
+    _subscribeToRtl() {
+        if (!this._rtlService || !this.config.enableKeyboardNavigation) {
+            return;
+        }
+        this._subscription.add(this._rtlService.rtl.subscribe((isRtl) => {
+            this._dir = isRtl ? 'rtl' : 'ltr';
+            this._keyboardEventsManager = this._keyboardEventsManager.withHorizontalOrientation(this._dir);
+        }));
+    }
+    /** @hidden */
+    _getForcedItemsIndexes() {
+        return this._allItems
+            .map((item, index) => (item.overflowItem.forceVisibility ? index : -1))
+            .filter((i) => i > -1);
+    }
+    /**
+     * @hidden
+     * Returns combined width of the element including margins.
+     * @param element Element to calculate width of.
+     */
+    _getElementWidth(element) {
+        const elementStyle = getComputedStyle(element);
+        const elementWidth = element.getBoundingClientRect().width;
+        const elementSize = elementWidth + parseFloat(elementStyle.marginLeft) + parseFloat(elementStyle.marginRight);
+        return Math.ceil(elementSize);
+    }
+}
+OverflowLayoutService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.4", ngImport: i0, type: OverflowLayoutService, deps: [{ token: i0.ElementRef }, { token: i1.RtlService, optional: true }], target: i0.ɵɵFactoryTarget.Injectable });
+OverflowLayoutService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.2.4", ngImport: i0, type: OverflowLayoutService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.4", ngImport: i0, type: OverflowLayoutService, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i0.ElementRef }, { type: i1.RtlService, decorators: [{
+                    type: Optional
+                }] }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"overflow-layout.service.js","sourceRoot":"","sources":["../../../../../libs/core/src/lib/overflow-layout/overflow-layout.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { FocusKeyManager } from '@angular/cdk/a11y';\nimport { ElementRef, Injectable, OnDestroy, Optional, QueryList } from '@angular/core';\nimport { resizeObservable, RtlService } from '@fundamental-ngx/core/utils';\nimport { debounceTime, distinctUntilChanged, filter, Observable, skip, Subject, Subscription } from 'rxjs';\nimport { OverflowLayoutItemContainerDirective } from './directives/overflow-layout-item-container.directive';\nimport { OverflowItemRef } from './interfaces/overflow-item-ref.interface';\nimport { OverflowItem } from './interfaces/overflow-item.interface';\n\nexport interface OverflowLayoutConfig {\n    items: QueryList<OverflowItemRef>;\n    visibleItems: QueryList<OverflowLayoutItemContainerDirective>;\n    itemsWrapper: HTMLElement;\n    showMoreContainer: HTMLElement;\n    layoutContainerElement: HTMLElement;\n    maxVisibleItems: number;\n    direction: 'left' | 'right';\n    enableKeyboardNavigation: boolean;\n    reverseHiddenItems: boolean;\n}\n\nexport class OverflowLayoutListeningResult {\n    showMore = false;\n    items: OverflowItemRef[] = [];\n    hiddenItems: OverflowItemRef[] = [];\n    visibleItems: OverflowItemRef[] = [];\n}\n\n@Injectable()\nexport class OverflowLayoutService implements OnDestroy {\n    /**\n     * Overflow Layout config.\n     */\n    config: OverflowLayoutConfig;\n\n    /**\n     * Overflow Layout calculation result.\n     */\n    result = new OverflowLayoutListeningResult();\n\n    /** @hidden */\n    _keyboardEventsManager: FocusKeyManager<OverflowItem>;\n\n    /** @hidden */\n    private _listenToItemResize = true;\n\n    /** @hidden */\n    private readonly _subscription = new Subscription();\n\n    /** @hidden */\n    private _allItems: OverflowItemRef[] = [];\n\n    /** @hidden */\n    private _hiddenItems: OverflowItemRef[] = [];\n\n    /** @hidden */\n    private _overflowItems: OverflowItem[] = [];\n\n    /** @hidden */\n    private _detectChanges$ = new Subject<void>();\n\n    /** @hidden */\n    private _result$ = new Subject<OverflowLayoutListeningResult>();\n\n    /** @hidden */\n    private _dir: 'rtl' | 'ltr' = 'ltr';\n\n    /**\n     * Observable which emits when changes detection is required.\n     */\n    get detectChanges(): Observable<void> {\n        return this._detectChanges$.asObservable();\n    }\n\n    /**\n     * Observable which emits when new calculation result is available.\n     */\n    get onResult(): Observable<OverflowLayoutListeningResult> {\n        return this._result$.asObservable();\n    }\n\n    /** @hidden */\n    constructor(private _elRef: ElementRef<HTMLElement>, @Optional() private _rtlService: RtlService | null) {}\n\n    /** @hidden */\n    ngOnDestroy(): void {\n        this._subscription.unsubscribe();\n    }\n\n    startListening(config: OverflowLayoutConfig): void {\n        this.setConfig(config);\n        this.fitVisibleItems();\n        this._setFocusKeyManager();\n        this._listenToChanges();\n        this._subscribeToRtl();\n    }\n\n    setConfig(config: OverflowLayoutConfig): void {\n        this.config = config;\n    }\n\n    private _emitResult(): void {\n        this._result$.next(this.result);\n    }\n\n    /** @hidden */\n    private _listenToChanges(): void {\n        this._subscription.add(\n            this.config.items.changes.subscribe(() => {\n                setTimeout(() => {\n                    this.fitVisibleItems();\n                });\n            })\n        );\n\n        this._listenToSizeChanges(this._elRef.nativeElement, this.config.itemsWrapper);\n    }\n\n    /** @hidden */\n    private _listenToSizeChanges(...elements: HTMLElement[]): void {\n        elements.forEach((element) =>\n            this._subscription.add(\n                resizeObservable(element)\n                    .pipe(\n                        skip(1),\n                        filter(() => this._listenToItemResize),\n                        distinctUntilChanged(),\n                        debounceTime(30)\n                    )\n                    .subscribe(() => {\n                        setTimeout(() => {\n                            this.fitVisibleItems();\n                        });\n                    })\n            )\n        );\n    }\n\n    /** @hidden */\n    fitVisibleItems(): void {\n        this._listenToItemResize = false;\n        this._allItems = this.config.items.toArray();\n\n        let allItems = this.config.items.toArray();\n        let visibleContainerItems = this.config.visibleItems.toArray();\n\n        allItems.forEach((item, index) => {\n            // Softly hide previously completely hidden item in order to correctly calculate it's size.\n            item.softHidden = true;\n            item.hidden = false;\n            item.index = index;\n            item.first = index === 0;\n            item.last = index === allItems.length - 1;\n            visibleContainerItems[index].containerRef.hidden = false;\n        });\n\n        this._detectChanges$.next();\n\n        allItems = this.config.direction === 'right' ? allItems : allItems.reverse();\n        visibleContainerItems =\n            this.config.direction === 'right' ? visibleContainerItems : visibleContainerItems.reverse();\n\n        this.result.showMore = false;\n        this._emitResult();\n        const containerWidth = this._elRef.nativeElement.getBoundingClientRect().width;\n        const itemsContainerWidth = this.config.itemsWrapper.getBoundingClientRect().width;\n\n        if (\n            containerWidth >= itemsContainerWidth &&\n            this.config.visibleItems.length <= this.config.maxVisibleItems &&\n            this._hiddenItems.length === 0\n        ) {\n            // Make all items fully visible.\n            allItems.forEach((item) => {\n                item.softHidden = false;\n            });\n            this.result.showMore = false;\n            this.result.hiddenItems = this._hiddenItems;\n            this._emitResult();\n            this._listenToItemResize = true;\n            return;\n        }\n        this.result.showMore = true;\n        this._emitResult();\n        let fittingElmCount = 0;\n        let fittingElmsWidth = 0;\n        let shouldHideItems = false;\n\n        const showMoreContainerWidth = Math.ceil(this.config.showMoreContainer.getBoundingClientRect().width);\n        let layoutWidth = Math.ceil(this.config.layoutContainerElement.getBoundingClientRect().width);\n\n        // Try to find all forced visible items\n        const forcedItemsIndexes = this._getForcedItemsIndexes();\n\n        forcedItemsIndexes.forEach((itemIndex) => {\n            const container = this.config.visibleItems.get(itemIndex);\n            if (!container) {\n                return;\n            }\n            const elementSize = this._getElementWidth(container.elementRef.nativeElement);\n\n            layoutWidth -= elementSize;\n        });\n\n        if (layoutWidth < 0 && forcedItemsIndexes.length > 0) {\n            console.warn(\n                'There is no enough space to fit all forced visible items into the container. Please adjust their visibility accordingly.'\n            );\n        }\n\n        this._detectChanges$.next();\n\n        visibleContainerItems.forEach((item, index) => {\n            const itemRef = allItems[index];\n            if (shouldHideItems && !itemRef.overflowItem.forceVisibility) {\n                item.containerRef.hidden = true;\n                item.softHidden = false;\n                itemRef.hidden = true;\n                return;\n            }\n\n            const elementSize = this._getElementWidth(item.elementRef.nativeElement);\n            const combinedWidth = fittingElmsWidth + elementSize;\n\n            const condition =\n                (combinedWidth <= layoutWidth ||\n                    (item === this.config.visibleItems.last &&\n                        combinedWidth <= layoutWidth + showMoreContainerWidth)) &&\n                fittingElmCount < this.config.maxVisibleItems;\n\n            if (condition) {\n                fittingElmsWidth += elementSize;\n                fittingElmCount++;\n            } else if (!itemRef.overflowItem.forceVisibility) {\n                shouldHideItems = true;\n                item.softHidden = false;\n                item.containerRef.hidden = true;\n                itemRef.hidden = true;\n            }\n        });\n\n        // Reverse original order back.\n        allItems = this.config.direction === 'right' ? allItems : allItems.reverse();\n\n        allItems.forEach((item) => {\n            item.softHidden = false;\n        });\n\n        let hiddenItems = allItems.filter((i) => i.hidden);\n        hiddenItems = !this.config.reverseHiddenItems ? hiddenItems.reverse() : hiddenItems;\n        const visibleItems = allItems.filter((i) => !i.hidden);\n\n        visibleItems.forEach((item, index) => {\n            item.index = index;\n            item.first = index === 0;\n            item.last = index === visibleItems.length - 1;\n        });\n\n        this._hiddenItems = hiddenItems.map((item, index) => {\n            item.first = index === 0;\n            item.last = index === hiddenItems.length - 1;\n            item.index = index;\n            return item;\n        });\n\n        this.result.showMore = this._hiddenItems.length > 0;\n        this.result.hiddenItems = this._hiddenItems;\n        this._emitResult();\n\n        this._listenToItemResize = true;\n    }\n\n    /** @hidden */\n    private _setFocusKeyManager(): void {\n        if (!this.config.enableKeyboardNavigation) {\n            return;\n        }\n        this._dir = this._rtlService?.rtl.value ? 'rtl' : 'ltr';\n        this._keyboardEventsManager = new FocusKeyManager(this._overflowItems)\n            .withWrap()\n            .withHorizontalOrientation(this._dir)\n            .skipPredicate((item) => !item.focusable || item.hidden);\n    }\n\n    /** @hidden Rtl change subscription */\n    private _subscribeToRtl(): void {\n        if (!this._rtlService || !this.config.enableKeyboardNavigation) {\n            return;\n        }\n\n        this._subscription.add(\n            this._rtlService.rtl.subscribe((isRtl) => {\n                this._dir = isRtl ? 'rtl' : 'ltr';\n\n                this._keyboardEventsManager = this._keyboardEventsManager.withHorizontalOrientation(this._dir);\n            })\n        );\n    }\n\n    /** @hidden */\n    private _getForcedItemsIndexes(): number[] {\n        return this._allItems\n            .map((item, index) => (item.overflowItem.forceVisibility ? index : -1))\n            .filter((i) => i > -1);\n    }\n\n    /**\n     * @hidden\n     * Returns combined width of the element including margins.\n     * @param element Element to calculate width of.\n     */\n    private _getElementWidth(element: HTMLElement): number {\n        const elementStyle = getComputedStyle(element);\n        const elementWidth = element.getBoundingClientRect().width;\n        const elementSize = elementWidth + parseFloat(elementStyle.marginLeft) + parseFloat(elementStyle.marginRight);\n\n        return Math.ceil(elementSize);\n    }\n}\n"]}