angular2
Version:
Angular 2 - a web framework for modern web apps
128 lines • 14.8 kB
JavaScript
var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
return c > 3 && r && Object.defineProperty(target, key, r), r;
};
var __metadata = (this && this.__metadata) || function (k, v) {
if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
};
import { isBlank, isPresent, isPromise } from 'angular2/src/facade/lang';
import { ObservableWrapper } from 'angular2/src/facade/async';
import { Pipe, Injectable, ChangeDetectorRef, WrappedValue } from 'angular2/core';
import { InvalidPipeArgumentException } from './invalid_pipe_argument_exception';
class ObservableStrategy {
createSubscription(async, updateLatestValue) {
return ObservableWrapper.subscribe(async, updateLatestValue, e => { throw e; });
}
dispose(subscription) { ObservableWrapper.dispose(subscription); }
onDestroy(subscription) { ObservableWrapper.dispose(subscription); }
}
class PromiseStrategy {
createSubscription(async, updateLatestValue) {
return async.then(updateLatestValue);
}
dispose(subscription) { }
onDestroy(subscription) { }
}
var _promiseStrategy = new PromiseStrategy();
var _observableStrategy = new ObservableStrategy();
var __unused; // avoid unused import when Promise union types are erased
/**
* 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.
*
* ### Example
*
* This example binds a `Promise` to the view. Clicking the `Resolve` button resolves the
* promise.
*
* {@example core/pipes/ts/async_pipe/async_pipe_example.ts region='AsyncPipe'}
*
* It's also possible to use `async` with Observables. The example below binds the `time` Observable
* to the view. Every 500ms, the `time` Observable updates the view with the current time.
*
* ```typescript
* ```
*/
let AsyncPipe_1;
export let AsyncPipe = AsyncPipe_1 = class AsyncPipe {
constructor(_ref) {
/** @internal */
this._latestValue = null;
/** @internal */
this._latestReturnedValue = null;
/** @internal */
this._subscription = null;
/** @internal */
this._obj = null;
this._strategy = null;
this._ref = _ref;
}
ngOnDestroy() {
if (isPresent(this._subscription)) {
this._dispose();
}
}
transform(obj) {
if (isBlank(this._obj)) {
if (isPresent(obj)) {
this._subscribe(obj);
}
this._latestReturnedValue = this._latestValue;
return this._latestValue;
}
if (obj !== this._obj) {
this._dispose();
return this.transform(obj);
}
if (this._latestValue === this._latestReturnedValue) {
return this._latestReturnedValue;
}
else {
this._latestReturnedValue = this._latestValue;
return WrappedValue.wrap(this._latestValue);
}
}
/** @internal */
_subscribe(obj) {
this._obj = obj;
this._strategy = this._selectStrategy(obj);
this._subscription = this._strategy.createSubscription(obj, (value) => this._updateLatestValue(obj, value));
}
/** @internal */
_selectStrategy(obj) {
if (isPromise(obj)) {
return _promiseStrategy;
}
else if (ObservableWrapper.isObservable(obj)) {
return _observableStrategy;
}
else {
throw new InvalidPipeArgumentException(AsyncPipe_1, obj);
}
}
/** @internal */
_dispose() {
this._strategy.dispose(this._subscription);
this._latestValue = null;
this._latestReturnedValue = null;
this._subscription = null;
this._obj = null;
}
/** @internal */
_updateLatestValue(async, value) {
if (async === this._obj) {
this._latestValue = value;
this._ref.markForCheck();
}
}
};
AsyncPipe = AsyncPipe_1 = __decorate([
// avoid unused import when Promise union types are erased
Pipe({ name: 'async', pure: false }),
Injectable(),
__metadata('design:paramtypes', [ChangeDetectorRef])
], AsyncPipe);
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"async_pipe.js","sourceRoot":"","sources":["diffing_plugin_wrapper-output_path-xBLIBrVR.tmp/angular2/src/common/pipes/async_pipe.ts"],"names":[],"mappings":"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","sourcesContent":["import {isBlank, isPresent, isPromise, CONST} from 'angular2/src/facade/lang';\nimport {ObservableWrapper, Observable, EventEmitter} from 'angular2/src/facade/async';\nimport {Pipe, Injectable, ChangeDetectorRef, OnDestroy, WrappedValue} from 'angular2/core';\n\nimport {InvalidPipeArgumentException} from './invalid_pipe_argument_exception';\n\nclass ObservableStrategy {\n  createSubscription(async: any, updateLatestValue: any): any {\n    return ObservableWrapper.subscribe(async, updateLatestValue, e => { throw e; });\n  }\n\n  dispose(subscription: any): void { ObservableWrapper.dispose(subscription); }\n\n  onDestroy(subscription: any): void { ObservableWrapper.dispose(subscription); }\n}\n\nclass PromiseStrategy {\n  createSubscription(async: Promise<any>, updateLatestValue: (v: any) => any): any {\n    return async.then(updateLatestValue);\n  }\n\n  dispose(subscription: any): void {}\n\n  onDestroy(subscription: any): void {}\n}\n\nvar _promiseStrategy = new PromiseStrategy();\nvar _observableStrategy = new ObservableStrategy();\nvar __unused: Promise<any>;  // avoid unused import when Promise union types are erased\n\n/**\n * The `async` pipe subscribes to an Observable or Promise and returns the latest value it has\n * emitted.\n * When a new value is emitted, the `async` pipe marks the component to be checked for changes.\n *\n * ### Example\n *\n * This example binds a `Promise` to the view. Clicking the `Resolve` button resolves the\n * promise.\n *\n * {@example core/pipes/ts/async_pipe/async_pipe_example.ts region='AsyncPipe'}\n *\n * It's also possible to use `async` with Observables. The example below binds the `time` Observable\n * to the view. Every 500ms, the `time` Observable updates the view with the current time.\n *\n * ```typescript\n * ```\n */\n@Pipe({name: 'async', pure: false})\n@Injectable()\nexport class AsyncPipe implements OnDestroy {\n  /** @internal */\n  _latestValue: Object = null;\n  /** @internal */\n  _latestReturnedValue: Object = null;\n\n  /** @internal */\n  _subscription: Object = null;\n  /** @internal */\n  _obj: Observable<any>| Promise<any>| EventEmitter<any> = null;\n  private _strategy: any = null;\n  /** @internal */\n  public _ref: ChangeDetectorRef;\n  constructor(_ref: ChangeDetectorRef) { this._ref = _ref; }\n\n  ngOnDestroy(): void {\n    if (isPresent(this._subscription)) {\n      this._dispose();\n    }\n  }\n\n  transform(obj: Observable<any>| Promise<any>| EventEmitter<any>): any {\n    if (isBlank(this._obj)) {\n      if (isPresent(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);\n    }\n\n    if (this._latestValue === this._latestReturnedValue) {\n      return this._latestReturnedValue;\n    } else {\n      this._latestReturnedValue = this._latestValue;\n      return WrappedValue.wrap(this._latestValue);\n    }\n  }\n\n  /** @internal */\n  _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  /** @internal */\n  _selectStrategy(obj: Observable<any>| Promise<any>| EventEmitter<any>): any {\n    if (isPromise(obj)) {\n      return _promiseStrategy;\n    } else if (ObservableWrapper.isObservable(obj)) {\n      return _observableStrategy;\n    } else {\n      throw new InvalidPipeArgumentException(AsyncPipe, obj);\n    }\n  }\n\n  /** @internal */\n  _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  /** @internal */\n  _updateLatestValue(async: any, value: Object) {\n    if (async === this._obj) {\n      this._latestValue = value;\n      this._ref.markForCheck();\n    }\n  }\n}\n"]}