@fundamental-ngx/cdk 0.38.3-rc.4

package/esm2020/utils/services/resize-observer.service.mjs

@@ -0,0 +1,94 @@
+import { Injectable } from '@angular/core';
+import { Observable, Subject } from 'rxjs';
+import { coerceElement } from '@angular/cdk/coercion';
+import * as i0 from "@angular/core";
+export class ResizeObserverFactory {
+    /** Factory to create ResizeObserver if it's present in browser.  */
+    create(callback) {
+        return typeof ResizeObserver === 'undefined' ? null : new ResizeObserver(callback);
+    }
+}
+ResizeObserverFactory.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.0.2", ngImport: i0, type: ResizeObserverFactory, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+ResizeObserverFactory.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.0.2", ngImport: i0, type: ResizeObserverFactory, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.0.2", ngImport: i0, type: ResizeObserverFactory, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
+export class ResizeObserverService {
+    /** @hidden */
+    constructor(_resizeObserverFactory) {
+        this._resizeObserverFactory = _resizeObserverFactory;
+        /** @hidden */
+        this._observedElements = new Map();
+    }
+    /** @hidden */
+    ngOnDestroy() {
+        this._observedElements.forEach((_, element) => this._cleanupObserver(element));
+    }
+    /** Observe the given element and emit whenever its size changes. */
+    observe(elementOrRef) {
+        const element = coerceElement(elementOrRef);
+        return new Observable((observer) => {
+            const stream = this._observeElement(element);
+            const subscription = stream?.subscribe(observer);
+            return () => {
+                subscription?.unsubscribe();
+                this._unobserveElement(element);
+            };
+        });
+    }
+    /**
+     * Observes the given element by using the existing MutationObserver if available, or creating a
+     * new one if not.
+     */
+    _observeElement(element) {
+        const observedElement = this._observedElements.get(element);
+        if (!observedElement) {
+            const stream = new Subject();
+            const observer = this._resizeObserverFactory.create((mutations) => stream.next(mutations));
+            if (observer) {
+                observer.observe(element);
+            }
+            this._observedElements.set(element, { observer, stream, count: 1 });
+        }
+        else {
+            observedElement.count++;
+        }
+        return observedElement?.stream;
+    }
+    /**
+     * Un-observes the given element and cleans up the underlying MutationObserver if nobody else is
+     * observing this element.
+     */
+    _unobserveElement(element) {
+        const observedElement = this._observedElements.get(element);
+        if (!observedElement) {
+            return;
+        }
+        observedElement.count--;
+        if (!observedElement.count) {
+            return;
+        }
+        this._cleanupObserver(element);
+    }
+    /** Clean up the underlying MutationObserver for the specified element. */
+    _cleanupObserver(element) {
+        const observedElement = this._observedElements.get(element);
+        if (!observedElement) {
+            return;
+        }
+        const { observer, stream } = observedElement;
+        if (observer) {
+            observer.disconnect();
+        }
+        stream.complete();
+        this._observedElements.delete(element);
+    }
+}
+ResizeObserverService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.0.2", ngImport: i0, type: ResizeObserverService, deps: [{ token: ResizeObserverFactory }], target: i0.ɵɵFactoryTarget.Injectable });
+ResizeObserverService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.0.2", ngImport: i0, type: ResizeObserverService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.0.2", ngImport: i0, type: ResizeObserverService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: function () { return [{ type: ResizeObserverFactory }]; } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicmVzaXplLW9ic2VydmVyLnNlcnZpY2UuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9saWJzL2Nkay9zcmMvbGliL3V0aWxzL3NlcnZpY2VzL3Jlc2l6ZS1vYnNlcnZlci5zZXJ2aWNlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBYyxVQUFVLEVBQWEsTUFBTSxlQUFlLENBQUM7QUFDbEUsT0FBTyxFQUFFLFVBQVUsRUFBWSxPQUFPLEVBQUUsTUFBTSxNQUFNLENBQUM7QUFDckQsT0FBTyxFQUFFLGFBQWEsRUFBRSxNQUFNLHVCQUF1QixDQUFDOztBQVN0RCxNQUFNLE9BQU8scUJBQXFCO0lBQzlCLG9FQUFvRTtJQUNwRSxNQUFNLENBQUMsUUFBZ0M7UUFDbkMsT0FBTyxPQUFPLGNBQWMsS0FBSyxXQUFXLENBQUMsQ0FBQyxDQUFDLElBQUksQ0FBQyxDQUFDLENBQUMsSUFBSSxjQUFjLENBQUMsUUFBUSxDQUFDLENBQUM7SUFDdkYsQ0FBQzs7a0hBSlEscUJBQXFCO3NIQUFyQixxQkFBcUIsY0FEUixNQUFNOzJGQUNuQixxQkFBcUI7a0JBRGpDLFVBQVU7bUJBQUMsRUFBRSxVQUFVLEVBQUUsTUFBTSxFQUFFOztBQVNsQyxNQUFNLE9BQU8scUJBQXFCO0lBSTlCLGNBQWM7SUFDZCxZQUFvQixzQkFBNkM7UUFBN0MsMkJBQXNCLEdBQXRCLHNCQUFzQixDQUF1QjtRQUpqRSxjQUFjO1FBQ04sc0JBQWlCLEdBQUcsSUFBSSxHQUFHLEVBQTRCLENBQUM7SUFHSSxDQUFDO0lBRXJFLGNBQWM7SUFDZCxXQUFXO1FBQ1AsSUFBSSxDQUFDLGlCQUFpQixDQUFDLE9BQU8sQ0FBQyxDQUFDLENBQUMsRUFBRSxPQUFPLEVBQUUsRUFBRSxDQUFDLElBQUksQ0FBQyxnQkFBZ0IsQ0FBQyxPQUFPLENBQUMsQ0FBQyxDQUFDO0lBQ25GLENBQUM7SUFFRCxvRUFBb0U7SUFDcEUsT0FBTyxDQUFDLFlBQTJDO1FBQy9DLE1BQU0sT0FBTyxHQUFHLGFBQWEsQ0FBQyxZQUFZLENBQUMsQ0FBQztRQUU1QyxPQUFPLElBQUksVUFBVSxDQUFDLENBQUMsUUFBeUMsRUFBRSxFQUFFO1lBQ2hFLE1BQU0sTUFBTSxHQUFHLElBQUksQ0FBQyxlQUFlLENBQUMsT0FBTyxDQUFDLENBQUM7WUFDN0MsTUFBTSxZQUFZLEdBQUcsTUFBTSxFQUFFLFNBQVMsQ0FBQyxRQUFRLENBQUMsQ0FBQztZQUVqRCxPQUFPLEdBQUcsRUFBRTtnQkFDUixZQUFZLEVBQUUsV0FBVyxFQUFFLENBQUM7Z0JBQzVCLElBQUksQ0FBQyxpQkFBaUIsQ0FBQyxPQUFPLENBQUMsQ0FBQztZQUNwQyxDQUFDLENBQUM7UUFDTixDQUFDLENBQUMsQ0FBQztJQUNQLENBQUM7SUFFRDs7O09BR0c7SUFDSyxlQUFlLENBQUMsT0FBZ0I7UUFDcEMsTUFBTSxlQUFlLEdBQUcsSUFBSSxDQUFDLGlCQUFpQixDQUFDLEdBQUcsQ0FBQyxPQUFPLENBQUMsQ0FBQztRQUU1RCxJQUFJLENBQUMsZUFBZSxFQUFFO1lBQ2xCLE1BQU0sTUFBTSxHQUFHLElBQUksT0FBTyxFQUF5QixDQUFDO1lBQ3BELE1BQU0sUUFBUSxHQUFHLElBQUksQ0FBQyxzQkFBc0IsQ0FBQyxNQUFNLENBQUMsQ0FBQyxTQUFTLEVBQUUsRUFBRSxDQUFDLE1BQU0sQ0FBQyxJQUFJLENBQUMsU0FBUyxDQUFDLENBQUMsQ0FBQztZQUMzRixJQUFJLFFBQVEsRUFBRTtnQkFDVixRQUFRLENBQUMsT0FBTyxDQUFDLE9BQU8sQ0FBQyxDQUFDO2FBQzdCO1lBQ0QsSUFBSSxDQUFDLGlCQUFpQixDQUFDLEdBQUcsQ0FBQyxPQUFPLEVBQUUsRUFBRSxRQUFRLEVBQUUsTUFBTSxFQUFFLEtBQUssRUFBRSxDQUFDLEVBQUUsQ0FBQyxDQUFDO1NBQ3ZFO2FBQU07WUFDSCxlQUFlLENBQUMsS0FBSyxFQUFFLENBQUM7U0FDM0I7UUFDRCxPQUFPLGVBQWUsRUFBRSxNQUFNLENBQUM7SUFDbkMsQ0FBQztJQUVEOzs7T0FHRztJQUNLLGlCQUFpQixDQUFDLE9BQWdCO1FBQ3RDLE1BQU0sZUFBZSxHQUFHLElBQUksQ0FBQyxpQkFBaUIsQ0FBQyxHQUFHLENBQUMsT0FBTyxDQUFDLENBQUM7UUFDNUQsSUFBSSxDQUFDLGVBQWUsRUFBRTtZQUNsQixPQUFPO1NBQ1Y7UUFFRCxlQUFlLENBQUMsS0FBSyxFQUFFLENBQUM7UUFDeEIsSUFBSSxDQUFDLGVBQWUsQ0FBQyxLQUFLLEVBQUU7WUFDeEIsT0FBTztTQUNWO1FBQ0QsSUFBSSxDQUFDLGdCQUFnQixDQUFDLE9BQU8sQ0FBQyxDQUFDO0lBQ25DLENBQUM7SUFFRCwwRUFBMEU7SUFDbEUsZ0JBQWdCLENBQUMsT0FBZ0I7UUFDckMsTUFBTSxlQUFlLEdBQUcsSUFBSSxDQUFDLGlCQUFpQixDQUFDLEdBQUcsQ0FBQyxPQUFPLENBQUMsQ0FBQztRQUU1RCxJQUFJLENBQUMsZUFBZSxFQUFFO1lBQ2xCLE9BQU87U0FDVjtRQUNELE1BQU0sRUFBRSxRQUFRLEVBQUUsTUFBTSxFQUFFLEdBQUcsZUFBZSxDQUFDO1FBQzdDLElBQUksUUFBUSxFQUFFO1lBQ1YsUUFBUSxDQUFDLFVBQVUsRUFBRSxDQUFDO1NBQ3pCO1FBQ0QsTUFBTSxDQUFDLFFBQVEsRUFBRSxDQUFDO1FBQ2xCLElBQUksQ0FBQyxpQkFBaUIsQ0FBQyxNQUFNLENBQUMsT0FBTyxDQUFDLENBQUM7SUFDM0MsQ0FBQzs7a0hBN0VRLHFCQUFxQjtzSEFBckIscUJBQXFCLGNBRFIsTUFBTTsyRkFDbkIscUJBQXFCO2tCQURqQyxVQUFVO21CQUFDLEVBQUUsVUFBVSxFQUFFLE1BQU0sRUFBRSIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IEVsZW1lbnRSZWYsIEluamVjdGFibGUsIE9uRGVzdHJveSB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuaW1wb3J0IHsgT2JzZXJ2YWJsZSwgT2JzZXJ2ZXIsIFN1YmplY3QgfSBmcm9tICdyeGpzJztcbmltcG9ydCB7IGNvZXJjZUVsZW1lbnQgfSBmcm9tICdAYW5ndWxhci9jZGsvY29lcmNpb24nO1xuXG5pbnRlcmZhY2UgT2JzZXJ2ZWRFbGVtZW50IHtcbiAgICBvYnNlcnZlcjogUmVzaXplT2JzZXJ2ZXIgfCBudWxsO1xuICAgIHJlYWRvbmx5IHN0cmVhbTogU3ViamVjdDxSZXNpemVPYnNlcnZlckVudHJ5W10+O1xuICAgIGNvdW50OiBudW1iZXI7XG59XG5cbkBJbmplY3RhYmxlKHsgcHJvdmlkZWRJbjogJ3Jvb3QnIH0pXG5leHBvcnQgY2xhc3MgUmVzaXplT2JzZXJ2ZXJGYWN0b3J5IHtcbiAgICAvKiogRmFjdG9yeSB0byBjcmVhdGUgUmVzaXplT2JzZXJ2ZXIgaWYgaXQncyBwcmVzZW50IGluIGJyb3dzZXIuICAqL1xuICAgIGNyZWF0ZShjYWxsYmFjazogUmVzaXplT2JzZXJ2ZXJDYWxsYmFjayk6IFJlc2l6ZU9ic2VydmVyIHwgbnVsbCB7XG4gICAgICAgIHJldHVybiB0eXBlb2YgUmVzaXplT2JzZXJ2ZXIgPT09ICd1bmRlZmluZWQnID8gbnVsbCA6IG5ldyBSZXNpemVPYnNlcnZlcihjYWxsYmFjayk7XG4gICAgfVxufVxuXG5ASW5qZWN0YWJsZSh7IHByb3ZpZGVkSW46ICdyb290JyB9KVxuZXhwb3J0IGNsYXNzIFJlc2l6ZU9ic2VydmVyU2VydmljZSBpbXBsZW1lbnRzIE9uRGVzdHJveSB7XG4gICAgLyoqIEBoaWRkZW4gKi9cbiAgICBwcml2YXRlIF9vYnNlcnZlZEVsZW1lbnRzID0gbmV3IE1hcDxFbGVtZW50LCBPYnNlcnZlZEVsZW1lbnQ+KCk7XG5cbiAgICAvKiogQGhpZGRlbiAqL1xuICAgIGNvbnN0cnVjdG9yKHByaXZhdGUgX3Jlc2l6ZU9ic2VydmVyRmFjdG9yeTogUmVzaXplT2JzZXJ2ZXJGYWN0b3J5KSB7fVxuXG4gICAgLyoqIEBoaWRkZW4gKi9cbiAgICBuZ09uRGVzdHJveSgpOiB2b2lkIHtcbiAgICAgICAgdGhpcy5fb2JzZXJ2ZWRFbGVtZW50cy5mb3JFYWNoKChfLCBlbGVtZW50KSA9PiB0aGlzLl9jbGVhbnVwT2JzZXJ2ZXIoZWxlbWVudCkpO1xuICAgIH1cblxuICAgIC8qKiBPYnNlcnZlIHRoZSBnaXZlbiBlbGVtZW50IGFuZCBlbWl0IHdoZW5ldmVyIGl0cyBzaXplIGNoYW5nZXMuICovXG4gICAgb2JzZXJ2ZShlbGVtZW50T3JSZWY6IEVsZW1lbnQgfCBFbGVtZW50UmVmPEVsZW1lbnQ+KTogT2JzZXJ2YWJsZTxSZXNpemVPYnNlcnZlckVudHJ5W10+IHtcbiAgICAgICAgY29uc3QgZWxlbWVudCA9IGNvZXJjZUVsZW1lbnQoZWxlbWVudE9yUmVmKTtcblxuICAgICAgICByZXR1cm4gbmV3IE9ic2VydmFibGUoKG9ic2VydmVyOiBPYnNlcnZlcjxSZXNpemVPYnNlcnZlckVudHJ5W10+KSA9PiB7XG4gICAgICAgICAgICBjb25zdCBzdHJlYW0gPSB0aGlzLl9vYnNlcnZlRWxlbWVudChlbGVtZW50KTtcbiAgICAgICAgICAgIGNvbnN0IHN1YnNjcmlwdGlvbiA9IHN0cmVhbT8uc3Vic2NyaWJlKG9ic2VydmVyKTtcblxuICAgICAgICAgICAgcmV0dXJuICgpID0+IHtcbiAgICAgICAgICAgICAgICBzdWJzY3JpcHRpb24/LnVuc3Vic2NyaWJlKCk7XG4gICAgICAgICAgICAgICAgdGhpcy5fdW5vYnNlcnZlRWxlbWVudChlbGVtZW50KTtcbiAgICAgICAgICAgIH07XG4gICAgICAgIH0pO1xuICAgIH1cblxuICAgIC8qKlxuICAgICAqIE9ic2VydmVzIHRoZSBnaXZlbiBlbGVtZW50IGJ5IHVzaW5nIHRoZSBleGlzdGluZyBNdXRhdGlvbk9ic2VydmVyIGlmIGF2YWlsYWJsZSwgb3IgY3JlYXRpbmcgYVxuICAgICAqIG5ldyBvbmUgaWYgbm90LlxuICAgICAqL1xuICAgIHByaXZhdGUgX29ic2VydmVFbGVtZW50KGVsZW1lbnQ6IEVsZW1lbnQpOiBTdWJqZWN0PFJlc2l6ZU9ic2VydmVyRW50cnlbXT4gfCB1bmRlZmluZWQge1xuICAgICAgICBjb25zdCBvYnNlcnZlZEVsZW1lbnQgPSB0aGlzLl9vYnNlcnZlZEVsZW1lbnRzLmdldChlbGVtZW50KTtcblxuICAgICAgICBpZiAoIW9ic2VydmVkRWxlbWVudCkge1xuICAgICAgICAgICAgY29uc3Qgc3RyZWFtID0gbmV3IFN1YmplY3Q8UmVzaXplT2JzZXJ2ZXJFbnRyeVtdPigpO1xuICAgICAgICAgICAgY29uc3Qgb2JzZXJ2ZXIgPSB0aGlzLl9yZXNpemVPYnNlcnZlckZhY3RvcnkuY3JlYXRlKChtdXRhdGlvbnMpID0+IHN0cmVhbS5uZXh0KG11dGF0aW9ucykpO1xuICAgICAgICAgICAgaWYgKG9ic2VydmVyKSB7XG4gICAgICAgICAgICAgICAgb2JzZXJ2ZXIub2JzZXJ2ZShlbGVtZW50KTtcbiAgICAgICAgICAgIH1cbiAgICAgICAgICAgIHRoaXMuX29ic2VydmVkRWxlbWVudHMuc2V0KGVsZW1lbnQsIHsgb2JzZXJ2ZXIsIHN0cmVhbSwgY291bnQ6IDEgfSk7XG4gICAgICAgIH0gZWxzZSB7XG4gICAgICAgICAgICBvYnNlcnZlZEVsZW1lbnQuY291bnQrKztcbiAgICAgICAgfVxuICAgICAgICByZXR1cm4gb2JzZXJ2ZWRFbGVtZW50Py5zdHJlYW07XG4gICAgfVxuXG4gICAgLyoqXG4gICAgICogVW4tb2JzZXJ2ZXMgdGhlIGdpdmVuIGVsZW1lbnQgYW5kIGNsZWFucyB1cCB0aGUgdW5kZXJseWluZyBNdXRhdGlvbk9ic2VydmVyIGlmIG5vYm9keSBlbHNlIGlzXG4gICAgICogb2JzZXJ2aW5nIHRoaXMgZWxlbWVudC5cbiAgICAgKi9cbiAgICBwcml2YXRlIF91bm9ic2VydmVFbGVtZW50KGVsZW1lbnQ6IEVsZW1lbnQpOiB2b2lkIHtcbiAgICAgICAgY29uc3Qgb2JzZXJ2ZWRFbGVtZW50ID0gdGhpcy5fb2JzZXJ2ZWRFbGVtZW50cy5nZXQoZWxlbWVudCk7XG4gICAgICAgIGlmICghb2JzZXJ2ZWRFbGVtZW50KSB7XG4gICAgICAgICAgICByZXR1cm47XG4gICAgICAgIH1cblxuICAgICAgICBvYnNlcnZlZEVsZW1lbnQuY291bnQtLTtcbiAgICAgICAgaWYgKCFvYnNlcnZlZEVsZW1lbnQuY291bnQpIHtcbiAgICAgICAgICAgIHJldHVybjtcbiAgICAgICAgfVxuICAgICAgICB0aGlzLl9jbGVhbnVwT2JzZXJ2ZXIoZWxlbWVudCk7XG4gICAgfVxuXG4gICAgLyoqIENsZWFuIHVwIHRoZSB1bmRlcmx5aW5nIE11dGF0aW9uT2JzZXJ2ZXIgZm9yIHRoZSBzcGVjaWZpZWQgZWxlbWVudC4gKi9cbiAgICBwcml2YXRlIF9jbGVhbnVwT2JzZXJ2ZXIoZWxlbWVudDogRWxlbWVudCk6IHZvaWQge1xuICAgICAgICBjb25zdCBvYnNlcnZlZEVsZW1lbnQgPSB0aGlzLl9vYnNlcnZlZEVsZW1lbnRzLmdldChlbGVtZW50KTtcblxuICAgICAgICBpZiAoIW9ic2VydmVkRWxlbWVudCkge1xuICAgICAgICAgICAgcmV0dXJuO1xuICAgICAgICB9XG4gICAgICAgIGNvbnN0IHsgb2JzZXJ2ZXIsIHN0cmVhbSB9ID0gb2JzZXJ2ZWRFbGVtZW50O1xuICAgICAgICBpZiAob2JzZXJ2ZXIpIHtcbiAgICAgICAgICAgIG9ic2VydmVyLmRpc2Nvbm5lY3QoKTtcbiAgICAgICAgfVxuICAgICAgICBzdHJlYW0uY29tcGxldGUoKTtcbiAgICAgICAgdGhpcy5fb2JzZXJ2ZWRFbGVtZW50cy5kZWxldGUoZWxlbWVudCk7XG4gICAgfVxufVxuIl19

