@skyux/core 5.9.6 → 5.11.0

package/fesm2015/skyux-core.js

@@ -1,5 +1,6 @@
 import * as i0 from '@angular/core';
 import { NgModule, Injectable, EventEmitter, Directive, Input, Output, Injector, ViewContainerRef, Component, ChangeDetectionStrategy, ViewChild, Pipe, ElementRef, Optional } from '@angular/core';
+import { __classPrivateFieldSet, __classPrivateFieldGet } from 'tslib';
 import * as i4 from '@angular/common';
 import { CommonModule } from '@angular/common';
 import { Subject, fromEvent, BehaviorSubject, ReplaySubject, Observable, of } from 'rxjs';
@@ -44,6 +45,7 @@ var SkyMediaBreakpoints;
     SkyMediaBreakpoints[SkyMediaBreakpoints["lg"] = 4] = "lg";
 })(SkyMediaBreakpoints || (SkyMediaBreakpoints = {}));
 
+var _SkyCoreAdapterService_renderer;
 const SKY_TABBABLE_SELECTOR = [
     'a[href]',
     'area[href]',
@@ -60,7 +62,8 @@ const SKY_TABBABLE_SELECTOR = [
 class SkyCoreAdapterService {
     constructor(rendererFactory) {
         this.rendererFactory = rendererFactory;
-        this.renderer = this.rendererFactory.createRenderer(undefined, undefined);
+        _SkyCoreAdapterService_renderer.set(this, void 0);
+        __classPrivateFieldSet(this, _SkyCoreAdapterService_renderer, this.rendererFactory.createRenderer(undefined, null), "f");
     }
     /**
      * Set the responsive container CSS class for a given element.
@@ -71,10 +74,10 @@ class SkyCoreAdapterService {
      */
     setResponsiveContainerClass(elementRef, breakpoint) {
         const nativeEl = elementRef.nativeElement;
-        this.renderer.removeClass(nativeEl, 'sky-responsive-container-xs');
-        this.renderer.removeClass(nativeEl, 'sky-responsive-container-sm');
-        this.renderer.removeClass(nativeEl, 'sky-responsive-container-md');
-        this.renderer.removeClass(nativeEl, 'sky-responsive-container-lg');
+        __classPrivateFieldGet(this, _SkyCoreAdapterService_renderer, "f").removeClass(nativeEl, 'sky-responsive-container-xs');
+        __classPrivateFieldGet(this, _SkyCoreAdapterService_renderer, "f").removeClass(nativeEl, 'sky-responsive-container-sm');
+        __classPrivateFieldGet(this, _SkyCoreAdapterService_renderer, "f").removeClass(nativeEl, 'sky-responsive-container-md');
+        __classPrivateFieldGet(this, _SkyCoreAdapterService_renderer, "f").removeClass(nativeEl, 'sky-responsive-container-lg');
         let newClass;
         switch (breakpoint) {
             case SkyMediaBreakpoints.xs: {
@@ -94,7 +97,7 @@ class SkyCoreAdapterService {
                 break;
             }
         }
-        this.renderer.addClass(nativeEl, newClass);
+        __classPrivateFieldGet(this, _SkyCoreAdapterService_renderer, "f").addClass(nativeEl, newClass);
     }
     /**
      * This method temporarily enables/disables pointer events.
@@ -258,6 +261,7 @@ class SkyCoreAdapterService {
         return hasBounds;
     }
 }
+_SkyCoreAdapterService_renderer = new WeakMap();
 SkyCoreAdapterService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: SkyCoreAdapterService, deps: [{ token: i0.RendererFactory2 }], target: i0.ɵɵFactoryTarget.Injectable });
 SkyCoreAdapterService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: SkyCoreAdapterService, providedIn: 'root' });
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: SkyCoreAdapterService, decorators: [{
@@ -719,18 +723,21 @@ class SkyAffixer {
     }
 }
 
+var _SkyAffixService_renderer;
 class SkyAffixService {
     constructor(rendererFactory) {
-        this.renderer = rendererFactory.createRenderer(undefined, undefined);
+        _SkyAffixService_renderer.set(this, void 0);
+        __classPrivateFieldSet(this, _SkyAffixService_renderer, rendererFactory.createRenderer(undefined, null), "f");
     }
     /**
      * Creates an instance of [[SkyAffixer]].
      * @param affixed The element to be affixed.
      */
     createAffixer(affixed) {
-        return new SkyAffixer(affixed.nativeElement, this.renderer);
+        return new SkyAffixer(affixed.nativeElement, __classPrivateFieldGet(this, _SkyAffixService_renderer, "f"));
     }
 }
+_SkyAffixService_renderer = new WeakMap();
 SkyAffixService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: SkyAffixService, deps: [{ token: i0.RendererFactory2 }], target: i0.ɵɵFactoryTarget.Injectable });
 SkyAffixService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: SkyAffixService, providedIn: 'root' });
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: SkyAffixService, decorators: [{
@@ -2416,19 +2423,21 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.16", ngImpo
                 }]
         }] });
 
