@skyux/core 5.1.3 → 5.2.0

package/bundles/skyux-core.umd.js

@@ -2950,31 +2950,115 @@
                         }]
                 }] });
 
+        function notifySubscribers(subscribers, item) {
+            var e_1, _a;
+            try {
+                for (var subscribers_1 = __values(subscribers), subscribers_1_1 = subscribers_1.next(); !subscribers_1_1.done; subscribers_1_1 = subscribers_1.next()) {
+                    var subscriber = subscribers_1_1.value;
+                    subscriber.next(item);
+                }
+            }
+            catch (e_1_1) { e_1 = { error: e_1_1 }; }
+            finally {
+                try {
+                    if (subscribers_1_1 && !subscribers_1_1.done && (_a = subscribers_1.return)) _a.call(subscribers_1);
+                }
+                finally { if (e_1) throw e_1.error; }
+            }
+        }
         var SkyScrollableHostService = /** @class */ (function () {
             function SkyScrollableHostService(mutationObserverSvc, windowRef) {
                 this.mutationObserverSvc = mutationObserverSvc;
                 this.windowRef = windowRef;
             }
-            SkyScrollableHostService.prototype.getScrollabeHost = function (elementRef) {
+            /**
+             * Returns the given element's current scrollable host
+             * @param elementRef The element whose scrollable host is being requested
+             * @returns The current scrollable host
+             */
+            SkyScrollableHostService.prototype.getScrollableHost = function (elementRef) {
                 return this.findScrollableHost(elementRef.nativeElement);
             };
-            SkyScrollableHostService.prototype.watchScrollableHost = function (elementRef, completionObservable) {
+            /**
+             * 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
+             * @internal
+             */
+            SkyScrollableHostService.prototype.watchScrollableHost = function (elementRef) {
                 var _this = this;
-                var scrollableHost = this.findScrollableHost(elementRef.nativeElement);
-                var behaviorSubject = new rxjs.BehaviorSubject(scrollableHost);
-                var mutationObserver = this.mutationObserverSvc.create(function () {
-                    var newScrollableHost = _this.findScrollableHost(elementRef.nativeElement);
-                    if (newScrollableHost !== scrollableHost) {
-                        scrollableHost = newScrollableHost;
+                var subscribers = [];
+                var mutationObserver;
+                return new rxjs.Observable(function (subscriber) {
+                    subscribers.push(subscriber);
+                    var scrollableHost = _this.findScrollableHost(elementRef.nativeElement);
+                    if (subscribers.length === 1) {
+                        mutationObserver = _this.mutationObserverSvc.create(function () {
+                            var newScrollableHost = _this.findScrollableHost(elementRef.nativeElement);
+                            if (newScrollableHost !== scrollableHost) {
+                                scrollableHost = newScrollableHost;
+                                _this.observeForScrollableHostChanges(scrollableHost, mutationObserver);
+                                notifySubscribers(subscribers, scrollableHost);
+                            }
+                        });
                         _this.observeForScrollableHostChanges(scrollableHost, mutationObserver);
-                        behaviorSubject.next(scrollableHost);
                     }
+                    subscriber.next(scrollableHost);
+                    subscriber.add(function () {
+                        var subIndex = subscribers.indexOf(subscriber);
+                        /* sanity check */
+                        /* istanbul ignore else */
+                        if (subIndex >= 0) {
+                            subscribers.splice(subIndex, 1);
+                        }
+                        if (subscribers.length === 0) {
+                            mutationObserver.disconnect();
+                        }
+                    });
                 });
-                this.observeForScrollableHostChanges(scrollableHost, mutationObserver);
-                completionObservable.pipe(operators.take(1)).subscribe(function () {
-                    mutationObserver.disconnect();
+            };
+            /**
+             * 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 the scroll events from the given element's scrollable host
+             */
+            SkyScrollableHostService.prototype.watchScrollableHostScrollEvents = function (elementRef) {
+                var _this = this;
+                var subscribers = [];
+                var newScrollableHostObservable = new rxjs.Subject();
+                var scrollableHostSubscription;
+                var scrollEventSubscription;
+                return new rxjs.Observable(function (subscriber) {
+                    subscribers.push(subscriber);
+                    if (subscribers.length === 1) {
+                        scrollableHostSubscription = _this.watchScrollableHost(elementRef)
+                            .subscribe(function (scrollableHost) {
+                            newScrollableHostObservable.next();
+                            newScrollableHostObservable.complete();
+                            newScrollableHostObservable = new rxjs.Subject();
+                            scrollEventSubscription = rxjs.fromEvent(scrollableHost, 'scroll')
+                                .pipe(operators.takeUntil(newScrollableHostObservable))
+                                .subscribe(function () {
+                                notifySubscribers(subscribers);
+                            });
+                        });
+                    }
+                    subscriber.add(function () {
+                        var subIndex = subscribers.indexOf(subscriber);
+                        /* sanity check */
+                        /* istanbul ignore else */
+                        if (subIndex >= 0) {
+                            subscribers.splice(subIndex, 1);
+                        }
+                        if (subscribers.length === 0) {
+                            scrollableHostSubscription.unsubscribe();
+                            scrollEventSubscription.unsubscribe();
+                            newScrollableHostObservable.complete();
+                        }
+                    });
                 });
-                return behaviorSubject;
             };
             SkyScrollableHostService.prototype.findScrollableHost = function (element) {
                 var regex = /(auto|scroll)/;
@@ -3447,7 +3531,7 @@
                     else {
                         this.scrollableHostWatchUnsubscribe = new rxjs.Subject();
                     }
-                    this.scrollableHostService.watchScrollableHost(this.el, this.scrollableHostWatchUnsubscribe)
+                    this.scrollableHostService.watchScrollableHost(this.el)
                         .pipe(operators.takeUntil(this.scrollableHostWatchUnsubscribe))
                         .subscribe(function (scrollableHost) {
                         var e_3, _a;