package/esm2020/utils/services/rtl.service.mjs

@@ -0,0 +1,29 @@
+import { BehaviorSubject } from 'rxjs';
+import { Optional, Injectable, Inject, InjectionToken } from '@angular/core';
+import * as i0 from "@angular/core";
+const DefaultRtlLanguages = ['ar', 'arc', 'dv', 'fa', 'ha', 'he', 'khw', 'ks', 'ku', 'ps', 'ur', 'yi'];
+export const RTL_LANGUAGE = new InjectionToken('RtlLanguage');
+/**
+ * Service taking care of RTL trough behavior subject
+ * language list is used to determine if rtl should be enabled at start
+ * user can overwrite default languages by using injection token RtlLanguageToken
+ */
+export class RtlService {
+    /** @hidden */
+    constructor(injectedRtlLanguages) {
+        injectedRtlLanguages = injectedRtlLanguages || DefaultRtlLanguages;
+        const filtered = injectedRtlLanguages.filter((language) => navigator.language.includes(language));
+        this.rtl = new BehaviorSubject(filtered.length > 0);
+    }
+}
+RtlService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.0.2", ngImport: i0, type: RtlService, deps: [{ token: RTL_LANGUAGE, optional: true }], target: i0.ɵɵFactoryTarget.Injectable });
+RtlService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.0.2", ngImport: i0, type: RtlService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.0.2", ngImport: i0, type: RtlService, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: undefined, decorators: [{
+                    type: Optional
+                }, {
+                    type: Inject,
+                    args: [RTL_LANGUAGE]
+                }] }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/utils/services/tabbable-element.service.mjs

