@angular/common
Version:
Angular - commonly needed directives and services
249 lines • 17.1 kB
JavaScript
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
*/
/**
* @license
* Copyright Google Inc. 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
*/
import { ChangeDetectorRef, Injectable, Pipe, WrappedValue, ɵisObservable, ɵisPromise, ɵlooseIdentical } from '@angular/core';
import { invalidPipeArgumentError } from './invalid_pipe_argument_error';
/**
* @record
*/
function SubscriptionStrategy() { }
if (false) {
/**
* @param {?} async
* @param {?} updateLatestValue
* @return {?}
*/
SubscriptionStrategy.prototype.createSubscription = function (async, updateLatestValue) { };
/**
* @param {?} subscription
* @return {?}
*/
SubscriptionStrategy.prototype.dispose = function (subscription) { };
/**
* @param {?} subscription
* @return {?}
*/
SubscriptionStrategy.prototype.onDestroy = function (subscription) { };
}
class ObservableStrategy {
/**
* @param {?} async
* @param {?} updateLatestValue
* @return {?}
*/
createSubscription(async, updateLatestValue) {
return async.subscribe({ next: updateLatestValue, error: (/**
* @param {?} e
* @return {?}
*/
(e) => { throw e; }) });
}
/**
* @param {?} subscription
* @return {?}
*/
dispose(subscription) { subscription.unsubscribe(); }
/**
* @param {?} subscription
* @return {?}
*/
onDestroy(subscription) { subscription.unsubscribe(); }
}
class PromiseStrategy {
/**
* @param {?} async
* @param {?} updateLatestValue
* @return {?}
*/
createSubscription(async, updateLatestValue) {
return async.then(updateLatestValue, (/**
* @param {?} e
* @return {?}
*/
e => { throw e; }));
}
/**
* @param {?} subscription
* @return {?}
*/
dispose(subscription) { }
/**
* @param {?} subscription
* @return {?}
*/
onDestroy(subscription) { }
}
/** @type {?} */
const _promiseStrategy = new PromiseStrategy();
/** @type {?} */
const _observableStrategy = new ObservableStrategy();
/**
* \@ngModule CommonModule
* \@description
*
* Unwraps a value from an asynchronous primitive.
*
* The `async` pipe subscribes to an `Observable` or `Promise` and returns the latest value it has
* emitted. When a new value is emitted, the `async` pipe marks the component to be checked for
* changes. When the component gets destroyed, the `async` pipe unsubscribes automatically to avoid
* potential memory leaks.
*
* \@usageNotes
*
* ### Examples
*
* This example binds a `Promise` to the view. Clicking the `Resolve` button resolves the
* promise.
*
* {\@example common/pipes/ts/async_pipe.ts region='AsyncPipePromise'}
*
* It's also possible to use `async` with Observables. The example below binds the `time` Observable
* to the view. The Observable continuously updates the view with the current time.
*
* {\@example common/pipes/ts/async_pipe.ts region='AsyncPipeObservable'}
*
* \@publicApi
*/
export class AsyncPipe {
/**
* @param {?} _ref
*/
constructor(_ref) {
this._ref = _ref;
this._latestValue = null;
this._latestReturnedValue = null;
this._subscription = null;
this._obj = null;
this._strategy = (/** @type {?} */ (null));
}
/**
* @return {?}
*/
ngOnDestroy() {
if (this._subscription) {
this._dispose();
}
}
/**
* @param {?} obj
* @return {?}
*/
transform(obj) {
if (!this._obj) {
if (obj) {
this._subscribe(obj);
}
this._latestReturnedValue = this._latestValue;
return this._latestValue;
}
if (obj !== this._obj) {
this._dispose();
return this.transform((/** @type {?} */ (obj)));
}
if (ɵlooseIdentical(this._latestValue, this._latestReturnedValue)) {
return this._latestReturnedValue;
}
this._latestReturnedValue = this._latestValue;
return WrappedValue.wrap(this._latestValue);
}
/**
* @private
* @param {?} obj
* @return {?}
*/
_subscribe(obj) {
this._obj = obj;
this._strategy = this._selectStrategy(obj);
this._subscription = this._strategy.createSubscription(obj, (/**
* @param {?} value
* @return {?}
*/
(value) => this._updateLatestValue(obj, value)));
}
/**
* @private
* @param {?} obj
* @return {?}
*/
_selectStrategy(obj) {
if (ɵisPromise(obj)) {
return _promiseStrategy;
}
if (ɵisObservable(obj)) {
return _observableStrategy;
}
throw invalidPipeArgumentError(AsyncPipe, obj);
}
/**
* @private
* @return {?}
*/
_dispose() {
this._strategy.dispose((/** @type {?} */ (this._subscription)));
this._latestValue = null;
this._latestReturnedValue = null;
this._subscription = null;
this._obj = null;
}
/**
* @private
* @param {?} async
* @param {?} value
* @return {?}
*/
_updateLatestValue(async, value) {
if (async === this._obj) {
this._latestValue = value;
this._ref.markForCheck();
}
}
}
AsyncPipe.decorators = [
{ type: Injectable },
{ type: Pipe, args: [{ name: 'async', pure: false },] }
];
/** @nocollapse */
AsyncPipe.ctorParameters = () => [
{ type: ChangeDetectorRef }
];
if (false) {
/**
* @type {?}
* @private
*/
AsyncPipe.prototype._latestValue;
/**
* @type {?}
* @private
*/
AsyncPipe.prototype._latestReturnedValue;
/**
* @type {?}
* @private
*/
AsyncPipe.prototype._subscription;
/**
* @type {?}
* @private
*/
AsyncPipe.prototype._obj;
/**
* @type {?}
* @private
*/
AsyncPipe.prototype._strategy;
/**
* @type {?}
* @private
*/
AsyncPipe.prototype._ref;
}
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"async_pipe.js","sourceRoot":"","sources":["../../../../../../../packages/common/src/pipes/async_pipe.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n\nimport {ChangeDetectorRef, EventEmitter, Injectable, OnDestroy, Pipe, PipeTransform, WrappedValue, ɵisObservable, ɵisPromise, ɵlooseIdentical} from '@angular/core';\nimport {Observable, SubscriptionLike} from 'rxjs';\nimport {invalidPipeArgumentError} from './invalid_pipe_argument_error';\n\ninterface SubscriptionStrategy {\n  createSubscription(async: Observable<any>|Promise<any>, updateLatestValue: any): SubscriptionLike\n      |Promise<any>;\n  dispose(subscription: SubscriptionLike|Promise<any>): void;\n  onDestroy(subscription: SubscriptionLike|Promise<any>): void;\n}\n\nclass ObservableStrategy implements SubscriptionStrategy {\n  createSubscription(async: Observable<any>, updateLatestValue: any): SubscriptionLike {\n    return async.subscribe({next: updateLatestValue, error: (e: any) => { throw e; }});\n  }\n\n  dispose(subscription: SubscriptionLike): void { subscription.unsubscribe(); }\n\n  onDestroy(subscription: SubscriptionLike): void { subscription.unsubscribe(); }\n}\n\nclass PromiseStrategy implements SubscriptionStrategy {\n  createSubscription(async: Promise<any>, updateLatestValue: (v: any) => any): Promise<any> {\n    return async.then(updateLatestValue, e => { throw e; });\n  }\n\n  dispose(subscription: Promise<any>): void {}\n\n  onDestroy(subscription: Promise<any>): void {}\n}\n\nconst _promiseStrategy = new PromiseStrategy();\nconst _observableStrategy = new ObservableStrategy();\n\n/**\n * @ngModule CommonModule\n * @description\n *\n * Unwraps a value from an asynchronous primitive.\n *\n * The `async` pipe subscribes to an `Observable` or `Promise` and returns the latest value it has\n * emitted. When a new value is emitted, the `async` pipe marks the component to be checked for\n * changes. When the component gets destroyed, the `async` pipe unsubscribes automatically to avoid\n * potential memory leaks.\n *\n * @usageNotes\n *\n * ### Examples\n *\n * This example binds a `Promise` to the view. Clicking the `Resolve` button resolves the\n * promise.\n *\n * {@example common/pipes/ts/async_pipe.ts region='AsyncPipePromise'}\n *\n * It's also possible to use `async` with Observables. The example below binds the `time` Observable\n * to the view. The Observable continuously updates the view with the current time.\n *\n * {@example common/pipes/ts/async_pipe.ts region='AsyncPipeObservable'}\n *\n * @publicApi\n */\n@Injectable()\n@Pipe({name: 'async', pure: false})\nexport class AsyncPipe implements OnDestroy, PipeTransform {\n  private _latestValue: any = null;\n  private _latestReturnedValue: any = null;\n\n  private _subscription: SubscriptionLike|Promise<any>|null = null;\n  private _obj: Observable<any>|Promise<any>|EventEmitter<any>|null = null;\n  private _strategy: SubscriptionStrategy = null !;\n\n  constructor(private _ref: ChangeDetectorRef) {}\n\n  ngOnDestroy(): void {\n    if (this._subscription) {\n      this._dispose();\n    }\n  }\n\n  transform<T>(obj: null): null;\n  transform<T>(obj: undefined): undefined;\n  transform<T>(obj: Observable<T>|null|undefined): T|null;\n  transform<T>(obj: Promise<T>|null|undefined): T|null;\n  transform(obj: Observable<any>|Promise<any>|null|undefined): any {\n    if (!this._obj) {\n      if (obj) {\n        this._subscribe(obj);\n      }\n      this._latestReturnedValue = this._latestValue;\n      return this._latestValue;\n    }\n\n    if (obj !== this._obj) {\n      this._dispose();\n      return this.transform(obj as any);\n    }\n\n    if (ɵlooseIdentical(this._latestValue, this._latestReturnedValue)) {\n      return this._latestReturnedValue;\n    }\n\n    this._latestReturnedValue = this._latestValue;\n    return WrappedValue.wrap(this._latestValue);\n  }\n\n  private _subscribe(obj: Observable<any>|Promise<any>|EventEmitter<any>): void {\n    this._obj = obj;\n    this._strategy = this._selectStrategy(obj);\n    this._subscription = this._strategy.createSubscription(\n        obj, (value: Object) => this._updateLatestValue(obj, value));\n  }\n\n  private _selectStrategy(obj: Observable<any>|Promise<any>|EventEmitter<any>): any {\n    if (ɵisPromise(obj)) {\n      return _promiseStrategy;\n    }\n\n    if (ɵisObservable(obj)) {\n      return _observableStrategy;\n    }\n\n    throw invalidPipeArgumentError(AsyncPipe, obj);\n  }\n\n  private _dispose(): void {\n    this._strategy.dispose(this._subscription !);\n    this._latestValue = null;\n    this._latestReturnedValue = null;\n    this._subscription = null;\n    this._obj = null;\n  }\n\n  private _updateLatestValue(async: any, value: Object): void {\n    if (async === this._obj) {\n      this._latestValue = value;\n      this._ref.markForCheck();\n    }\n  }\n}\n"]}