| /** |
| * @license |
| * Copyright Google LLC All Rights Reserved. |
| * |
| * Use of this source code is governed by an MIT-style license that can be |
| * found in the LICENSE file at https://angular.io/license |
| */ |
| (function (global, factory) { |
| typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('@angular/cdk/coercion'), require('@angular/core'), require('rxjs'), require('rxjs/operators')) : |
| typeof define === 'function' && define.amd ? define('@angular/cdk/observers', ['exports', '@angular/cdk/coercion', '@angular/core', 'rxjs', 'rxjs/operators'], factory) : |
| (factory((global.ng = global.ng || {}, global.ng.cdk = global.ng.cdk || {}, global.ng.cdk.observers = {}),global.ng.cdk.coercion,global.ng.core,global.rxjs,global.rxjs.operators)); |
| }(this, (function (exports,coercion,core,rxjs,operators) { 'use strict'; |
| |
| /** |
| * @fileoverview added by tsickle |
| * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc |
| */ |
| /** |
| * Factory that creates a new MutationObserver and allows us to stub it out in unit tests. |
| * \@docs-private |
| */ |
| var MutationObserverFactory = /** @class */ (function () { |
| function MutationObserverFactory() { |
| } |
| /** |
| * @param {?} callback |
| * @return {?} |
| */ |
| MutationObserverFactory.prototype.create = /** |
| * @param {?} callback |
| * @return {?} |
| */ |
| function (callback) { |
| return typeof MutationObserver === 'undefined' ? null : new MutationObserver(callback); |
| }; |
| MutationObserverFactory.decorators = [ |
| { type: core.Injectable, args: [{ providedIn: 'root' },] }, |
| ]; |
| /** @nocollapse */ MutationObserverFactory.ngInjectableDef = core.ɵɵdefineInjectable({ factory: function MutationObserverFactory_Factory() { return new MutationObserverFactory(); }, token: MutationObserverFactory, providedIn: "root" }); |
| return MutationObserverFactory; |
| }()); |
| /** |
| * An injectable service that allows watching elements for changes to their content. |
| */ |
| var ContentObserver = /** @class */ (function () { |
| function ContentObserver(_mutationObserverFactory) { |
| this._mutationObserverFactory = _mutationObserverFactory; |
| /** |
| * Keeps track of the existing MutationObservers so they can be reused. |
| */ |
| this._observedElements = new Map(); |
| } |
| /** |
| * @return {?} |
| */ |
| ContentObserver.prototype.ngOnDestroy = /** |
| * @return {?} |
| */ |
| function () { |
| var _this = this; |
| this._observedElements.forEach((/** |
| * @param {?} _ |
| * @param {?} element |
| * @return {?} |
| */ |
| function (_, element) { return _this._cleanupObserver(element); })); |
| }; |
| /** |
| * @param {?} elementOrRef |
| * @return {?} |
| */ |
| ContentObserver.prototype.observe = /** |
| * @param {?} elementOrRef |
| * @return {?} |
| */ |
| function (elementOrRef) { |
| var _this = this; |
| /** @type {?} */ |
| var element = coercion.coerceElement(elementOrRef); |
| return new rxjs.Observable((/** |
| * @param {?} observer |
| * @return {?} |
| */ |
| function (observer) { |
| /** @type {?} */ |
| var stream = _this._observeElement(element); |
| /** @type {?} */ |
| var subscription = stream.subscribe(observer); |
| return (/** |
| * @return {?} |
| */ |
| function () { |
| subscription.unsubscribe(); |
| _this._unobserveElement(element); |
| }); |
| })); |
| }; |
| /** |
| * Observes the given element by using the existing MutationObserver if available, or creating a |
| * new one if not. |
| */ |
| /** |
| * Observes the given element by using the existing MutationObserver if available, or creating a |
| * new one if not. |
| * @private |
| * @param {?} element |
| * @return {?} |
| */ |
| ContentObserver.prototype._observeElement = /** |
| * Observes the given element by using the existing MutationObserver if available, or creating a |
| * new one if not. |
| * @private |
| * @param {?} element |
| * @return {?} |
| */ |
| function (element) { |
| if (!this._observedElements.has(element)) { |
| /** @type {?} */ |
| var stream_1 = new rxjs.Subject(); |
| /** @type {?} */ |
| var observer = this._mutationObserverFactory.create((/** |
| * @param {?} mutations |
| * @return {?} |
| */ |
| function (mutations) { return stream_1.next(mutations); })); |
| if (observer) { |
| observer.observe(element, { |
| characterData: true, |
| childList: true, |
| subtree: true |
| }); |
| } |
| this._observedElements.set(element, { observer: observer, stream: stream_1, count: 1 }); |
| } |
| else { |
| (/** @type {?} */ (this._observedElements.get(element))).count++; |
| } |
| return (/** @type {?} */ (this._observedElements.get(element))).stream; |
| }; |
| /** |
| * Un-observes the given element and cleans up the underlying MutationObserver if nobody else is |
| * observing this element. |
| */ |
| /** |
| * Un-observes the given element and cleans up the underlying MutationObserver if nobody else is |
| * observing this element. |
| * @private |
| * @param {?} element |
| * @return {?} |
| */ |
| ContentObserver.prototype._unobserveElement = /** |
| * Un-observes the given element and cleans up the underlying MutationObserver if nobody else is |
| * observing this element. |
| * @private |
| * @param {?} element |
| * @return {?} |
| */ |
| function (element) { |
| if (this._observedElements.has(element)) { |
| (/** @type {?} */ (this._observedElements.get(element))).count--; |
| if (!(/** @type {?} */ (this._observedElements.get(element))).count) { |
| this._cleanupObserver(element); |
| } |
| } |
| }; |
| /** Clean up the underlying MutationObserver for the specified element. */ |
| /** |
| * Clean up the underlying MutationObserver for the specified element. |
| * @private |
| * @param {?} element |
| * @return {?} |
| */ |
| ContentObserver.prototype._cleanupObserver = /** |
| * Clean up the underlying MutationObserver for the specified element. |
| * @private |
| * @param {?} element |
| * @return {?} |
| */ |
| function (element) { |
| if (this._observedElements.has(element)) { |
| var _a = (/** @type {?} */ (this._observedElements.get(element))), observer = _a.observer, stream = _a.stream; |
| if (observer) { |
| observer.disconnect(); |
| } |
| stream.complete(); |
| this._observedElements.delete(element); |
| } |
| }; |
| ContentObserver.decorators = [ |
| { type: core.Injectable, args: [{ providedIn: 'root' },] }, |
| ]; |
| /** @nocollapse */ |
| ContentObserver.ctorParameters = function () { return [ |
| { type: MutationObserverFactory } |
| ]; }; |
| /** @nocollapse */ ContentObserver.ngInjectableDef = core.ɵɵdefineInjectable({ factory: function ContentObserver_Factory() { return new ContentObserver(core.ɵɵinject(MutationObserverFactory)); }, token: ContentObserver, providedIn: "root" }); |
| return ContentObserver; |
| }()); |
| /** |
| * Directive that triggers a callback whenever the content of |
| * its associated element has changed. |
| */ |
| var CdkObserveContent = /** @class */ (function () { |
| function CdkObserveContent(_contentObserver, _elementRef, _ngZone) { |
| this._contentObserver = _contentObserver; |
| this._elementRef = _elementRef; |
| this._ngZone = _ngZone; |
| /** |
| * Event emitted for each change in the element's content. |
| */ |
| this.event = new core.EventEmitter(); |
| this._disabled = false; |
| this._currentSubscription = null; |
| } |
| Object.defineProperty(CdkObserveContent.prototype, "disabled", { |
| /** |
| * Whether observing content is disabled. This option can be used |
| * to disconnect the underlying MutationObserver until it is needed. |
| */ |
| get: /** |
| * Whether observing content is disabled. This option can be used |
| * to disconnect the underlying MutationObserver until it is needed. |
| * @return {?} |
| */ |
| function () { return this._disabled; }, |
| set: /** |
| * @param {?} value |
| * @return {?} |
| */ |
| function (value) { |
| this._disabled = coercion.coerceBooleanProperty(value); |
| this._disabled ? this._unsubscribe() : this._subscribe(); |
| }, |
| enumerable: true, |
| configurable: true |
| }); |
| Object.defineProperty(CdkObserveContent.prototype, "debounce", { |
| /** Debounce interval for emitting the changes. */ |
| get: /** |
| * Debounce interval for emitting the changes. |
| * @return {?} |
| */ |
| function () { return this._debounce; }, |
| set: /** |
| * @param {?} value |
| * @return {?} |
| */ |
| function (value) { |
| this._debounce = coercion.coerceNumberProperty(value); |
| this._subscribe(); |
| }, |
| enumerable: true, |
| configurable: true |
| }); |
| /** |
| * @return {?} |
| */ |
| CdkObserveContent.prototype.ngAfterContentInit = /** |
| * @return {?} |
| */ |
| function () { |
| if (!this._currentSubscription && !this.disabled) { |
| this._subscribe(); |
| } |
| }; |
| /** |
| * @return {?} |
| */ |
| CdkObserveContent.prototype.ngOnDestroy = /** |
| * @return {?} |
| */ |
| function () { |
| this._unsubscribe(); |
| }; |
| /** |
| * @private |
| * @return {?} |
| */ |
| CdkObserveContent.prototype._subscribe = /** |
| * @private |
| * @return {?} |
| */ |
| function () { |
| var _this = this; |
| this._unsubscribe(); |
| /** @type {?} */ |
| var stream = this._contentObserver.observe(this._elementRef); |
| // TODO(mmalerba): We shouldn't be emitting on this @Output() outside the zone. |
| // Consider brining it back inside the zone next time we're making breaking changes. |
| // Bringing it back inside can cause things like infinite change detection loops and changed |
| // after checked errors if people's code isn't handling it properly. |
| this._ngZone.runOutsideAngular((/** |
| * @return {?} |
| */ |
| function () { |
| _this._currentSubscription = |
| (_this.debounce ? stream.pipe(operators.debounceTime(_this.debounce)) : stream).subscribe(_this.event); |
| })); |
| }; |
| /** |
| * @private |
| * @return {?} |
| */ |
| CdkObserveContent.prototype._unsubscribe = /** |
| * @private |
| * @return {?} |
| */ |
| function () { |
| if (this._currentSubscription) { |
| this._currentSubscription.unsubscribe(); |
| } |
| }; |
| CdkObserveContent.decorators = [ |
| { type: core.Directive, args: [{ |
| selector: '[cdkObserveContent]', |
| exportAs: 'cdkObserveContent', |
| },] }, |
| ]; |
| /** @nocollapse */ |
| CdkObserveContent.ctorParameters = function () { return [ |
| { type: ContentObserver }, |
| { type: core.ElementRef }, |
| { type: core.NgZone } |
| ]; }; |
| CdkObserveContent.propDecorators = { |
| event: [{ type: core.Output, args: ['cdkObserveContent',] }], |
| disabled: [{ type: core.Input, args: ['cdkObserveContentDisabled',] }], |
| debounce: [{ type: core.Input }] |
| }; |
| return CdkObserveContent; |
| }()); |
| var ObserversModule = /** @class */ (function () { |
| function ObserversModule() { |
| } |
| ObserversModule.decorators = [ |
| { type: core.NgModule, args: [{ |
| exports: [CdkObserveContent], |
| declarations: [CdkObserveContent], |
| providers: [MutationObserverFactory] |
| },] }, |
| ]; |
| return ObserversModule; |
| }()); |
| |
| exports.MutationObserverFactory = MutationObserverFactory; |
| exports.ContentObserver = ContentObserver; |
| exports.CdkObserveContent = CdkObserveContent; |
| exports.ObserversModule = ObserversModule; |
| |
| Object.defineProperty(exports, '__esModule', { value: true }); |
| |
| }))); |
| //# sourceMappingURL=cdk-observers.umd.js.map |