@@ -0,0 +1,43 @@
+import { InteractivityChecker } from '@angular/cdk/a11y';
+import { DOCUMENT } from '@angular/common';
+import { Inject, Injectable, Optional } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/cdk/a11y";
+export class TabbableElementService {
+    /** @hidden */
+    constructor(_checker, _document) {
+        this._checker = _checker;
+        this._document = _document;
+    }
+    /** Get the first tabbable element from a DOM subtree (inclusive). */
+    getTabbableElement(root, focusLastElement = false, skipSelf = false) {
+        if (!skipSelf && this._checker.isFocusable(root) && this._checker.isTabbable(root)) {
+            return root;
+        }
+        // Iterate in DOM order. Note that IE doesn't have `children` for SVG, so we fall
+        // back to `childNodes` which includes text nodes, comments etc.
+        const rootChildren = root.children || root.childNodes;
+        const children = focusLastElement ? Array.from(rootChildren).reverse() : rootChildren;
+        for (let i = 0; i < children.length; i++) {
+            const tabbableChild = children[i].nodeType === this._document?.ELEMENT_NODE
+                ? this.getTabbableElement(children[i], focusLastElement)
+                : null;
+            if (tabbableChild) {
+                return tabbableChild;
+            }
+        }
+        return null;
+    }
+}
+TabbableElementService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.0.2", ngImport: i0, type: TabbableElementService, deps: [{ token: i1.InteractivityChecker }, { token: DOCUMENT, optional: true }], target: i0.ɵɵFactoryTarget.Injectable });
+TabbableElementService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.0.2", ngImport: i0, type: TabbableElementService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.0.2", ngImport: i0, type: TabbableElementService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: function () { return [{ type: i1.InteractivityChecker }, { type: Document, decorators: [{
+                    type: Optional
+                }, {
+                    type: Inject,
+                    args: [DOCUMENT]
+                }] }]; } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidGFiYmFibGUtZWxlbWVudC5zZXJ2aWNlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vbGlicy9jZGsvc3JjL2xpYi91dGlscy9zZXJ2aWNlcy90YWJiYWJsZS1lbGVtZW50LnNlcnZpY2UudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLG9CQUFvQixFQUFFLE1BQU0sbUJBQW1CLENBQUM7QUFDekQsT0FBTyxFQUFFLFFBQVEsRUFBRSxNQUFNLGlCQUFpQixDQUFDO0FBQzNDLE9BQU8sRUFBRSxNQUFNLEVBQUUsVUFBVSxFQUFFLFFBQVEsRUFBRSxNQUFNLGVBQWUsQ0FBQzs7O0FBRzdELE1BQU0sT0FBTyxzQkFBc0I7SUFDL0IsY0FBYztJQUNkLFlBQ3FCLFFBQThCLEVBQ0EsU0FBMEI7UUFEeEQsYUFBUSxHQUFSLFFBQVEsQ0FBc0I7UUFDQSxjQUFTLEdBQVQsU0FBUyxDQUFpQjtJQUMxRSxDQUFDO0lBRUoscUVBQXFFO0lBQ3JFLGtCQUFrQixDQUFDLElBQWlCLEVBQUUsZ0JBQWdCLEdBQUcsS0FBSyxFQUFFLFFBQVEsR0FBRyxLQUFLO1FBQzVFLElBQUksQ0FBQyxRQUFRLElBQUksSUFBSSxDQUFDLFFBQVEsQ0FBQyxXQUFXLENBQUMsSUFBSSxDQUFDLElBQUksSUFBSSxDQUFDLFFBQVEsQ0FBQyxVQUFVLENBQUMsSUFBSSxDQUFDLEVBQUU7WUFDaEYsT0FBTyxJQUFJLENBQUM7U0FDZjtRQUVELGlGQUFpRjtRQUNqRixnRUFBZ0U7UUFDaEUsTUFBTSxZQUFZLEdBQUcsSUFBSSxDQUFDLFFBQVEsSUFBSSxJQUFJLENBQUMsVUFBVSxDQUFDO1FBRXRELE1BQU0sUUFBUSxHQUFHLGdCQUFnQixDQUFDLENBQUMsQ0FBQyxLQUFLLENBQUMsSUFBSSxDQUFDLFlBQVksQ0FBQyxDQUFDLE9BQU8sRUFBRSxDQUFDLENBQUMsQ0FBQyxZQUFZLENBQUM7UUFFdEYsS0FBSyxJQUFJLENBQUMsR0FBRyxDQUFDLEVBQUUsQ0FBQyxHQUFHLFFBQVEsQ0FBQyxNQUFNLEVBQUUsQ0FBQyxFQUFFLEVBQUU7WUFDdEMsTUFBTSxhQUFhLEdBQ2YsUUFBUSxDQUFDLENBQUMsQ0FBQyxDQUFDLFFBQVEsS0FBSyxJQUFJLENBQUMsU0FBUyxFQUFFLFlBQVk7Z0JBQ2pELENBQUMsQ0FBQyxJQUFJLENBQUMsa0JBQWtCLENBQUMsUUFBUSxDQUFDLENBQUMsQ0FBZ0IsRUFBRSxnQkFBZ0IsQ0FBQztnQkFDdkUsQ0FBQyxDQUFDLElBQUksQ0FBQztZQUVmLElBQUksYUFBYSxFQUFFO2dCQUNmLE9BQU8sYUFBYSxDQUFDO2FBQ3hCO1NBQ0o7UUFFRCxPQUFPLElBQUksQ0FBQztJQUNoQixDQUFDOzttSEEvQlEsc0JBQXNCLHNEQUlQLFFBQVE7dUhBSnZCLHNCQUFzQixjQURULE1BQU07MkZBQ25CLHNCQUFzQjtrQkFEbEMsVUFBVTttQkFBQyxFQUFFLFVBQVUsRUFBRSxNQUFNLEVBQUU7OzBCQUt6QixRQUFROzswQkFBSSxNQUFNOzJCQUFDLFFBQVEiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBJbnRlcmFjdGl2aXR5Q2hlY2tlciB9IGZyb20gJ0Bhbmd1bGFyL2Nkay9hMTF5JztcbmltcG9ydCB7IERPQ1VNRU5UIH0gZnJvbSAnQGFuZ3VsYXIvY29tbW9uJztcbmltcG9ydCB7IEluamVjdCwgSW5qZWN0YWJsZSwgT3B0aW9uYWwgfSBmcm9tICdAYW5ndWxhci9jb3JlJztcblxuQEluamVjdGFibGUoeyBwcm92aWRlZEluOiAncm9vdCcgfSlcbmV4cG9ydCBjbGFzcyBUYWJiYWJsZUVsZW1lbnRTZXJ2aWNlIHtcbiAgICAvKiogQGhpZGRlbiAqL1xuICAgIGNvbnN0cnVjdG9yKFxuICAgICAgICBwcml2YXRlIHJlYWRvbmx5IF9jaGVja2VyOiBJbnRlcmFjdGl2aXR5Q2hlY2tlcixcbiAgICAgICAgQE9wdGlvbmFsKCkgQEluamVjdChET0NVTUVOVCkgcHJpdmF0ZSByZWFkb25seSBfZG9jdW1lbnQ6IERvY3VtZW50IHwgbnVsbFxuICAgICkge31cblxuICAgIC8qKiBHZXQgdGhlIGZpcnN0IHRhYmJhYmxlIGVsZW1lbnQgZnJvbSBhIERPTSBzdWJ0cmVlIChpbmNsdXNpdmUpLiAqL1xuICAgIGdldFRhYmJhYmxlRWxlbWVudChyb290OiBIVE1MRWxlbWVudCwgZm9jdXNMYXN0RWxlbWVudCA9IGZhbHNlLCBza2lwU2VsZiA9IGZhbHNlKTogSFRNTEVsZW1lbnQgfCBudWxsIHtcbiAgICAgICAgaWYgKCFza2lwU2VsZiAmJiB0aGlzLl9jaGVja2VyLmlzRm9jdXNhYmxlKHJvb3QpICYmIHRoaXMuX2NoZWNrZXIuaXNUYWJiYWJsZShyb290KSkge1xuICAgICAgICAgICAgcmV0dXJuIHJvb3Q7XG4gICAgICAgIH1cblxuICAgICAgICAvLyBJdGVyYXRlIGluIERPTSBvcmRlci4gTm90ZSB0aGF0IElFIGRvZXNuJ3QgaGF2ZSBgY2hpbGRyZW5gIGZvciBTVkcsIHNvIHdlIGZhbGxcbiAgICAgICAgLy8gYmFjayB0byBgY2hpbGROb2Rlc2Agd2hpY2ggaW5jbHVkZXMgdGV4dCBub2RlcywgY29tbWVudHMgZXRjLlxuICAgICAgICBjb25zdCByb290Q2hpbGRyZW4gPSByb290LmNoaWxkcmVuIHx8IHJvb3QuY2hpbGROb2RlcztcblxuICAgICAgICBjb25zdCBjaGlsZHJlbiA9IGZvY3VzTGFzdEVsZW1lbnQgPyBBcnJheS5mcm9tKHJvb3RDaGlsZHJlbikucmV2ZXJzZSgpIDogcm9vdENoaWxkcmVuO1xuXG4gICAgICAgIGZvciAobGV0IGkgPSAwOyBpIDwgY2hpbGRyZW4ubGVuZ3RoOyBpKyspIHtcbiAgICAgICAgICAgIGNvbnN0IHRhYmJhYmxlQ2hpbGQgPVxuICAgICAgICAgICAgICAgIGNoaWxkcmVuW2ldLm5vZGVUeXBlID09PSB0aGlzLl9kb2N1bWVudD8uRUxFTUVOVF9OT0RFXG4gICAgICAgICAgICAgICAgICAgID8gdGhpcy5nZXRUYWJiYWJsZUVsZW1lbnQoY2hpbGRyZW5baV0gYXMgSFRNTEVsZW1lbnQsIGZvY3VzTGFzdEVsZW1lbnQpXG4gICAgICAgICAgICAgICAgICAgIDogbnVsbDtcblxuICAgICAgICAgICAgaWYgKHRhYmJhYmxlQ2hpbGQpIHtcbiAgICAgICAgICAgICAgICByZXR1cm4gdGFiYmFibGVDaGlsZDtcbiAgICAgICAgICAgIH1cbiAgICAgICAgfVxuXG4gICAgICAgIHJldHVybiBudWxsO1xuICAgIH1cbn1cbiJdfQ==