+var _SkyResizeObserverService_resizeObserver, _SkyResizeObserverService_tracking;
 /**
  * Service to create rxjs observables for changes to the content box dimensions of elements.
  */
 class SkyResizeObserverService {
     constructor(zone) {
         this.zone = zone;
-        this._tracking = [];
-        this._resizeObserver = new ResizeObserver((entries) => {
+        _SkyResizeObserverService_resizeObserver.set(this, void 0);
+        _SkyResizeObserverService_tracking.set(this, []);
+        __classPrivateFieldSet(this, _SkyResizeObserverService_resizeObserver, new ResizeObserver((entries) => {
             entries.forEach((entry) => this.callback(entry));
-        });
+        }), "f");
     }
     ngOnDestroy() {
-        this._resizeObserver.disconnect();
+        __classPrivateFieldGet(this, _SkyResizeObserverService_resizeObserver, "f").disconnect();
     }
     /**
      * Create rxjs observable to get size changes for an element ref.
@@ -2437,22 +2446,22 @@ class SkyResizeObserverService {
         return this.observeAndTrack(element).subjectObservable;
     }
     observeAndTrack(element) {
-        const checkTracking = this._tracking.findIndex((value) => {
+        const checkTracking = __classPrivateFieldGet(this, _SkyResizeObserverService_tracking, "f").findIndex((value) => {
             return !value.subject.closed && value.element === element.nativeElement;
         });
         if (checkTracking === -1) {
-            this._resizeObserver.observe(element.nativeElement);
+            __classPrivateFieldGet(this, _SkyResizeObserverService_resizeObserver, "f").observe(element.nativeElement);
         }
         const subject = new Subject();
         const subjectObservable = subject.pipe(finalize(() => {
             // Are there any other tracking entries still watching this element?
-            const checkTracking = this._tracking.findIndex((value) => {
+            const checkTracking = __classPrivateFieldGet(this, _SkyResizeObserverService_tracking, "f").findIndex((value) => {
                 return (value.subject !== subject &&
                     !value.subject.closed &&
                     value.element === element.nativeElement);
             });
             if (checkTracking === -1) {
-                this._resizeObserver.unobserve(element.nativeElement);
+                __classPrivateFieldGet(this, _SkyResizeObserverService_resizeObserver, "f").unobserve(element.nativeElement);
             }
         }));
         const tracking = {
@@ -2460,15 +2469,17 @@ class SkyResizeObserverService {
             subject,
             subjectObservable,
         };
-        this._tracking.push(tracking);
+        __classPrivateFieldGet(this, _SkyResizeObserverService_tracking, "f").push(tracking);
         return tracking;
     }
     callback(entry) {
-        this._tracking
+        __classPrivateFieldGet(this, _SkyResizeObserverService_tracking, "f")
             .filter((value) => !(value.subject.closed || value.subject.isStopped))
             .forEach((value) => {
             /* istanbul ignore else */
             if (value.element === entry.target) {
+                // Execute the callback within NgZone because Angular does not "monkey patch"
+                // ResizeObserver like it does for other features in the DOM.
                 this.zone.run(() => {
                     value.subject.next(entry);
                 });
@@ -2476,6 +2487,7 @@ class SkyResizeObserverService {
         });
     }
 }
+_SkyResizeObserverService_resizeObserver = new WeakMap(), _SkyResizeObserverService_tracking = new WeakMap();
 SkyResizeObserverService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: SkyResizeObserverService, deps: [{ token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Injectable });
 SkyResizeObserverService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: SkyResizeObserverService, providedIn: 'any' });
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: SkyResizeObserverService, decorators: [{
@@ -2485,13 +2497,14 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.16", ngImpo
                 }]
         }], ctorParameters: function () { return [{ type: i0.NgZone }]; } });
 
