angular2
Version:
Angular 2 - a web framework for modern web apps
1,412 lines (1,123 loc) • 1.96 MB
JavaScript
(function webpackUniversalModuleDefinition(root, factory) {
if(typeof exports === 'object' && typeof module === 'object')
module.exports = factory();
else if(typeof define === 'function' && define.amd)
define([], factory);
else if(typeof exports === 'object')
exports["ng"] = factory();
else
root["ng"] = factory();
})(this, function() {
return /******/ (function(modules) { // webpackBootstrap
/******/ // The module cache
/******/ var installedModules = {};
/******/ // The require function
/******/ function __webpack_require__(moduleId) {
/******/ // Check if module is in cache
/******/ if(installedModules[moduleId])
/******/ return installedModules[moduleId].exports;
/******/ // Create a new module (and put it into the cache)
/******/ var module = installedModules[moduleId] = {
/******/ exports: {},
/******/ id: moduleId,
/******/ loaded: false
/******/ };
/******/ // Execute the module function
/******/ modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);
/******/ // Flag the module as loaded
/******/ module.loaded = true;
/******/ // Return the exports of the module
/******/ return module.exports;
/******/ }
/******/ // expose the modules object (__webpack_modules__)
/******/ __webpack_require__.m = modules;
/******/ // expose the module cache
/******/ __webpack_require__.c = installedModules;
/******/ // __webpack_public_path__
/******/ __webpack_require__.p = "";
/******/ // Load entry module and return exports
/******/ return __webpack_require__(0);
/******/ })
/************************************************************************/
/******/ ([
/* 0 */
/***/ function(module, exports, __webpack_require__) {
__webpack_require__(1);
__webpack_require__(358);
module.exports = __webpack_require__(374);
/***/ },
/* 1 */
/***/ function(module, exports, __webpack_require__) {
function __export(m) {
for (var p in m) if (!exports.hasOwnProperty(p)) exports[p] = m[p];
}
__export(__webpack_require__(2));
__export(__webpack_require__(151));
__export(__webpack_require__(286));
__export(__webpack_require__(287));
__export(__webpack_require__(289));
__export(__webpack_require__(291));
__export(__webpack_require__(350));
var compiler_1 = __webpack_require__(320);
exports.UrlResolver = compiler_1.UrlResolver;
exports.AppRootUrl = compiler_1.AppRootUrl;
/***/ },
/* 2 */
/***/ function(module, exports, __webpack_require__) {
function __export(m) {
for (var p in m) if (!exports.hasOwnProperty(p)) exports[p] = m[p];
}
__export(__webpack_require__(3));
__export(__webpack_require__(254));
__export(__webpack_require__(262));
__export(__webpack_require__(285));
/***/ },
/* 3 */
/***/ function(module, exports, __webpack_require__) {
/**
* @module
* @description
* This module provides a set of common Pipes.
*/
var async_pipe_1 = __webpack_require__(4);
var uppercase_pipe_1 = __webpack_require__(247);
var lowercase_pipe_1 = __webpack_require__(248);
var json_pipe_1 = __webpack_require__(249);
var slice_pipe_1 = __webpack_require__(250);
var date_pipe_1 = __webpack_require__(251);
var number_pipe_1 = __webpack_require__(253);
var lang_1 = __webpack_require__(5);
var async_pipe_2 = __webpack_require__(4);
exports.AsyncPipe = async_pipe_2.AsyncPipe;
var date_pipe_2 = __webpack_require__(251);
exports.DatePipe = date_pipe_2.DatePipe;
var json_pipe_2 = __webpack_require__(249);
exports.JsonPipe = json_pipe_2.JsonPipe;
var slice_pipe_2 = __webpack_require__(250);
exports.SlicePipe = slice_pipe_2.SlicePipe;
var lowercase_pipe_2 = __webpack_require__(248);
exports.LowerCasePipe = lowercase_pipe_2.LowerCasePipe;
var number_pipe_2 = __webpack_require__(253);
exports.NumberPipe = number_pipe_2.NumberPipe;
exports.DecimalPipe = number_pipe_2.DecimalPipe;
exports.PercentPipe = number_pipe_2.PercentPipe;
exports.CurrencyPipe = number_pipe_2.CurrencyPipe;
var uppercase_pipe_2 = __webpack_require__(247);
exports.UpperCasePipe = uppercase_pipe_2.UpperCasePipe;
exports.COMMON_PIPES = lang_1.CONST_EXPR([
async_pipe_1.AsyncPipe,
uppercase_pipe_1.UpperCasePipe,
lowercase_pipe_1.LowerCasePipe,
json_pipe_1.JsonPipe,
slice_pipe_1.SlicePipe,
number_pipe_1.DecimalPipe,
number_pipe_1.PercentPipe,
number_pipe_1.CurrencyPipe,
date_pipe_1.DatePipe
]);
/***/ },
/* 4 */
/***/ function(module, exports, __webpack_require__) {
var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
if (typeof Reflect === "object" && typeof Reflect.decorate === "function") return Reflect.decorate(decorators, target, key, desc);
switch (arguments.length) {
case 2: return decorators.reduceRight(function(o, d) { return (d && d(o)) || o; }, target);
case 3: return decorators.reduceRight(function(o, d) { return (d && d(target, key)), void 0; }, void 0);
case 4: return decorators.reduceRight(function(o, d) { return (d && d(target, key, o)) || o; }, desc);
}
};
var __metadata = (this && this.__metadata) || function (k, v) {
if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
};
var lang_1 = __webpack_require__(5);
var async_1 = __webpack_require__(6);
var core_1 = __webpack_require__(151);
var invalid_pipe_argument_exception_1 = __webpack_require__(246);
var ObservableStrategy = (function () {
function ObservableStrategy() {
}
ObservableStrategy.prototype.createSubscription = function (async, updateLatestValue) {
return async_1.ObservableWrapper.subscribe(async, updateLatestValue, function (e) { throw e; });
};
ObservableStrategy.prototype.dispose = function (subscription) { async_1.ObservableWrapper.dispose(subscription); };
ObservableStrategy.prototype.onDestroy = function (subscription) { async_1.ObservableWrapper.dispose(subscription); };
return ObservableStrategy;
})();
var PromiseStrategy = (function () {
function PromiseStrategy() {
}
PromiseStrategy.prototype.createSubscription = function (async, updateLatestValue) {
return async.then(updateLatestValue);
};
PromiseStrategy.prototype.dispose = function (subscription) { };
PromiseStrategy.prototype.onDestroy = function (subscription) { };
return PromiseStrategy;
})();
var _promiseStrategy = new PromiseStrategy();
var _observableStrategy = new ObservableStrategy();
/**
* 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
* ```
*/
var AsyncPipe = (function () {
function AsyncPipe(_ref) {
/** @internal */
this._latestValue = null;
/** @internal */
this._latestReturnedValue = null;
/** @internal */
this._subscription = null;
/** @internal */
this._obj = null;
this._strategy = null;
this._ref = _ref;
}
AsyncPipe.prototype.ngOnDestroy = function () {
if (lang_1.isPresent(this._subscription)) {
this._dispose();
}
};
AsyncPipe.prototype.transform = function (obj, args) {
if (lang_1.isBlank(this._obj)) {
if (lang_1.isPresent(obj)) {
this._subscribe(obj);
}
return null;
}
if (obj !== this._obj) {
this._dispose();
return this.transform(obj);
}
if (this._latestValue === this._latestReturnedValue) {
return this._latestReturnedValue;
}
else {
this._latestReturnedValue = this._latestValue;
return core_1.WrappedValue.wrap(this._latestValue);
}
};
/** @internal */
AsyncPipe.prototype._subscribe = function (obj) {
var _this = this;
this._obj = obj;
this._strategy = this._selectStrategy(obj);
this._subscription =
this._strategy.createSubscription(obj, function (value) { return _this._updateLatestValue(obj, value); });
};
/** @internal */
AsyncPipe.prototype._selectStrategy = function (obj) {
if (lang_1.isPromise(obj)) {
return _promiseStrategy;
}
else if (async_1.ObservableWrapper.isObservable(obj)) {
return _observableStrategy;
}
else {
throw new invalid_pipe_argument_exception_1.InvalidPipeArgumentException(AsyncPipe, obj);
}
};
/** @internal */
AsyncPipe.prototype._dispose = function () {
this._strategy.dispose(this._subscription);
this._latestValue = null;
this._latestReturnedValue = null;
this._subscription = null;
this._obj = null;
};
/** @internal */
AsyncPipe.prototype._updateLatestValue = function (async, value) {
if (async === this._obj) {
this._latestValue = value;
this._ref.markForCheck();
}
};
AsyncPipe = __decorate([
core_1.Pipe({ name: 'async', pure: false }),
core_1.Injectable(),
__metadata('design:paramtypes', [core_1.ChangeDetectorRef])
], AsyncPipe);
return AsyncPipe;
})();
exports.AsyncPipe = AsyncPipe;
/***/ },
/* 5 */
/***/ function(module, exports) {
/* WEBPACK VAR INJECTION */(function(global) {var __extends = (this && this.__extends) || function (d, b) {
for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
var globalScope;
if (typeof window === 'undefined') {
if (typeof WorkerGlobalScope !== 'undefined' && self instanceof WorkerGlobalScope) {
// TODO: Replace any with WorkerGlobalScope from lib.webworker.d.ts #3492
globalScope = self;
}
else {
globalScope = global;
}
}
else {
globalScope = window;
}
;
exports.IS_DART = false;
// Need to declare a new variable for global here since TypeScript
// exports the original value of the symbol.
var _global = globalScope;
exports.global = _global;
exports.Type = Function;
function getTypeNameForDebugging(type) {
return type['name'];
}
exports.getTypeNameForDebugging = getTypeNameForDebugging;
exports.Math = _global.Math;
exports.Date = _global.Date;
var _devMode = !!_global.angularDevMode;
var _devModeLocked = false;
function lockDevMode() {
_devModeLocked = true;
}
exports.lockDevMode = lockDevMode;
/**
* Enable Angular's development mode, which turns on assertions and other
* checks within the framework.
*
* One important assertion this enables verifies that a change detection pass
* does not result in additional changes to any bindings (also known as
* unidirectional data flow).
*
* {@example core/ts/dev_mode/dev_mode_example.ts region='enableDevMode'}
*/
function enableDevMode() {
// TODO(alxhub): Refactor out of facade/lang as per issue #5157.
if (_devModeLocked) {
// Cannot use BaseException as that ends up importing from facade/lang.
throw 'Cannot enable dev mode after platform setup.';
}
_devMode = true;
}
exports.enableDevMode = enableDevMode;
function assertionsEnabled() {
return _devMode;
}
exports.assertionsEnabled = assertionsEnabled;
// TODO: remove calls to assert in production environment
// Note: Can't just export this and import in in other files
// as `assert` is a reserved keyword in Dart
_global.assert = function assert(condition) {
// TODO: to be fixed properly via #2830, noop for now
};
// This function is needed only to properly support Dart's const expressions
// see https://github.com/angular/ts2dart/pull/151 for more info
function CONST_EXPR(expr) {
return expr;
}
exports.CONST_EXPR = CONST_EXPR;
function CONST() {
return function (target) { return target; };
}
exports.CONST = CONST;
function isPresent(obj) {
return obj !== undefined && obj !== null;
}
exports.isPresent = isPresent;
function isBlank(obj) {
return obj === undefined || obj === null;
}
exports.isBlank = isBlank;
function isString(obj) {
return typeof obj === "string";
}
exports.isString = isString;
function isFunction(obj) {
return typeof obj === "function";
}
exports.isFunction = isFunction;
function isType(obj) {
return isFunction(obj);
}
exports.isType = isType;
function isStringMap(obj) {
return typeof obj === 'object' && obj !== null;
}
exports.isStringMap = isStringMap;
function isPromise(obj) {
return obj instanceof _global.Promise;
}
exports.isPromise = isPromise;
function isArray(obj) {
return Array.isArray(obj);
}
exports.isArray = isArray;
function isNumber(obj) {
return typeof obj === 'number';
}
exports.isNumber = isNumber;
function isDate(obj) {
return obj instanceof exports.Date && !isNaN(obj.valueOf());
}
exports.isDate = isDate;
function noop() { }
exports.noop = noop;
function stringify(token) {
if (typeof token === 'string') {
return token;
}
if (token === undefined || token === null) {
return '' + token;
}
if (token.name) {
return token.name;
}
var res = token.toString();
var newLineIndex = res.indexOf("\n");
return (newLineIndex === -1) ? res : res.substring(0, newLineIndex);
}
exports.stringify = stringify;
// serialize / deserialize enum exist only for consistency with dart API
// enums in typescript don't need to be serialized
function serializeEnum(val) {
return val;
}
exports.serializeEnum = serializeEnum;
function deserializeEnum(val, values) {
return val;
}
exports.deserializeEnum = deserializeEnum;
var StringWrapper = (function () {
function StringWrapper() {
}
StringWrapper.fromCharCode = function (code) { return String.fromCharCode(code); };
StringWrapper.charCodeAt = function (s, index) { return s.charCodeAt(index); };
StringWrapper.split = function (s, regExp) { return s.split(regExp); };
StringWrapper.equals = function (s, s2) { return s === s2; };
StringWrapper.replace = function (s, from, replace) {
return s.replace(from, replace);
};
StringWrapper.replaceAll = function (s, from, replace) {
return s.replace(from, replace);
};
StringWrapper.slice = function (s, from, to) {
if (from === void 0) { from = 0; }
if (to === void 0) { to = null; }
return s.slice(from, to === null ? undefined : to);
};
StringWrapper.replaceAllMapped = function (s, from, cb) {
return s.replace(from, function () {
var matches = [];
for (var _i = 0; _i < arguments.length; _i++) {
matches[_i - 0] = arguments[_i];
}
// Remove offset & string from the result array
matches.splice(-2, 2);
// The callback receives match, p1, ..., pn
return cb(matches);
});
};
StringWrapper.contains = function (s, substr) { return s.indexOf(substr) != -1; };
StringWrapper.compare = function (a, b) {
if (a < b) {
return -1;
}
else if (a > b) {
return 1;
}
else {
return 0;
}
};
return StringWrapper;
})();
exports.StringWrapper = StringWrapper;
var StringJoiner = (function () {
function StringJoiner(parts) {
if (parts === void 0) { parts = []; }
this.parts = parts;
}
StringJoiner.prototype.add = function (part) { this.parts.push(part); };
StringJoiner.prototype.toString = function () { return this.parts.join(""); };
return StringJoiner;
})();
exports.StringJoiner = StringJoiner;
var NumberParseError = (function (_super) {
__extends(NumberParseError, _super);
function NumberParseError(message) {
_super.call(this);
this.message = message;
}
NumberParseError.prototype.toString = function () { return this.message; };
return NumberParseError;
})(Error);
exports.NumberParseError = NumberParseError;
var NumberWrapper = (function () {
function NumberWrapper() {
}
NumberWrapper.toFixed = function (n, fractionDigits) { return n.toFixed(fractionDigits); };
NumberWrapper.equal = function (a, b) { return a === b; };
NumberWrapper.parseIntAutoRadix = function (text) {
var result = parseInt(text);
if (isNaN(result)) {
throw new NumberParseError("Invalid integer literal when parsing " + text);
}
return result;
};
NumberWrapper.parseInt = function (text, radix) {
if (radix == 10) {
if (/^(\-|\+)?[0-9]+$/.test(text)) {
return parseInt(text, radix);
}
}
else if (radix == 16) {
if (/^(\-|\+)?[0-9ABCDEFabcdef]+$/.test(text)) {
return parseInt(text, radix);
}
}
else {
var result = parseInt(text, radix);
if (!isNaN(result)) {
return result;
}
}
throw new NumberParseError("Invalid integer literal when parsing " + text + " in base " +
radix);
};
// TODO: NaN is a valid literal but is returned by parseFloat to indicate an error.
NumberWrapper.parseFloat = function (text) { return parseFloat(text); };
Object.defineProperty(NumberWrapper, "NaN", {
get: function () { return NaN; },
enumerable: true,
configurable: true
});
NumberWrapper.isNaN = function (value) { return isNaN(value); };
NumberWrapper.isInteger = function (value) { return Number.isInteger(value); };
return NumberWrapper;
})();
exports.NumberWrapper = NumberWrapper;
exports.RegExp = _global.RegExp;
var RegExpWrapper = (function () {
function RegExpWrapper() {
}
RegExpWrapper.create = function (regExpStr, flags) {
if (flags === void 0) { flags = ''; }
flags = flags.replace(/g/g, '');
return new _global.RegExp(regExpStr, flags + 'g');
};
RegExpWrapper.firstMatch = function (regExp, input) {
// Reset multimatch regex state
regExp.lastIndex = 0;
return regExp.exec(input);
};
RegExpWrapper.test = function (regExp, input) {
regExp.lastIndex = 0;
return regExp.test(input);
};
RegExpWrapper.matcher = function (regExp, input) {
// Reset regex state for the case
// someone did not loop over all matches
// last time.
regExp.lastIndex = 0;
return { re: regExp, input: input };
};
return RegExpWrapper;
})();
exports.RegExpWrapper = RegExpWrapper;
var RegExpMatcherWrapper = (function () {
function RegExpMatcherWrapper() {
}
RegExpMatcherWrapper.next = function (matcher) {
return matcher.re.exec(matcher.input);
};
return RegExpMatcherWrapper;
})();
exports.RegExpMatcherWrapper = RegExpMatcherWrapper;
var FunctionWrapper = (function () {
function FunctionWrapper() {
}
FunctionWrapper.apply = function (fn, posArgs) { return fn.apply(null, posArgs); };
return FunctionWrapper;
})();
exports.FunctionWrapper = FunctionWrapper;
// JS has NaN !== NaN
function looseIdentical(a, b) {
return a === b || typeof a === "number" && typeof b === "number" && isNaN(a) && isNaN(b);
}
exports.looseIdentical = looseIdentical;
// JS considers NaN is the same as NaN for map Key (while NaN !== NaN otherwise)
// see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map
function getMapKey(value) {
return value;
}
exports.getMapKey = getMapKey;
function normalizeBlank(obj) {
return isBlank(obj) ? null : obj;
}
exports.normalizeBlank = normalizeBlank;
function normalizeBool(obj) {
return isBlank(obj) ? false : obj;
}
exports.normalizeBool = normalizeBool;
function isJsObject(o) {
return o !== null && (typeof o === "function" || typeof o === "object");
}
exports.isJsObject = isJsObject;
function print(obj) {
console.log(obj);
}
exports.print = print;
// Can't be all uppercase as our transpiler would think it is a special directive...
var Json = (function () {
function Json() {
}
Json.parse = function (s) { return _global.JSON.parse(s); };
Json.stringify = function (data) {
// Dart doesn't take 3 arguments
return _global.JSON.stringify(data, null, 2);
};
return Json;
})();
exports.Json = Json;
var DateWrapper = (function () {
function DateWrapper() {
}
DateWrapper.create = function (year, month, day, hour, minutes, seconds, milliseconds) {
if (month === void 0) { month = 1; }
if (day === void 0) { day = 1; }
if (hour === void 0) { hour = 0; }
if (minutes === void 0) { minutes = 0; }
if (seconds === void 0) { seconds = 0; }
if (milliseconds === void 0) { milliseconds = 0; }
return new exports.Date(year, month - 1, day, hour, minutes, seconds, milliseconds);
};
DateWrapper.fromISOString = function (str) { return new exports.Date(str); };
DateWrapper.fromMillis = function (ms) { return new exports.Date(ms); };
DateWrapper.toMillis = function (date) { return date.getTime(); };
DateWrapper.now = function () { return new exports.Date(); };
DateWrapper.toJson = function (date) { return date.toJSON(); };
return DateWrapper;
})();
exports.DateWrapper = DateWrapper;
function setValueOnPath(global, path, value) {
var parts = path.split('.');
var obj = global;
while (parts.length > 1) {
var name = parts.shift();
if (obj.hasOwnProperty(name)) {
obj = obj[name];
}
else {
obj = obj[name] = {};
}
}
if (obj === undefined || obj === null) {
obj = {};
}
obj[parts.shift()] = value;
}
exports.setValueOnPath = setValueOnPath;
var _symbolIterator = null;
function getSymbolIterator() {
if (isBlank(_symbolIterator)) {
if (isPresent(Symbol) && isPresent(Symbol.iterator)) {
_symbolIterator = Symbol.iterator;
}
else {
// es6-shim specific logic
var keys = Object.getOwnPropertyNames(Map.prototype);
for (var i = 0; i < keys.length; ++i) {
var key = keys[i];
if (key !== 'entries' && key !== 'size' &&
Map.prototype[key] === Map.prototype['entries']) {
_symbolIterator = key;
}
}
}
}
return _symbolIterator;
}
exports.getSymbolIterator = getSymbolIterator;
/* WEBPACK VAR INJECTION */}.call(exports, (function() { return this; }())))
/***/ },
/* 6 */
/***/ function(module, exports, __webpack_require__) {
var __extends = (this && this.__extends) || function (d, b) {
for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
var lang_1 = __webpack_require__(5);
var promise_1 = __webpack_require__(7);
exports.PromiseWrapper = promise_1.PromiseWrapper;
exports.Promise = promise_1.Promise;
var Rx_1 = __webpack_require__(8);
var Rx_2 = __webpack_require__(8);
exports.Subject = Rx_2.Subject;
var TimerWrapper = (function () {
function TimerWrapper() {
}
TimerWrapper.setTimeout = function (fn, millis) {
return lang_1.global.setTimeout(fn, millis);
};
TimerWrapper.clearTimeout = function (id) { lang_1.global.clearTimeout(id); };
TimerWrapper.setInterval = function (fn, millis) {
return lang_1.global.setInterval(fn, millis);
};
TimerWrapper.clearInterval = function (id) { lang_1.global.clearInterval(id); };
return TimerWrapper;
})();
exports.TimerWrapper = TimerWrapper;
var ObservableWrapper = (function () {
function ObservableWrapper() {
}
// TODO(vsavkin): when we use rxnext, try inferring the generic type from the first arg
ObservableWrapper.subscribe = function (emitter, onNext, onError, onComplete) {
if (onComplete === void 0) { onComplete = function () { }; }
onError = (typeof onError === "function") && onError || lang_1.noop;
onComplete = (typeof onComplete === "function") && onComplete || lang_1.noop;
return emitter.subscribe({ next: onNext, error: onError, complete: onComplete });
};
ObservableWrapper.isObservable = function (obs) { return obs instanceof Rx_1.Observable; };
/**
* Returns whether `obs` has any subscribers listening to events.
*/
ObservableWrapper.hasSubscribers = function (obs) { return obs.observers.length > 0; };
ObservableWrapper.dispose = function (subscription) { subscription.unsubscribe(); };
/**
* @deprecated - use callEmit() instead
*/
ObservableWrapper.callNext = function (emitter, value) { emitter.next(value); };
ObservableWrapper.callEmit = function (emitter, value) { emitter.emit(value); };
ObservableWrapper.callError = function (emitter, error) { emitter.error(error); };
ObservableWrapper.callComplete = function (emitter) { emitter.complete(); };
ObservableWrapper.fromPromise = function (promise) {
return Rx_1.Observable.fromPromise(promise);
};
ObservableWrapper.toPromise = function (obj) { return obj.toPromise(); };
return ObservableWrapper;
})();
exports.ObservableWrapper = ObservableWrapper;
/**
* Use by directives and components to emit custom Events.
*
* ### Examples
*
* In the following example, `Zippy` alternatively emits `open` and `close` events when its
* title gets clicked:
*
* ```
* @Component({
* selector: 'zippy',
* template: `
* <div class="zippy">
* <div (click)="toggle()">Toggle</div>
* <div [hidden]="!visible">
* <ng-content></ng-content>
* </div>
* </div>`})
* export class Zippy {
* visible: boolean = true;
* @Output() open: EventEmitter<any> = new EventEmitter();
* @Output() close: EventEmitter<any> = new EventEmitter();
*
* toggle() {
* this.visible = !this.visible;
* if (this.visible) {
* this.open.emit(null);
* } else {
* this.close.emit(null);
* }
* }
* }
* ```
*
* Use Rx.Observable but provides an adapter to make it work as specified here:
* https://github.com/jhusain/observable-spec
*
* Once a reference implementation of the spec is available, switch to it.
*/
var EventEmitter = (function (_super) {
__extends(EventEmitter, _super);
/**
* Creates an instance of [EventEmitter], which depending on [isAsync],
* delivers events synchronously or asynchronously.
*/
function EventEmitter(isAsync) {
if (isAsync === void 0) { isAsync = true; }
_super.call(this);
this._isAsync = isAsync;
}
EventEmitter.prototype.emit = function (value) { _super.prototype.next.call(this, value); };
/**
* @deprecated - use .emit(value) instead
*/
EventEmitter.prototype.next = function (value) { _super.prototype.next.call(this, value); };
EventEmitter.prototype.subscribe = function (generatorOrNext, error, complete) {
var schedulerFn;
var errorFn = function (err) { return null; };
var completeFn = function () { return null; };
if (generatorOrNext && typeof generatorOrNext === 'object') {
schedulerFn = this._isAsync ? function (value) { setTimeout(function () { return generatorOrNext.next(value); }); } :
function (value) { generatorOrNext.next(value); };
if (generatorOrNext.error) {
errorFn = this._isAsync ? function (err) { setTimeout(function () { return generatorOrNext.error(err); }); } :
function (err) { generatorOrNext.error(err); };
}
if (generatorOrNext.complete) {
completeFn = this._isAsync ? function () { setTimeout(function () { return generatorOrNext.complete(); }); } :
function () { generatorOrNext.complete(); };
}
}
else {
schedulerFn = this._isAsync ? function (value) { setTimeout(function () { return generatorOrNext(value); }); } :
function (value) { generatorOrNext(value); };
if (error) {
errorFn =
this._isAsync ? function (err) { setTimeout(function () { return error(err); }); } : function (err) { error(err); };
}
if (complete) {
completeFn =
this._isAsync ? function () { setTimeout(function () { return complete(); }); } : function () { complete(); };
}
}
return _super.prototype.subscribe.call(this, schedulerFn, errorFn, completeFn);
};
return EventEmitter;
})(Rx_1.Subject);
exports.EventEmitter = EventEmitter;
// todo(robwormald): ts2dart should handle this properly
var Observable = (function (_super) {
__extends(Observable, _super);
function Observable() {
_super.apply(this, arguments);
}
Observable.prototype.lift = function (operator) {
var observable = new Observable();
observable.source = this;
observable.operator = operator;
return observable;
};
return Observable;
})(Rx_1.Observable);
exports.Observable = Observable;
/***/ },
/* 7 */
/***/ function(module, exports) {
// Promises are put into their own facade file so that they can be used without
// introducing a dependency on rxjs. They are re-exported through facade/async.
var PromiseWrapper = (function () {
function PromiseWrapper() {
}
PromiseWrapper.resolve = function (obj) { return Promise.resolve(obj); };
PromiseWrapper.reject = function (obj, _) { return Promise.reject(obj); };
// Note: We can't rename this method into `catch`, as this is not a valid
// method name in Dart.
PromiseWrapper.catchError = function (promise, onError) {
return promise.catch(onError);
};
PromiseWrapper.all = function (promises) {
if (promises.length == 0)
return Promise.resolve([]);
return Promise.all(promises);
};
PromiseWrapper.then = function (promise, success, rejection) {
return promise.then(success, rejection);
};
PromiseWrapper.wrap = function (computation) {
return new Promise(function (res, rej) {
try {
res(computation());
}
catch (e) {
rej(e);
}
});
};
PromiseWrapper.scheduleMicrotask = function (computation) {
PromiseWrapper.then(PromiseWrapper.resolve(null), computation, function (_) { });
};
PromiseWrapper.isPromise = function (obj) { return obj instanceof Promise; };
PromiseWrapper.completer = function () {
var resolve;
var reject;
var p = new Promise(function (res, rej) {
resolve = res;
reject = rej;
});
return { promise: p, resolve: resolve, reject: reject };
};
return PromiseWrapper;
})();
exports.PromiseWrapper = PromiseWrapper;
/***/ },
/* 8 */
/***/ function(module, exports, __webpack_require__) {
'use strict';
exports.__esModule = true;
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
var _Observable = __webpack_require__(9);
var _Observable2 = _interopRequireDefault(_Observable);
var _operatorsCombineLatestStatic = __webpack_require__(18);
var _operatorsCombineLatestStatic2 = _interopRequireDefault(_operatorsCombineLatestStatic);
var _operatorsConcatStatic = __webpack_require__(30);
var _operatorsConcatStatic2 = _interopRequireDefault(_operatorsConcatStatic);
var _observablesDeferObservable = __webpack_require__(35);
var _observablesDeferObservable2 = _interopRequireDefault(_observablesDeferObservable);
var _observablesEmptyObservable = __webpack_require__(24);
var _observablesEmptyObservable2 = _interopRequireDefault(_observablesEmptyObservable);
var _observablesForkJoinObservable = __webpack_require__(36);
var _observablesForkJoinObservable2 = _interopRequireDefault(_observablesForkJoinObservable);
var _observablesFromObservable = __webpack_require__(37);
var _observablesFromObservable2 = _interopRequireDefault(_observablesFromObservable);
var _observablesArrayObservable = __webpack_require__(19);
var _observablesArrayObservable2 = _interopRequireDefault(_observablesArrayObservable);
var _observablesFromEventObservable = __webpack_require__(42);
var _observablesFromEventObservable2 = _interopRequireDefault(_observablesFromEventObservable);
var _observablesFromEventPatternObservable = __webpack_require__(43);
var _observablesFromEventPatternObservable2 = _interopRequireDefault(_observablesFromEventPatternObservable);
var _observablesPromiseObservable = __webpack_require__(38);
var _observablesPromiseObservable2 = _interopRequireDefault(_observablesPromiseObservable);
var _observablesIntervalObservable = __webpack_require__(44);
var _observablesIntervalObservable2 = _interopRequireDefault(_observablesIntervalObservable);
var _operatorsMergeStatic = __webpack_require__(52);
var _operatorsMergeStatic2 = _interopRequireDefault(_operatorsMergeStatic);
var _observablesInfiniteObservable = __webpack_require__(54);
var _observablesInfiniteObservable2 = _interopRequireDefault(_observablesInfiniteObservable);
var _observablesRangeObservable = __webpack_require__(55);
var _observablesRangeObservable2 = _interopRequireDefault(_observablesRangeObservable);
var _observablesErrorObservable = __webpack_require__(23);
var _observablesErrorObservable2 = _interopRequireDefault(_observablesErrorObservable);
var _observablesTimerObservable = __webpack_require__(56);
var _observablesTimerObservable2 = _interopRequireDefault(_observablesTimerObservable);
var _operatorsZipStatic = __webpack_require__(57);
var _operatorsZipStatic2 = _interopRequireDefault(_operatorsZipStatic);
var _operatorsBuffer = __webpack_require__(59);
var _operatorsBuffer2 = _interopRequireDefault(_operatorsBuffer);
var _operatorsBufferCount = __webpack_require__(60);
var _operatorsBufferCount2 = _interopRequireDefault(_operatorsBufferCount);
var _operatorsBufferTime = __webpack_require__(61);
var _operatorsBufferTime2 = _interopRequireDefault(_operatorsBufferTime);
var _operatorsBufferToggle = __webpack_require__(62);
var _operatorsBufferToggle2 = _interopRequireDefault(_operatorsBufferToggle);
var _operatorsBufferWhen = __webpack_require__(63);
var _operatorsBufferWhen2 = _interopRequireDefault(_operatorsBufferWhen);
var _operatorsCatch = __webpack_require__(64);
var _operatorsCatch2 = _interopRequireDefault(_operatorsCatch);
var _operatorsCombineAll = __webpack_require__(65);
var _operatorsCombineAll2 = _interopRequireDefault(_operatorsCombineAll);
var _operatorsCombineLatest = __webpack_require__(66);
var _operatorsCombineLatest2 = _interopRequireDefault(_operatorsCombineLatest);
var _operatorsConcat = __webpack_require__(67);
var _operatorsConcat2 = _interopRequireDefault(_operatorsConcat);
var _operatorsConcatAll = __webpack_require__(68);
var _operatorsConcatAll2 = _interopRequireDefault(_operatorsConcatAll);
var _operatorsConcatMap = __webpack_require__(69);
var _operatorsConcatMap2 = _interopRequireDefault(_operatorsConcatMap);
var _operatorsConcatMapTo = __webpack_require__(71);
var _operatorsConcatMapTo2 = _interopRequireDefault(_operatorsConcatMapTo);
var _operatorsCount = __webpack_require__(73);
var _operatorsCount2 = _interopRequireDefault(_operatorsCount);
var _operatorsDematerialize = __webpack_require__(75);
var _operatorsDematerialize2 = _interopRequireDefault(_operatorsDematerialize);
var _operatorsDebounce = __webpack_require__(76);
var _operatorsDebounce2 = _interopRequireDefault(_operatorsDebounce);
var _operatorsDebounceTime = __webpack_require__(77);
var _operatorsDebounceTime2 = _interopRequireDefault(_operatorsDebounceTime);
var _operatorsDefaultIfEmpty = __webpack_require__(78);
var _operatorsDefaultIfEmpty2 = _interopRequireDefault(_operatorsDefaultIfEmpty);
var _operatorsDelay = __webpack_require__(79);
var _operatorsDelay2 = _interopRequireDefault(_operatorsDelay);
var _operatorsDistinctUntilChanged = __webpack_require__(81);
var _operatorsDistinctUntilChanged2 = _interopRequireDefault(_operatorsDistinctUntilChanged);
var _operatorsDo = __webpack_require__(82);
var _operatorsDo2 = _interopRequireDefault(_operatorsDo);
var _operatorsExpand = __webpack_require__(83);
var _operatorsExpand2 = _interopRequireDefault(_operatorsExpand);
var _operatorsFilter = __webpack_require__(85);
var _operatorsFilter2 = _interopRequireDefault(_operatorsFilter);
var _operatorsFinally = __webpack_require__(86);
var _operatorsFinally2 = _interopRequireDefault(_operatorsFinally);
var _operatorsFirst = __webpack_require__(87);
var _operatorsFirst2 = _interopRequireDefault(_operatorsFirst);
var _operatorsGroupBy = __webpack_require__(89);
var _operatorsIgnoreElements = __webpack_require__(95);
var _operatorsIgnoreElements2 = _interopRequireDefault(_operatorsIgnoreElements);
var _operatorsEvery = __webpack_require__(96);
var _operatorsEvery2 = _interopRequireDefault(_operatorsEvery);
var _operatorsLast = __webpack_require__(97);
var _operatorsLast2 = _interopRequireDefault(_operatorsLast);
var _operatorsMap = __webpack_require__(98);
var _operatorsMap2 = _interopRequireDefault(_operatorsMap);
var _operatorsMapTo = __webpack_require__(99);
var _operatorsMapTo2 = _interopRequireDefault(_operatorsMapTo);
var _operatorsMaterialize = __webpack_require__(100);
var _operatorsMaterialize2 = _interopRequireDefault(_operatorsMaterialize);
var _operatorsMerge = __webpack_require__(101);
var _operatorsMerge2 = _interopRequireDefault(_operatorsMerge);
var _operatorsMergeAll = __webpack_require__(102);
var _operatorsMergeAll2 = _interopRequireDefault(_operatorsMergeAll);
var _operatorsMergeMap = __webpack_require__(103);
var _operatorsMergeMap2 = _interopRequireDefault(_operatorsMergeMap);
var _operatorsMergeMapTo = __webpack_require__(104);
var _operatorsMergeMapTo2 = _interopRequireDefault(_operatorsMergeMapTo);
var _operatorsMulticast = __webpack_require__(105);
var _operatorsMulticast2 = _interopRequireDefault(_operatorsMulticast);
var _operatorsObserveOn = __webpack_require__(107);
var _operatorsObserveOn2 = _interopRequireDefault(_operatorsObserveOn);
var _operatorsPartition = __webpack_require__(108);
var _operatorsPartition2 = _interopRequireDefault(_operatorsPartition);
var _operatorsPublish = __webpack_require__(110);
var _operatorsPublish2 = _interopRequireDefault(_operatorsPublish);
var _operatorsPublishBehavior = __webpack_require__(111);
var _operatorsPublishBehavior2 = _interopRequireDefault(_operatorsPublishBehavior);
var _operatorsPublishReplay = __webpack_require__(113);
var _operatorsPublishReplay2 = _interopRequireDefault(_operatorsPublishReplay);
var _operatorsReduce = __webpack_require__(115);
var _operatorsReduce2 = _interopRequireDefault(_operatorsReduce);
var _operatorsRepeat = __webpack_require__(117);
var _operatorsRepeat2 = _interopRequireDefault(_operatorsRepeat);
var _operatorsRetry = __webpack_require__(118);
var _operatorsRetry2 = _interopRequireDefault(_operatorsRetry);
var _operatorsRetryWhen = __webpack_require__(119);
var _operatorsRetryWhen2 = _interopRequireDefault(_operatorsRetryWhen);
var _operatorsSample = __webpack_require__(120);
var _operatorsSample2 = _interopRequireDefault(_operatorsSample);
var _operatorsSampleTime = __webpack_require__(121);
var _operatorsSampleTime2 = _interopRequireDefault(_operatorsSampleTime);
var _operatorsScan = __webpack_require__(122);
var _operatorsScan2 = _interopRequireDefault(_operatorsScan);
var _operatorsShare = __webpack_require__(123);
var _operatorsShare2 = _interopRequireDefault(_operatorsShare);
var _operatorsShareBehavior = __webpack_require__(124);
var _operatorsShareBehavior2 = _interopRequireDefault(_operatorsShareBehavior);
var _operatorsShareReplay = __webpack_require__(125);
var _operatorsShareReplay2 = _interopRequireDefault(_operatorsShareReplay);
var _operatorsSingle = __webpack_require__(126);
var _operatorsSingle2 = _interopRequireDefault(_operatorsSingle);
var _operatorsSkip = __webpack_require__(127);
var _operatorsSkip2 = _interopRequireDefault(_operatorsSkip);
var _operatorsSkipUntil = __webpack_require__(128);
var _operatorsSkipUntil2 = _interopRequireDefault(_operatorsSkipUntil);
var _operatorsStartWith = __webpack_require__(129);
var _operatorsStartWith2 = _interopRequireDefault(_operatorsStartWith);
var _operatorsSubscribeOn = __webpack_require__(130);
var _operatorsSubscribeOn2 = _interopRequireDefault(_operatorsSubscribeOn);
var _operatorsSwitch = __webpack_require__(132);
var _operatorsSwitch2 = _interopRequireDefault(_operatorsSwitch);
var _operatorsSwitchMap = __webpack_require__(133);
var _operatorsSwitchMap2 = _interopRequireDefault(_operatorsSwitchMap);
var _operatorsSwitchMapTo = __webpack_require__(134);
var _operatorsSwitchMapTo2 = _interopRequireDefault(_operatorsSwitchMapTo);
var _operatorsTake = __webpack_require__(135);
var _operatorsTake2 = _interopRequireDefault(_operatorsTake);
var _operatorsTakeUntil = __webpack_require__(136);
var _operatorsTakeUntil2 = _interopRequireDefault(_operatorsTakeUntil);
var _operatorsThrottle = __webpack_require__(137);
var _operatorsThrottle2 = _interopRequireDefault(_operatorsThrottle);
var _operatorsTimeout = __webpack_require__(138);
var _operatorsTimeout2 = _interopRequireDefault(_operatorsTimeout);
var _operatorsTimeoutWith = __webpack_require__(139);
var _operatorsTimeoutWith2 = _interopRequireDefault(_operatorsTimeoutWith);
var _operatorsToArray = __webpack_require__(140);
var _operatorsToArray2 = _interopRequireDefault(_operatorsToArray);
var _operatorsToPromise = __webpack_require__(141);
var _operatorsToPromise2 = _interopRequireDefault(_operatorsToPromise);
var _operatorsWindow = __webpack_require__(142);
var _operatorsWindow2 = _interopRequireDefault(_operatorsWindow);
var _operatorsWindowCount = __webpack_require__(143);
var _operatorsWindowCount2 = _interopRequireDefault(_operatorsWindowCount);
var _operatorsWindowTime = __webpack_require__(144);
var _operatorsWindowTime2 = _interopRequireDefault(_operatorsWindowTime);
var _operatorsWindowToggle = __webpack_require__(145);
var _operatorsWindowToggle2 = _interopRequireDefault(_operatorsWindowToggle);
var _operatorsWindowWhen = __webpack_require__(146);
var _operatorsWindowWhen2 = _interopRequireDefault(_operatorsWindowWhen);
var _operatorsWithLatestFrom = __webpack_require__(147);
var _operatorsWithLatestFrom2 = _interopRequireDefault(_operatorsWithLatestFrom);
var _operatorsZip = __webpack_require__(148);
var _operatorsZip2 = _interopRequireDefault(_operatorsZip);
var _operatorsZipAll = __webpack_require__(149);
var _operatorsZipAll2 = _interopRequireDefault(_operatorsZipAll);
var _Subject = __webpack_require__(90);
var _Subject2 = _interopRequireDefault(_Subject);
var _Subscription = __webpack_require__(14);
var _Subscription2 = _interopRequireDefault(_Subscription);
var _Subscriber = __webpack_require__(10);
var _Subscriber2 = _interopRequireDefault(_Subscriber);
var _subjectsReplaySubject = __webpack_require__(114);
var _subjectsReplaySubject2 = _interopRequireDefault(_subjectsReplaySubject);
var _subjectsBehaviorSubject = __webpack_require__(112);
var _subjectsBehaviorSubject2 = _interopRequireDefault(_subjectsBehaviorSubject);
var _observablesConnectableObservable = __webpack_require__(106);
var _observablesConnectableObservable2 = _interopRequireDefault(_observablesConnectableObservable);
var _Notification = __webpack_require__(41);
var _Notification2 = _interopRequireDefault(_Notification);
var _utilEmptyError = __webpack_require__(88);
var _utilEmptyError2 = _interopRequireDefault(_utilEmptyError);
var _utilArgumentOutOfRangeError = __webpack_require__(150);
var _utilArgumentOutOfRangeError2 = _interopRequireDefault(_utilArgumentOutOfRangeError);
var _schedulersNextTick = __webpack_require__(46);
var _schedulersNextTick2 = _interopRequireDefault(_schedulersNextTick);
var _schedulersImmediate = __webpack_require__(31);
var _schedulersImmediate2 = _interopRequireDefault(_schedulersImmediate);
_Observable2['default'].combineLatest = _operatorsCombineLatestStatic2['default'];
_Observable2['default'].concat = _operatorsConcatStatic2['default'];
_Observable2['default'].defer = _observablesDeferObservable2['default'].create;
_Observable2['default'].empty = _observablesEmptyObservable2['default'].create;
_Observable2['default'].forkJoin = _observablesForkJoinObservable2['default'].create;
_Observable2['default'].from = _observablesFromObservable2['default'].create;
_Observable2['default'].fromArray = _observablesArrayObservable2['default'].create;
_Observable2['default'].fromEvent = _observablesFromEventObservable2['default'].create;
_Observable2['default'].fromEventPattern = _observablesFromEventPatternObservable2['default'].create;
_Observable2['default'].fromPromise = _observablesPromiseObservable2['default'].create;
_Observable2['default'].interval = _observablesIntervalObservable2['default'].create;
_Observable2['default'].merge = _operatorsMergeStatic2['default'];
_Observable2['default'].never = _observablesInfiniteObservable2['default'].create;
_Observable2['default'].of = _observablesArrayObservable2['default'].of;
_Observable2['default'].range = _observablesRangeObservable2['default'].create;
_Observable2['default']['throw'] = _observablesErrorObservable2['default'].create;
_Observable2['default'].timer = _observablesTimerObservable2['default'].create;
_Observable2['default'].zip = _operatorsZipStatic2['default'];
var observableProto = _Observable2['default'].prototype;
observableProto.buffer = _operatorsBuffer2['default'];
observableProto.bufferCount = _operatorsBufferCount2['default'];
observableProto.bufferTime = _operatorsBufferTime2['default'];
observableProto.bufferToggle = _operatorsBufferToggle2['default'];
observableProto.bufferWhen = _operatorsBufferWhen2['default'];
observableProto['catch'] = _operatorsCatch2['default'];
observableProto.combineAll = _operatorsCombineAll2['default'];
observableProto.combineLatest = _operatorsCombineLatest2['default'];
observableProto.concat = _operatorsConcat2['default'];
observableProto.concatAll = _operatorsConcatAll2['default'];
observableProto.concatMap = _operatorsConcatMap2['default'];
observableProto.concatMapTo = _operatorsConcatMapTo2['default'];
observableProto.count = _operatorsCount2['default'];
observableProto.dematerialize = _operatorsDematerialize2['default'];
observableProto.debounce = _operatorsDebounce2['default'];
observableProto.debounceTime = _operatorsDebounceTime2['default'];
observableProto.defaultIfEmpty = _operatorsDefaultIfEmpty2['default'];
observableProto.delay = _operatorsDelay2['default'];
observableProto.distinctUntilChanged = _operatorsDistinctUntilChanged2['default'];
observableProto['do'] = _operatorsDo2['default'];
observableProto.expand = _operatorsExpand2['default'];
observableProto.filter = _operatorsFilter2['default'];
observableProto['finally'] = _operatorsFinally2['default'];
observableProto.first = _operatorsFirst2['default'];
observableProto.groupBy = _operatorsGroupBy.groupBy;
observableProto.ignoreElements = _operatorsIgnoreElements2['default'];
observableProto.every = _operatorsEvery2['default'];
observableProto.last = _operatorsLast2['default'];
observableProto.map = _operatorsMap2['de