package/esm2020/utils/services/themes.service.mjs

@@ -0,0 +1,133 @@
+import { Injectable, isDevMode, Optional } from '@angular/core';
+import { DomSanitizer } from '@angular/platform-browser';
+import { ActivatedRoute } from '@angular/router';
+import { filter, takeUntil } from 'rxjs/operators';
+import { Subject } from 'rxjs';
+import { THEME_SWITCHER_ROUTER_MISSING_ERROR } from '../consts';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/router";
+import * as i2 from "@angular/platform-browser";
+/**
+ * @deprecated
+ * Service providing theme switcher functionality.
+ * Deprecated since 0.35.0 in favor of ThemingService from ThemingModule
+ */
+export class ThemesService {
+    /** @hidden */
+    constructor(_activatedRoute, _sanitizer) {
+        this._activatedRoute = _activatedRoute;
+        this._sanitizer = _sanitizer;
+        /** Available themes */
+        this.themes = [
+            {
+                id: 'sap_horizon',
+                name: 'Morning Horizon (Light)'
+            },
+            {
+                id: 'sap_horizon_dark',
+                name: 'Evening Horizon (Dark)'
+            },
+            {
+                id: 'sap_horizon_hcb',
+                name: 'Horizon High Contrast Black',
+                description: 'Optimized contrast and accessibiliwty for extremely bright environments'
+            },
+            {
+                id: 'sap_horizon_hcw',
+                name: 'Horizon High Contrast White Horizon',
+                description: 'Optimized contrast and accessibility for extremely dark environments'
+            },
+            {
+                id: 'sap_fiori_3',
+                name: 'Quartz Light',
+                description: 'Use in regular office environment'
+            },
+            {
+                id: 'sap_fiori_3_dark',
+                name: 'Quartz Dark',
+                description: 'Use in dimmed environments'
+            },
+            {
+                id: 'sap_fiori_3_hcb',
+                name: 'Quartz High Contrast Black',
+                description: 'Optimized contrast and accessibility for extremely bright environments'
+            },
+            {
+                id: 'sap_fiori_3_hcw',
+                name: 'Quartz High Contrast White',
+                description: 'Optimized contrast and accessibility for extremely dark environments'
+            },
+            {
+                id: 'sap_fiori_3_light_dark',
+                name: 'Quartz Auto (Depending on the OS Settings)'
+            }
+        ];
+        /** Subject triggered, when the theming is changed by URL parameter */
+        this.onThemeQueryParamChange = new Subject();
+        /** @hidden **/
+        this._onDestroy$ = new Subject();
+    }
+    /**
+     * Set theme according to additional URL parameter.
+     * This parameter can be changed in function argument.
+     * By default it's `theme`.
+     **/
+    setThemeByRoute(themeParamName) {
+        const paramName = themeParamName || 'theme';
+        if (!this._activatedRoute) {
+            throw new Error(THEME_SWITCHER_ROUTER_MISSING_ERROR);
+        }
+        this._activatedRoute.queryParams
+            .pipe(takeUntil(this._onDestroy$), filter((param) => param && param[paramName]))
+            .subscribe((param) => this._propagateThemes(param[paramName]));
+        const nativeTheme = this._getNativeParameterByName(paramName);
+        if (nativeTheme) {
+            this._propagateThemes(nativeTheme);
+        }
+    }
+    /** Method to get once theme object directly from url. */
+    getThemesFromURL(param) {
+        const paramName = param || 'theme';
+        const nativeTheme = this._getNativeParameterByName(paramName);
+        if (!nativeTheme && isDevMode()) {
+            console.warn('There is no theme param set named: ' + param);
+            return;
+        }
+        return {
+            themeUrl: this.setTheme(nativeTheme),
+            customThemeUrl: this.setCustomTheme(nativeTheme)
+        };
+    }
+    /** Assign css file corresponding to chosen theme from @sap-theming **/
+    setTheme(theme) {
+        return this._sanitizer.bypassSecurityTrustResourceUrl('assets/theming-base/' + theme + '/css_variables.css');
+    }
+    /** Assign css file corresponding to chosen theme fundamental-styles **/
+    setCustomTheme(theme) {
+        return this._sanitizer.bypassSecurityTrustResourceUrl('assets/fundamental-styles-theming/' + theme + '.css');
+    }
+    /** @hidden */
+    _getNativeParameterByName(paramName) {
+        paramName = paramName.replace(/[[\]]/g, '\\$&');
+        const regex = new RegExp('[?&]' + paramName + '(=([^&#]*)|&|#|$)'), results = regex.exec(window.location.href);
+        if (!results || !results[2]) {
+            return '';
+        }
+        return decodeURIComponent(results[2].replace(/\+/g, ' '));
+    }
+    /** @hidden */
+    _propagateThemes(theme) {
+        this.onThemeQueryParamChange.next({
+            themeUrl: this.setTheme(theme),
+            customThemeUrl: this.setCustomTheme(theme)
+        });
+    }
+}
+ThemesService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.0.2", ngImport: i0, type: ThemesService, deps: [{ token: i1.ActivatedRoute, optional: true }, { token: i2.DomSanitizer }], target: i0.ɵɵFactoryTarget.Injectable });
+ThemesService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.0.2", ngImport: i0, type: ThemesService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.0.2", ngImport: i0, type: ThemesService, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i1.ActivatedRoute, decorators: [{
+                    type: Optional
+                }] }, { type: i2.DomSanitizer }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"themes.service.js","sourceRoot":"","sources":["../../../../../../libs/cdk/src/lib/utils/services/themes.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable, isDevMode, Optional } from '@angular/core';\nimport { DomSanitizer, SafeResourceUrl } from '@angular/platform-browser';\nimport { ActivatedRoute } from '@angular/router';\nimport { filter, takeUntil } from 'rxjs/operators';\nimport { Subject } from 'rxjs';\n\nimport { THEME_SWITCHER_ROUTER_MISSING_ERROR } from '../consts';\n\nexport interface ThemeServiceOutput {\n    themeUrl: SafeResourceUrl;\n    customThemeUrl: SafeResourceUrl;\n}\n\nexport interface Theme {\n    id: string;\n    name: string;\n    description?: string;\n}\n\n@Injectable()\n/**\n * @deprecated\n * Service providing theme switcher functionality.\n * Deprecated since 0.35.0 in favor of ThemingService from ThemingModule\n */\nexport class ThemesService {\n    /** Available themes */\n    themes: Theme[] = [\n        {\n            id: 'sap_horizon',\n            name: 'Morning Horizon (Light)'\n        },\n        {\n            id: 'sap_horizon_dark',\n            name: 'Evening Horizon (Dark)'\n        },\n        {\n            id: 'sap_horizon_hcb',\n            name: 'Horizon High Contrast Black',\n            description: 'Optimized contrast and accessibiliwty for extremely bright environments'\n        },\n        {\n            id: 'sap_horizon_hcw',\n            name: 'Horizon High Contrast White Horizon',\n            description: 'Optimized contrast and accessibility for extremely dark environments'\n        },\n        {\n            id: 'sap_fiori_3',\n            name: 'Quartz Light',\n            description: 'Use in regular office environment'\n        },\n        {\n            id: 'sap_fiori_3_dark',\n            name: 'Quartz Dark',\n            description: 'Use in dimmed environments'\n        },\n        {\n            id: 'sap_fiori_3_hcb',\n            name: 'Quartz High Contrast Black',\n            description: 'Optimized contrast and accessibility for extremely bright environments'\n        },\n        {\n            id: 'sap_fiori_3_hcw',\n            name: 'Quartz High Contrast White',\n            description: 'Optimized contrast and accessibility for extremely dark environments'\n        },\n        {\n            id: 'sap_fiori_3_light_dark',\n            name: 'Quartz Auto (Depending on the OS Settings)'\n        }\n    ];\n\n    /** Subject triggered, when the theming is changed by URL parameter */\n    readonly onThemeQueryParamChange: Subject<ThemeServiceOutput> = new Subject<ThemeServiceOutput>();\n\n    /** @hidden **/\n    private readonly _onDestroy$: Subject<void> = new Subject<void>();\n\n    /** @hidden */\n    constructor(@Optional() private _activatedRoute: ActivatedRoute, private _sanitizer: DomSanitizer) {}\n\n    /**\n     * Set theme according to additional URL parameter.\n     * This parameter can be changed in function argument.\n     * By default it's `theme`.\n     **/\n    setThemeByRoute(themeParamName?: string): void {\n        const paramName = themeParamName || 'theme';\n\n        if (!this._activatedRoute) {\n            throw new Error(THEME_SWITCHER_ROUTER_MISSING_ERROR);\n        }\n\n        this._activatedRoute.queryParams\n            .pipe(\n                takeUntil(this._onDestroy$),\n                filter((param) => param && param[paramName])\n            )\n            .subscribe((param) => this._propagateThemes(param[paramName]));\n\n        const nativeTheme = this._getNativeParameterByName(paramName);\n        if (nativeTheme) {\n            this._propagateThemes(nativeTheme);\n        }\n    }\n\n    /** Method to get once theme object directly from url. */\n    getThemesFromURL(param?: string): ThemeServiceOutput | undefined {\n        const paramName = param || 'theme';\n\n        const nativeTheme = this._getNativeParameterByName(paramName);\n        if (!nativeTheme && isDevMode()) {\n            console.warn('There is no theme param set named: ' + param);\n            return;\n        }\n\n        return {\n            themeUrl: this.setTheme(nativeTheme),\n            customThemeUrl: this.setCustomTheme(nativeTheme)\n        };\n    }\n\n    /** Assign css file corresponding to chosen theme from @sap-theming **/\n    setTheme(theme: string): SafeResourceUrl {\n        return this._sanitizer.bypassSecurityTrustResourceUrl('assets/theming-base/' + theme + '/css_variables.css');\n    }\n\n    /** Assign css file corresponding to chosen theme fundamental-styles **/\n    setCustomTheme(theme: string): SafeResourceUrl {\n        return this._sanitizer.bypassSecurityTrustResourceUrl('assets/fundamental-styles-theming/' + theme + '.css');\n    }\n\n    /** @hidden */\n    private _getNativeParameterByName(paramName: string): string {\n        paramName = paramName.replace(/[[\\]]/g, '\\\\$&');\n        const regex = new RegExp('[?&]' + paramName + '(=([^&#]*)|&|#|$)'),\n            results = regex.exec(window.location.href);\n        if (!results || !results[2]) {\n            return '';\n        }\n        return decodeURIComponent(results[2].replace(/\\+/g, ' '));\n    }\n\n    /** @hidden */\n    private _propagateThemes(theme: string): void {\n        this.onThemeQueryParamChange.next({\n            themeUrl: this.setTheme(theme),\n            customThemeUrl: this.setCustomTheme(theme)\n        });\n    }\n}\n"]}