+var _SkyResizeObserverMediaQueryService_breakpoints, _SkyResizeObserverMediaQueryService_currentBreakpointObservable, _SkyResizeObserverMediaQueryService_stopListening, _SkyResizeObserverMediaQueryService_target;
 /**
  * Acts like `SkyMediaQueryService` for a container element, emitting the same responsive breakpoints.
  */
 class SkyResizeObserverMediaQueryService {
     constructor(resizeObserverService) {
         this.resizeObserverService = resizeObserverService;
-        this._breakpoints = [
+        _SkyResizeObserverMediaQueryService_breakpoints.set(this, [
             {
                 check: (width) => width > 0 && width <= 767,
                 name: SkyMediaBreakpoints.xs,
@@ -2508,11 +2521,12 @@ class SkyResizeObserverMediaQueryService {
                 check: (width) => width > 1199,
                 name: SkyMediaBreakpoints.lg,
             },
-        ];
-        this._currentBreakpointObservable = new ReplaySubject(1);
-        this._stopListening = new Subject();
-        this._stopListening.subscribe(() => {
-            this._target = undefined;
+        ]);
+        _SkyResizeObserverMediaQueryService_currentBreakpointObservable.set(this, new ReplaySubject(1));
+        _SkyResizeObserverMediaQueryService_stopListening.set(this, new Subject());
+        _SkyResizeObserverMediaQueryService_target.set(this, void 0);
+        __classPrivateFieldGet(this, _SkyResizeObserverMediaQueryService_stopListening, "f").subscribe(() => {
+            __classPrivateFieldSet(this, _SkyResizeObserverMediaQueryService_target, undefined, "f");
             this.updateBreakpoint(undefined);
         });
     }
@@ -2523,10 +2537,10 @@ class SkyResizeObserverMediaQueryService {
         return this._currentBreakpoint;
     }
     ngOnDestroy() {
-        this._stopListening.next();
+        __classPrivateFieldGet(this, _SkyResizeObserverMediaQueryService_stopListening, "f").next();
         this._currentBreakpoint = undefined;
-        this._stopListening.complete();
-        this._currentBreakpointObservable.complete();
+        __classPrivateFieldGet(this, _SkyResizeObserverMediaQueryService_stopListening, "f").complete();
+        __classPrivateFieldGet(this, _SkyResizeObserverMediaQueryService_currentBreakpointObservable, "f").complete();
     }
     /**
      * @internal
@@ -2539,21 +2553,21 @@ class SkyResizeObserverMediaQueryService {
      * time. Any previous subscriptions will be unsubscribed when a new element is observed.
      */
     observe(element) {
-        if (this._target) {
-            if (this._target === element) {
+        if (__classPrivateFieldGet(this, _SkyResizeObserverMediaQueryService_target, "f")) {
+            if (__classPrivateFieldGet(this, _SkyResizeObserverMediaQueryService_target, "f") === element) {
                 return this;
             }
-            this._stopListening.next();
+            __classPrivateFieldGet(this, _SkyResizeObserverMediaQueryService_stopListening, "f").next();
         }
-        this._target = element;
+        __classPrivateFieldSet(this, _SkyResizeObserverMediaQueryService_target, element, "f");
         this.checkWidth(element);
         this.resizeObserverService
             .observe(element)
-            .pipe(takeUntil(this._stopListening))
+            .pipe(takeUntil(__classPrivateFieldGet(this, _SkyResizeObserverMediaQueryService_stopListening, "f")))
             .subscribe((value) => {
             const breakpoint = this.checkBreakpoint(value.contentRect.width);
             /* istanbul ignore else */
-            if (breakpoint !== this._currentBreakpoint) {
+            if (breakpoint !== this.current) {
                 this.updateBreakpoint(breakpoint);
             }
         });
@@ -2563,25 +2577,28 @@ class SkyResizeObserverMediaQueryService {
      * Stop watching the container element.
      */
     unobserve() {
-        this._stopListening.next();
+        __classPrivateFieldGet(this, _SkyResizeObserverMediaQueryService_stopListening, "f").next();
     }
     /**
      * Subscribes to element size changes that cross breakpoints.
      */
     subscribe(listener) {
-        return this._currentBreakpointObservable
-            .pipe(takeUntil(this._stopListening))
+        return __classPrivateFieldGet(this, _SkyResizeObserverMediaQueryService_currentBreakpointObservable, "f")
+            .pipe(takeUntil(__classPrivateFieldGet(this, _SkyResizeObserverMediaQueryService_stopListening, "f")))
             .subscribe((value) => {
             listener(value);
         });
     }
     updateBreakpoint(breakpoint) {
         this._currentBreakpoint = breakpoint;
-        this._currentBreakpointObservable.next(breakpoint);
+        __classPrivateFieldGet(this, _SkyResizeObserverMediaQueryService_currentBreakpointObservable, "f").next(breakpoint);
     }
     checkBreakpoint(width) {
-        var _a;
-        return (_a = this._breakpoints.find((breakpoint) => breakpoint.check(width))) === null || _a === void 0 ? void 0 : _a.name;
+        const breakpoint = __classPrivateFieldGet(this, _SkyResizeObserverMediaQueryService_breakpoints, "f").find((breakpoint) => breakpoint.check(width));
+        /* istanbul ignore else */
+        if (breakpoint) {
+            return breakpoint.name;
+        }
     }
     checkWidth(element) {
         const width = element.nativeElement.offsetWidth || 0;
@@ -2592,6 +2609,7 @@ class SkyResizeObserverMediaQueryService {
         }
     }
 }
+_SkyResizeObserverMediaQueryService_breakpoints = new WeakMap(), _SkyResizeObserverMediaQueryService_currentBreakpointObservable = new WeakMap(), _SkyResizeObserverMediaQueryService_stopListening = new WeakMap(), _SkyResizeObserverMediaQueryService_target = new WeakMap();
 SkyResizeObserverMediaQueryService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: SkyResizeObserverMediaQueryService, deps: [{ token: SkyResizeObserverService }], target: i0.ɵɵFactoryTarget.Injectable });
 SkyResizeObserverMediaQueryService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: SkyResizeObserverMediaQueryService, providedIn: 'any' });
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: SkyResizeObserverMediaQueryService, decorators: [{
@@ -2622,8 +2640,7 @@ class SkyScrollableHostService {
     /**
      * Returns an observable which emits the given element's current scrollable host
      * @param elementRef The element whose scrollable host is being requested
-     * @param completionObservable An observable which alerts the internal observers that they should complete
-     * @returns An observable which emits the current scrollable host
+     * @returns An observable which emits the current scrollable host element.
      * @internal
      */
     watchScrollableHost(elementRef) {
@@ -2633,11 +2650,13 @@ class SkyScrollableHostService {
         return new Observable((subscriber) => {
             subscribers.push(subscriber);
             let scrollableHost = this.findScrollableHost(elementRef.nativeElement);
+            // Setup mutation observers only once, for all subscribers.
             if (subscribers.length === 1) {
                 parentMutationObserver = this.mutationObserverSvc.create(() => {
                     const newScrollableHost = this.findScrollableHost(elementRef.nativeElement);
+                    // Reset observer if scrollable host changes.
                     if (newScrollableHost !== scrollableHost &&
-                        elementRef.nativeElement.offsetParent) {
+                        this.isElementVisible(elementRef)) {
                         scrollableHost = newScrollableHost;
                         this.observeForScrollableHostChanges(scrollableHost, parentMutationObserver);
                         notifySubscribers(subscribers, scrollableHost);
@@ -2645,7 +2664,9 @@ class SkyScrollableHostService {
                 });
                 this.observeForScrollableHostChanges(scrollableHost, parentMutationObserver);
                 documentHiddenElementMutationObserver = this.mutationObserverSvc.create(() => {
-                    if (scrollableHost && !elementRef.nativeElement.offsetParent) {
+                    if (scrollableHost && !this.isElementVisible(elementRef)) {
+                        // If the scrollable host is not visible, set it to undefined and unsubscribe from its mutation changes.
+                        // Then, observe the document element so that a new scrollable host can be found.
                         scrollableHost = undefined;
                         this.observeForScrollableHostChanges(scrollableHost, parentMutationObserver);
                         notifySubscribers(subscribers, scrollableHost);
@@ -2653,10 +2674,11 @@ class SkyScrollableHostService {
                 });
                 this.observeDocumentHiddenElementChanges(documentHiddenElementMutationObserver);
             }
+            // Emit the scrollable host to the subscriber.
             subscriber.next(scrollableHost);
+            // Teardown callback for the subscription.
             subscriber.add(() => {
                 const subIndex = subscribers.indexOf(subscriber);
-                /* sanity check */
                 /* istanbul ignore else */
                 if (subIndex >= 0) {
                     subscribers.splice(subIndex, 1);
@@ -2671,7 +2693,6 @@ class SkyScrollableHostService {
     /**
      * Returns an observable which emits whenever the element's scrollable host emits a scroll event. The observable will always emit the scroll events from the elements current scrollable host and will update based on any scrollable host changes. The observable will also emit once whenever the scrollable host changes.
      * @param elementRef The element whose scrollable host scroll events are being requested
-     * @param completionObservable An observable which alerts the internal observers that they should complete
      * @returns An observable which emits when the elements scrollable host is scrolled or is changed
      */
     watchScrollableHostScrollEvents(elementRef) {
@@ -2682,6 +2703,7 @@ class SkyScrollableHostService {
         let scrollEventSubscription;
         return new Observable((subscriber) => {
             subscribers.push(subscriber);
+            // Setup mutation observers only once, for all subscribers.
             if (subscribers.length === 1) {
                 scrollableHostSubscription = this.watchScrollableHost(elementRef).subscribe((newScrollableHost) => {
                     newScrollableHostObservable.next();
@@ -2691,6 +2713,8 @@ class SkyScrollableHostService {
                     }
                     scrollableHost = newScrollableHost;
                     newScrollableHostObservable = new Subject();
+                    // Only subscribe to scroll events if the host element is defined.
+                    /* istanbul ignore else */
                     if (newScrollableHost) {
                         scrollEventSubscription = fromEvent(newScrollableHost, 'scroll')
                             .pipe(takeUntil(newScrollableHostObservable))
@@ -2700,9 +2724,9 @@ class SkyScrollableHostService {
                     }
                 });
             }
+            // Teardown callback for the subscription.
             subscriber.add(() => {
                 const subIndex = subscribers.indexOf(subscriber);
-                /* sanity check */
                 /* istanbul ignore else */
                 if (subIndex >= 0) {
                     subscribers.splice(subIndex, 1);
@@ -2719,7 +2743,6 @@ class SkyScrollableHostService {
         const regex = /(auto|scroll)/;
         const windowObj = this.windowRef.nativeWindow;
         const bodyObj = windowObj.document.body;
-        /* Sanity check */
         if (!element) {
             return windowObj;
         }
@@ -2727,7 +2750,7 @@ class SkyScrollableHostService {
         let parent = element;
         do {
             parent = parent.parentNode;
-            /* Sanity check for if this function is called for an element which has been removed from the DOM */
+            // Return `window` if the parent element has been removed from the DOM.
             if (!(parent instanceof HTMLElement)) {
                 return windowObj;
             }
@@ -2750,22 +2773,20 @@ class SkyScrollableHostService {
     }
     observeForScrollableHostChanges(element, mutationObserver) {
         mutationObserver.disconnect();
-        if (element instanceof HTMLElement) {
-            mutationObserver.observe(element, {
-                attributes: true,
-                attributeFilter: ['class', 'style'],
-                childList: true,
-                subtree: true,
-            });
-        }
-        else {
-            mutationObserver.observe(document.documentElement, {
-                attributes: true,
-                attributeFilter: ['class', 'style'],
-                childList: true,
-                subtree: true,
-            });
-        }
+        const target = element instanceof HTMLElement ? element : document.documentElement;
+        mutationObserver.observe(target, {
+            attributes: true,
+            attributeFilter: ['class', 'style'],
+            childList: true,
+            subtree: true,
+        });
+    }
+    /**
+     * Determines if an element is "visible" in the DOM.
+     * @see https://stackoverflow.com/a/11639664/6178885
+     */
+    isElementVisible(elementRef) {
+        return elementRef.nativeElement.offsetParent;
     }
 }
 SkyScrollableHostService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: SkyScrollableHostService, deps: [{ token: MutationObserverService }, { token: SkyAppWindowRef }], target: i0.ɵɵFactoryTarget.Injectable });