package/esm2020/utils/tokens/module-deprecations.token.mjs

@@ -0,0 +1,3 @@
+import { InjectionToken } from '@angular/core';
+export const ModuleDeprecations = new InjectionToken('ModuleDeprecations');
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibW9kdWxlLWRlcHJlY2F0aW9ucy50b2tlbi5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL2xpYnMvY2RrL3NyYy9saWIvdXRpbHMvdG9rZW5zL21vZHVsZS1kZXByZWNhdGlvbnMudG9rZW4udHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLGNBQWMsRUFBRSxNQUFNLGVBQWUsQ0FBQztBQUcvQyxNQUFNLENBQUMsTUFBTSxrQkFBa0IsR0FBRyxJQUFJLGNBQWMsQ0FBb0Isb0JBQW9CLENBQUMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IEluamVjdGlvblRva2VuIH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5pbXBvcnQgeyBNb2R1bGVEZXByZWNhdGlvbiB9IGZyb20gJy4uL2ludGVyZmFjZXMvbW9kdWxlLWRlcHJlY2F0aW9uLmludGVyZmFjZSc7XG5cbmV4cG9ydCBjb25zdCBNb2R1bGVEZXByZWNhdGlvbnMgPSBuZXcgSW5qZWN0aW9uVG9rZW48TW9kdWxlRGVwcmVjYXRpb24+KCdNb2R1bGVEZXByZWNhdGlvbnMnKTtcbiJdfQ==

package/esm2020/utils/typecheck.mjs

@@ -0,0 +1,75 @@
+/**
+ * Helper function check whether passed data is a JS object (including function).
+ */
+// eslint-disable-next-line @typescript-eslint/ban-types
+export function isJsObject(obj) {
+    return obj !== null && (typeof obj === 'function' || typeof obj === 'object');
+}
+/**
+ * Helper function checks whether passed value is not empty.
+ */
+export function isPresent(obj) {
+    return obj !== undefined && obj !== null;
+}
+/**
+ * Helper function check whether passed value is empty.
+ */
+export function isBlank(obj) {
+    return obj === undefined || obj === null;
+}
+/**
+ * Helper function checks whether passed value is a boolean.
+ */
+export function isBoolean(obj) {
+    return typeof obj === 'boolean';
+}
+/**
+ * Helper function checks whether passed value is a valid number.
+ */
+export function isNumber(obj) {
+    return typeof obj === 'number';
+}
+/**
+ * Helper function checks whether passed value is a string.
+ */
+export function isString(obj) {
+    return typeof obj === 'string';
+}
+/**
+ * Helper function checks whether passed value is a function
+ */
+export function isFunction(obj) {
+    return typeof obj === 'function';
+}
+/** @hidden */
+// eslint-disable-next-line @typescript-eslint/ban-types
+export function isType(obj) {
+    return isFunction(obj);
+}
+/**
+ * Helper function checks whether passed value is a record of `T` values.
+ */
+export function isStringMap(obj) {
+    return typeof obj === 'object' && obj !== null;
+}
+/**
+ * Helper function checks whether passed value is an `object`.
+ */
+export function isObject(item) {
+    return typeof item === 'object' && !Array.isArray(item) && item !== null;
+}
+/**
+ * Helper function checks whether passed value is a promise.
+ */
+export function isPromise(obj) {
+    // allow any Promise/A+ compliant thenable.
+    // It's up to the caller to ensure that obj.then conforms to the spec
+    return !!obj && isFunction(obj.then);
+}
+/**
+ * Helper function checks whether passed value is an Observable/Subscribable.
+ */
+export function isSubscribable(obj) {
+    return !!obj && isFunction(obj.subscribe);
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/utils/utils.module.mjs

@@ -0,0 +1,136 @@
+import { NgModule } from '@angular/core';
+import { CommonModule } from '@angular/common';
+import { RtlService } from './services/rtl.service';
+import { ThemesService } from './services/themes.service';
+import { AutoCompleteModule, ClickedBehaviorModule, DisabledBehaviorModule, FocusableItemModule, FocusableListModule, InitialFocusModule, LineClampModule, OnlyDigitsModule, OverflowListModule, ReadonlyBehaviorModule, RepeatModule, ResizeModule, SelectableListModule, TemplateModule, TruncateModule } from './directives';
+import { DragAndDropModule } from './drag-and-drop/drag-and-drop.module';
+import * as i0 from "@angular/core";
+export class UtilsModule {
+}
+UtilsModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.0.2", ngImport: i0, type: UtilsModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+UtilsModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "15.0.2", ngImport: i0, type: UtilsModule, imports: [CommonModule,
+        FocusableItemModule,
+        FocusableListModule,
+        DragAndDropModule,
+        OnlyDigitsModule,
+        TruncateModule,
+        LineClampModule,
+        OverflowListModule,
+        RepeatModule,
+        ResizeModule,
+        TemplateModule,
+        AutoCompleteModule,
+        DisabledBehaviorModule,
+        SelectableListModule,
+        ReadonlyBehaviorModule,
+        ClickedBehaviorModule,
+        FocusableListModule,
+        FocusableItemModule,
+        DisabledBehaviorModule,
+        InitialFocusModule], exports: [FocusableItemModule,
+        FocusableListModule,
+        DragAndDropModule,
+        OnlyDigitsModule,
+        TruncateModule,
+        LineClampModule,
+        OverflowListModule,
+        RepeatModule,
+        ResizeModule,
+        TemplateModule,
+        AutoCompleteModule,
+        DisabledBehaviorModule,
+        SelectableListModule,
+        ReadonlyBehaviorModule,
+        ClickedBehaviorModule,
+        FocusableListModule,
+        FocusableItemModule,
+        DisabledBehaviorModule,
+        InitialFocusModule] });
+UtilsModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "15.0.2", ngImport: i0, type: UtilsModule, providers: [RtlService, ThemesService], imports: [CommonModule,
+        FocusableItemModule,
+        FocusableListModule,
+        DragAndDropModule,
+        OnlyDigitsModule,
+        TruncateModule,
+        LineClampModule,
+        OverflowListModule,
+        RepeatModule,
+        ResizeModule,
+        TemplateModule,
+        AutoCompleteModule,
+        DisabledBehaviorModule,
+        SelectableListModule,
+        ReadonlyBehaviorModule,
+        ClickedBehaviorModule,
+        FocusableListModule,
+        FocusableItemModule,
+        DisabledBehaviorModule,
+        InitialFocusModule, FocusableItemModule,
+        FocusableListModule,
+        DragAndDropModule,
+        OnlyDigitsModule,
+        TruncateModule,
+        LineClampModule,
+        OverflowListModule,
+        RepeatModule,
+        ResizeModule,
+        TemplateModule,
+        AutoCompleteModule,
+        DisabledBehaviorModule,
+        SelectableListModule,
+        ReadonlyBehaviorModule,
+        ClickedBehaviorModule,
+        FocusableListModule,
+        FocusableItemModule,
+        DisabledBehaviorModule,
+        InitialFocusModule] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.0.2", ngImport: i0, type: UtilsModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [
+                        CommonModule,
+                        FocusableItemModule,
+                        FocusableListModule,
+                        DragAndDropModule,
+                        OnlyDigitsModule,
+                        TruncateModule,
+                        LineClampModule,
+                        OverflowListModule,
+                        RepeatModule,
+                        ResizeModule,
+                        TemplateModule,
+                        AutoCompleteModule,
+                        DisabledBehaviorModule,
+                        SelectableListModule,
+                        ReadonlyBehaviorModule,
+                        ClickedBehaviorModule,
+                        FocusableListModule,
+                        FocusableItemModule,
+                        DisabledBehaviorModule,
+                        InitialFocusModule
+                    ],
+                    exports: [
+                        FocusableItemModule,
+                        FocusableListModule,
+                        DragAndDropModule,
+                        OnlyDigitsModule,
+                        TruncateModule,
+                        LineClampModule,
+                        OverflowListModule,
+                        RepeatModule,
+                        ResizeModule,
+                        TemplateModule,
+                        AutoCompleteModule,
+                        DisabledBehaviorModule,
+                        SelectableListModule,
+                        ReadonlyBehaviorModule,
+                        ClickedBehaviorModule,
+                        FocusableListModule,
+                        FocusableItemModule,
+                        DisabledBehaviorModule,
+                        InitialFocusModule
+                    ],
+                    providers: [RtlService, ThemesService]
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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