mirror of
https://github.com/wahyd4/cdnjs.git
synced 2026-08-15 07:46:06 +10:00
Merge pull request #1843 from Reactive-Extensions/rxjs
Updating RxJS to v2.1.15
This commit is contained in:
Thomas Davis
@@ -0,0 +1,716 @@
|
||||
// Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information.
|
||||
|
||||
(function (root, factory) {
|
||||
var freeExports = typeof exports == 'object' && exports,
|
||||
freeModule = typeof module == 'object' && module && module.exports == freeExports && module,
|
||||
freeGlobal = typeof global == 'object' && global;
|
||||
if (freeGlobal.global === freeGlobal) {
|
||||
window = freeGlobal;
|
||||
}
|
||||
|
||||
// Because of build optimizers
|
||||
if (typeof define === 'function' && define.amd) {
|
||||
define(['rx', 'exports'], function (Rx, exports) {
|
||||
root.Rx = factory(root, exports, Rx);
|
||||
return root.Rx;
|
||||
});
|
||||
} else if (typeof module === 'object' && module && module.exports === freeExports) {
|
||||
module.exports = factory(root, module.exports, require('./rx'));
|
||||
} else {
|
||||
root.Rx = factory(root, {}, root.Rx);
|
||||
}
|
||||
}(this, function (global, exp, Rx, undefined) {
|
||||
|
||||
// References
|
||||
var Observable = Rx.Observable,
|
||||
observableProto = Observable.prototype,
|
||||
CompositeDisposable = Rx.CompositeDisposable,
|
||||
AnonymousObservable = Rx.Internals.AnonymousObservable,
|
||||
isEqual = Rx.Internals.isEqual;
|
||||
|
||||
// Defaults
|
||||
var argumentOutOfRange = 'Argument out of range';
|
||||
var sequenceContainsNoElements = "Sequence contains no elements.";
|
||||
function defaultComparer(x, y) { return isEqual(x, y); }
|
||||
function identity(x) { return x; }
|
||||
function subComparer(x, y) {
|
||||
if (x > y) {
|
||||
return 1;
|
||||
}
|
||||
if (x < y) {
|
||||
return -1
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
function extremaBy(source, keySelector, comparer) {
|
||||
return new AnonymousObservable(function (observer) {
|
||||
var hasValue = false, lastKey = null, list = [];
|
||||
return source.subscribe(function (x) {
|
||||
var comparison, key;
|
||||
try {
|
||||
key = keySelector(x);
|
||||
} catch (ex) {
|
||||
observer.onError(ex);
|
||||
return;
|
||||
}
|
||||
comparison = 0;
|
||||
if (!hasValue) {
|
||||
hasValue = true;
|
||||
lastKey = key;
|
||||
} else {
|
||||
try {
|
||||
comparison = comparer(key, lastKey);
|
||||
} catch (ex1) {
|
||||
observer.onError(ex1);
|
||||
return;
|
||||
}
|
||||
}
|
||||
if (comparison > 0) {
|
||||
lastKey = key;
|
||||
list = [];
|
||||
}
|
||||
if (comparison >= 0) {
|
||||
list.push(x);
|
||||
}
|
||||
}, observer.onError.bind(observer), function () {
|
||||
observer.onNext(list);
|
||||
observer.onCompleted();
|
||||
});
|
||||
});
|
||||
}
|
||||
|
||||
function firstOnly(x) {
|
||||
if (x.length === 0) {
|
||||
throw new Error(sequenceContainsNoElements);
|
||||
}
|
||||
return x[0];
|
||||
}
|
||||
|
||||
/**
|
||||
* Applies an accumulator function over an observable sequence, returning the result of the aggregation as a single element in the result sequence. The specified seed value is used as the initial accumulator value.
|
||||
* For aggregation behavior with incremental intermediate results, see Observable.scan.
|
||||
*
|
||||
* @example
|
||||
* 1 - res = source.aggregate(function (acc, x) { return acc + x; });
|
||||
* 2 - res = source.aggregate(0, function (acc, x) { return acc + x; });
|
||||
* @memberOf Observable#
|
||||
* @param {Mixed} [seed] The initial accumulator value.
|
||||
* @param {Function} accumulator An accumulator function to be invoked on each element.
|
||||
* @returns {Observable} An observable sequence containing a single element with the final accumulator value.
|
||||
*/
|
||||
observableProto.aggregate = function () {
|
||||
var seed, hasSeed, accumulator;
|
||||
if (arguments.length === 2) {
|
||||
seed = arguments[0];
|
||||
hasSeed = true;
|
||||
accumulator = arguments[1];
|
||||
} else {
|
||||
accumulator = arguments[0];
|
||||
}
|
||||
return hasSeed ? this.scan(seed, accumulator).startWith(seed).finalValue() : this.scan(accumulator).finalValue();
|
||||
};
|
||||
|
||||
/**
|
||||
* Applies an accumulator function over an observable sequence, returning the result of the aggregation as a single element in the result sequence. The specified seed value is used as the initial accumulator value.
|
||||
* For aggregation behavior with incremental intermediate results, see Observable.scan.
|
||||
*
|
||||
* @example
|
||||
* 1 - res = source.reduce(function (acc, x) { return acc + x; });
|
||||
* 2 - res = source.reduce(function (acc, x) { return acc + x; }, 0);
|
||||
* @memberOf Observable#
|
||||
* @param {Mixed} [seed] The initial accumulator value.
|
||||
* @param {Function} accumulator An accumulator function to be invoked on each element.
|
||||
* @returns {Observable} An observable sequence containing a single element with the final accumulator value.
|
||||
*/
|
||||
observableProto.reduce = function () {
|
||||
var seed, hasSeed, accumulator = arguments[0];
|
||||
if (arguments.length === 2) {
|
||||
hasSeed = true;
|
||||
seed = arguments[1];
|
||||
}
|
||||
return hasSeed ? this.scan(seed, accumulator).startWith(seed).finalValue() : this.scan(accumulator).finalValue();
|
||||
};
|
||||
|
||||
/**
|
||||
* Determines whether any element of an observable sequence satisfies a condition if present, else if any items are in the sequence.
|
||||
*
|
||||
* 1 - source.any();
|
||||
* 2 - source.any(function (x) { return x > 3; });
|
||||
* @memberOf Observable#
|
||||
* @param {Function} [predicate] A function to test each element for a condition.
|
||||
* @returns {Observable} An observable sequence containing a single element determining whether any elements in the source sequence pass the test in the specified predicate if given, else if any items are in the sequence.
|
||||
*/
|
||||
observableProto.any = function (predicate, thisArg) {
|
||||
var source = this;
|
||||
return predicate ?
|
||||
source.where(predicate, thisArg).any() :
|
||||
new AnonymousObservable(function (observer) {
|
||||
return source.subscribe(function () {
|
||||
observer.onNext(true);
|
||||
observer.onCompleted();
|
||||
}, observer.onError.bind(observer), function () {
|
||||
observer.onNext(false);
|
||||
observer.onCompleted();
|
||||
});
|
||||
});
|
||||
};
|
||||
observableProto.some = observableProto.any;
|
||||
|
||||
/**
|
||||
* Determines whether an observable sequence is empty.
|
||||
*
|
||||
* @memberOf Observable#
|
||||
* @returns {Observable} An observable sequence containing a single element determining whether the source sequence is empty.
|
||||
*/
|
||||
observableProto.isEmpty = function () {
|
||||
return this.any().select(function (b) { return !b; });
|
||||
};
|
||||
|
||||
/**
|
||||
* Determines whether all elements of an observable sequence satisfy a condition.
|
||||
*
|
||||
* 1 - res = source.all(function (value) { return value.length > 3; });
|
||||
* @memberOf Observable#
|
||||
* @param {Function} [predicate] A function to test each element for a condition.
|
||||
* @param {Any} [thisArg] Object to use as this when executing callback.
|
||||
* @returns {Observable} An observable sequence containing a single element determining whether all elements in the source sequence pass the test in the specified predicate.
|
||||
*/
|
||||
observableProto.all = function (predicate, thisArg) {
|
||||
return this.where(function (v) {
|
||||
return !predicate(v);
|
||||
}, thisArg).any().select(function (b) {
|
||||
return !b;
|
||||
});
|
||||
};
|
||||
observableProto.every = observableProto.all;
|
||||
|
||||
/**
|
||||
* Determines whether an observable sequence contains a specified element with an optional equality comparer.
|
||||
*
|
||||
* 1 - res = source.contains(42);
|
||||
* 2 - res = source.contains({ value: 42 }, function (x, y) { return x.value === y.value; });
|
||||
* @memberOf Observable#
|
||||
* @param value The value to locate in the source sequence.</param>
|
||||
* @param {Function} [comparer] An equality comparer to compare elements.
|
||||
* @returns {Observable} An observable sequence containing a single element determining whether the source sequence contains an element that has the specified value.
|
||||
*/
|
||||
observableProto.contains = function (value, comparer) {
|
||||
comparer || (comparer = defaultComparer);
|
||||
return this.where(function (v) {
|
||||
return comparer(v, value);
|
||||
}).any();
|
||||
};
|
||||
|
||||
/**
|
||||
* Returns an observable sequence containing a value that represents how many elements in the specified observable sequence satisfy a condition if provided, else the count of items.
|
||||
*
|
||||
* 1 - res = source.count();
|
||||
* 2 - res = source.count(function (x) { return x > 3; });
|
||||
* @memberOf Observable#
|
||||
* @param {Function} [predicate]A function to test each element for a condition.
|
||||
* @param {Any} [thisArg] Object to use as this when executing callback.
|
||||
* @returns {Observable} An observable sequence containing a single element with a number that represents how many elements in the input sequence satisfy the condition in the predicate function if provided, else the count of items in the sequence.
|
||||
*/
|
||||
observableProto.count = function (predicate, thisArg) {
|
||||
return predicate ?
|
||||
this.where(predicate, thisArg).count() :
|
||||
this.aggregate(0, function (count) {
|
||||
return count + 1;
|
||||
});
|
||||
};
|
||||
|
||||
/**
|
||||
* Computes the sum of a sequence of values that are obtained by invoking an optional transform function on each element of the input sequence, else if not specified computes the sum on each item in the sequence.
|
||||
*
|
||||
* 1 - res = source.sum();
|
||||
* 2 - res = source.sum(function (x) { return x.value; });
|
||||
* @memberOf Observable#
|
||||
* @param {Function} [selector] A transform function to apply to each element.\
|
||||
* @param {Any} [thisArg] Object to use as this when executing callback.
|
||||
* @returns {Observable} An observable sequence containing a single element with the sum of the values in the source sequence.
|
||||
*/
|
||||
observableProto.sum = function (keySelector, thisArg) {
|
||||
return keySelector ?
|
||||
this.select(keySelector, thisArg).sum() :
|
||||
this.aggregate(0, function (prev, curr) {
|
||||
return prev + curr;
|
||||
});
|
||||
};
|
||||
|
||||
/**
|
||||
* Returns the elements in an observable sequence with the minimum key value according to the specified comparer.
|
||||
*
|
||||
* 1 - source.minBy(function (x) { return x.value; });
|
||||
* 2 - source.minBy(function (x) { return x.value; }, function (x, y) { return x - y; });
|
||||
* @memberOf Observable#
|
||||
* @param {Function} keySelector Key selector function.</param>
|
||||
* @param {Function} [comparer] Comparer used to compare key values.</param>
|
||||
* @returns {Observable} An observable sequence containing a list of zero or more elements that have a minimum key value.
|
||||
*/
|
||||
observableProto.minBy = function (keySelector, comparer) {
|
||||
comparer || (comparer = subComparer);
|
||||
return extremaBy(this, keySelector, function (x, y) {
|
||||
return comparer(x, y) * -1;
|
||||
});
|
||||
};
|
||||
|
||||
/**
|
||||
* Returns the minimum element in an observable sequence according to the optional comparer else a default greater than less than check.
|
||||
*
|
||||
* 1 - source.min();
|
||||
* 2 - source.min(function (x, y) { return x.value - y.value; });
|
||||
* @memberOf Observable#
|
||||
* @param {Function} [comparer] Comparer used to compare elements.
|
||||
* @returns {Observable} An observable sequence containing a single element with the minimum element in the source sequence.
|
||||
*/
|
||||
observableProto.min = function (comparer) {
|
||||
return this.minBy(identity, comparer).select(function (x) {
|
||||
return firstOnly(x);
|
||||
});
|
||||
};
|
||||
|
||||
/**
|
||||
* Returns the elements in an observable sequence with the maximum key value according to the specified comparer.
|
||||
*
|
||||
* @example
|
||||
* 1 - source.maxBy(function (x) { return x.value; });
|
||||
* 2 - source.maxBy(function (x) { return x.value; }, function (x, y) { return x - y;; });
|
||||
* @memberOf Observable#
|
||||
* @param {Function} keySelector Key selector function.
|
||||
* @param {Function} [comparer] Comparer used to compare key values.
|
||||
* @returns {Observable} An observable sequence containing a list of zero or more elements that have a maximum key value.
|
||||
*/
|
||||
observableProto.maxBy = function (keySelector, comparer) {
|
||||
comparer || (comparer = subComparer);
|
||||
return extremaBy(this, keySelector, comparer);
|
||||
};
|
||||
|
||||
/**
|
||||
* Returns the maximum value in an observable sequence according to the specified comparer.
|
||||
*
|
||||
* @example
|
||||
* 1 - source.max();
|
||||
* 2 - source.max(function (x, y) { return x.value - y.value; });
|
||||
* @memberOf Observable#
|
||||
* @param {Function} [comparer] Comparer used to compare elements.
|
||||
* @returns {Observable} An observable sequence containing a single element with the maximum element in the source sequence.
|
||||
*/
|
||||
observableProto.max = function (comparer) {
|
||||
return this.maxBy(identity, comparer).select(function (x) {
|
||||
return firstOnly(x);
|
||||
});
|
||||
};
|
||||
|
||||
/**
|
||||
* Computes the average of an observable sequence of values that are in the sequence or obtained by invoking a transform function on each element of the input sequence if present.
|
||||
*
|
||||
* @example
|
||||
* 1 - res = source.average();
|
||||
* 2 - res = source.average(function (x) { return x.value; });
|
||||
* @memberOf Observable#
|
||||
* @param {Function} [selector] A transform function to apply to each element.
|
||||
* @param {Any} [thisArg] Object to use as this when executing callback.
|
||||
* @returns {Observable} An observable sequence containing a single element with the average of the sequence of values.
|
||||
*/
|
||||
observableProto.average = function (keySelector, thisArg) {
|
||||
return keySelector ?
|
||||
this.select(keySelector, thisArg).average() :
|
||||
this.scan({
|
||||
sum: 0,
|
||||
count: 0
|
||||
}, function (prev, cur) {
|
||||
return {
|
||||
sum: prev.sum + cur,
|
||||
count: prev.count + 1
|
||||
};
|
||||
}).finalValue().select(function (s) {
|
||||
return s.sum / s.count;
|
||||
});
|
||||
};
|
||||
|
||||
function sequenceEqualArray(first, second, comparer) {
|
||||
return new AnonymousObservable(function (observer) {
|
||||
var count = 0, len = second.length;
|
||||
return first.subscribe(function (value) {
|
||||
var equal = false;
|
||||
try {
|
||||
if (count < len) {
|
||||
equal = comparer(value, second[count++]);
|
||||
}
|
||||
} catch (e) {
|
||||
observer.onError(e);
|
||||
return;
|
||||
}
|
||||
if (!equal) {
|
||||
observer.onNext(false);
|
||||
observer.onCompleted();
|
||||
}
|
||||
}, observer.onError.bind(observer), function () {
|
||||
observer.onNext(count === len);
|
||||
observer.onCompleted();
|
||||
});
|
||||
});
|
||||
}
|
||||
|
||||
/**
|
||||
* Determines whether two sequences are equal by comparing the elements pairwise using a specified equality comparer.
|
||||
*
|
||||
* @example
|
||||
* 1 - res = source.sequenceEqual([1,2,3]);
|
||||
* 2 - res = source.sequenceEqual([{ value: 42 }], function (x, y) { return x.value === y.value; });
|
||||
* 3 - res = source.sequenceEqual(Rx.Observable.returnValue(42));
|
||||
* 4 - res = source.sequenceEqual(Rx.Observable.returnValue({ value: 42 }), function (x, y) { return x.value === y.value; });
|
||||
* @memberOf Observable#
|
||||
* @param {Observable} second Second observable sequence or array to compare.
|
||||
* @param {Function} [comparer] Comparer used to compare elements of both sequences.
|
||||
* @returns {Observable} An observable sequence that contains a single element which indicates whether both sequences are of equal length and their corresponding elements are equal according to the specified equality comparer.
|
||||
*/
|
||||
observableProto.sequenceEqual = function (second, comparer) {
|
||||
var first = this;
|
||||
comparer || (comparer = defaultComparer);
|
||||
if (Array.isArray(second)) {
|
||||
return sequenceEqualArray(first, second, comparer);
|
||||
}
|
||||
return new AnonymousObservable(function (observer) {
|
||||
var donel = false, doner = false, ql = [], qr = [];
|
||||
var subscription1 = first.subscribe(function (x) {
|
||||
var equal, v;
|
||||
if (qr.length > 0) {
|
||||
v = qr.shift();
|
||||
try {
|
||||
equal = comparer(v, x);
|
||||
} catch (e) {
|
||||
observer.onError(e);
|
||||
return;
|
||||
}
|
||||
if (!equal) {
|
||||
observer.onNext(false);
|
||||
observer.onCompleted();
|
||||
}
|
||||
} else if (doner) {
|
||||
observer.onNext(false);
|
||||
observer.onCompleted();
|
||||
} else {
|
||||
ql.push(x);
|
||||
}
|
||||
}, observer.onError.bind(observer), function () {
|
||||
donel = true;
|
||||
if (ql.length === 0) {
|
||||
if (qr.length > 0) {
|
||||
observer.onNext(false);
|
||||
observer.onCompleted();
|
||||
} else if (doner) {
|
||||
observer.onNext(true);
|
||||
observer.onCompleted();
|
||||
}
|
||||
}
|
||||
});
|
||||
var subscription2 = second.subscribe(function (x) {
|
||||
var equal, v;
|
||||
if (ql.length > 0) {
|
||||
v = ql.shift();
|
||||
try {
|
||||
equal = comparer(v, x);
|
||||
} catch (exception) {
|
||||
observer.onError(exception);
|
||||
return;
|
||||
}
|
||||
if (!equal) {
|
||||
observer.onNext(false);
|
||||
observer.onCompleted();
|
||||
}
|
||||
} else if (donel) {
|
||||
observer.onNext(false);
|
||||
observer.onCompleted();
|
||||
} else {
|
||||
qr.push(x);
|
||||
}
|
||||
}, observer.onError.bind(observer), function () {
|
||||
doner = true;
|
||||
if (qr.length === 0) {
|
||||
if (ql.length > 0) {
|
||||
observer.onNext(false);
|
||||
observer.onCompleted();
|
||||
} else if (donel) {
|
||||
observer.onNext(true);
|
||||
observer.onCompleted();
|
||||
}
|
||||
}
|
||||
});
|
||||
return new CompositeDisposable(subscription1, subscription2);
|
||||
});
|
||||
};
|
||||
|
||||
function elementAtOrDefault(source, index, hasDefault, defaultValue) {
|
||||
if (index < 0) {
|
||||
throw new Error(argumentOutOfRange);
|
||||
}
|
||||
return new AnonymousObservable(function (observer) {
|
||||
var i = index;
|
||||
return source.subscribe(function (x) {
|
||||
if (i === 0) {
|
||||
observer.onNext(x);
|
||||
observer.onCompleted();
|
||||
}
|
||||
i--;
|
||||
}, observer.onError.bind(observer), function () {
|
||||
if (!hasDefault) {
|
||||
observer.onError(new Error(argumentOutOfRange));
|
||||
} else {
|
||||
observer.onNext(defaultValue);
|
||||
observer.onCompleted();
|
||||
}
|
||||
});
|
||||
});
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns the element at a specified index in a sequence.
|
||||
*
|
||||
* @example
|
||||
* source.elementAt(5);
|
||||
* @memberOf Observable#
|
||||
* @param {Number} index The zero-based index of the element to retrieve.
|
||||
* @returns {Observable} An observable sequence that produces the element at the specified position in the source sequence.
|
||||
*/
|
||||
observableProto.elementAt = function (index) {
|
||||
return elementAtOrDefault(this, index, false);
|
||||
};
|
||||
|
||||
/**
|
||||
* Returns the element at a specified index in a sequence or a default value if the index is out of range.
|
||||
*
|
||||
* @example
|
||||
* source.elementAtOrDefault(5);
|
||||
* source.elementAtOrDefault(5, 0);
|
||||
* @memberOf Observable#
|
||||
* @param {Number} index The zero-based index of the element to retrieve.
|
||||
* @param [defaultValue] The default value if the index is outside the bounds of the source sequence.
|
||||
* @returns {Observable} An observable sequence that produces the element at the specified position in the source sequence, or a default value if the index is outside the bounds of the source sequence.
|
||||
*/
|
||||
observableProto.elementAtOrDefault = function (index, defaultValue) {
|
||||
return elementAtOrDefault(this, index, true, defaultValue);
|
||||
};
|
||||
|
||||
function singleOrDefaultAsync(source, hasDefault, defaultValue) {
|
||||
return new AnonymousObservable(function (observer) {
|
||||
var value = defaultValue, seenValue = false;
|
||||
return source.subscribe(function (x) {
|
||||
if (seenValue) {
|
||||
observer.onError(new Error('Sequence contains more than one element'));
|
||||
} else {
|
||||
value = x;
|
||||
seenValue = true;
|
||||
}
|
||||
}, observer.onError.bind(observer), function () {
|
||||
if (!seenValue && !hasDefault) {
|
||||
observer.onError(new Error(sequenceContainsNoElements));
|
||||
} else {
|
||||
observer.onNext(value);
|
||||
observer.onCompleted();
|
||||
}
|
||||
});
|
||||
});
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns the only element of an observable sequence that satisfies the condition in the optional predicate, and reports an exception if there is not exactly one element in the observable sequence.
|
||||
*
|
||||
* @example
|
||||
* 1 - res = source.single();
|
||||
* 2 - res = source.single(function (x) { return x === 42; });
|
||||
* @memberOf Observable#
|
||||
* @param {Function} [predicate] A predicate function to evaluate for elements in the source sequence.
|
||||
* @param {Any} [thisArg] Object to use as `this` when executing the predicate.
|
||||
* @returns {Observable} Sequence containing the single element in the observable sequence that satisfies the condition in the predicate.
|
||||
*/
|
||||
observableProto.single = function (predicate, thisArg) {
|
||||
if (predicate) {
|
||||
return this.where(predicate, thisArg).single();
|
||||
}
|
||||
return singleOrDefaultAsync(this, false);
|
||||
};
|
||||
|
||||
/**
|
||||
* Returns the only element of an observable sequence that matches the predicate, or a default value if no such element exists; this method reports an exception if there is more than one element in the observable sequence.
|
||||
*
|
||||
* @example
|
||||
* 1 - res = source.singleOrDefault();
|
||||
* 2 - res = source.singleOrDefault(function (x) { return x === 42; });
|
||||
* 3 - res = source.singleOrDefault(function (x) { return x === 42; }, 0);
|
||||
* 4 - res = source.singleOrDefault(null, 0);
|
||||
* @memberOf Observable#
|
||||
* @param {Function} predicate A predicate function to evaluate for elements in the source sequence.
|
||||
* @param [defaultValue] The default value if the index is outside the bounds of the source sequence.
|
||||
* @param {Any} [thisArg] Object to use as `this` when executing the predicate.
|
||||
* @returns {Observable} Sequence containing the single element in the observable sequence that satisfies the condition in the predicate, or a default value if no such element exists.
|
||||
*/
|
||||
observableProto.singleOrDefault = function (predicate, defaultValue, thisArg) {
|
||||
if (predicate) {
|
||||
return this.where(predicate, thisArg).singleOrDefault(null, defaultValue);
|
||||
}
|
||||
return singleOrDefaultAsync(this, true, defaultValue);
|
||||
};
|
||||
|
||||
function firstOrDefaultAsync(source, hasDefault, defaultValue) {
|
||||
return new AnonymousObservable(function (observer) {
|
||||
return source.subscribe(function (x) {
|
||||
observer.onNext(x);
|
||||
observer.onCompleted();
|
||||
}, observer.onError.bind(observer), function () {
|
||||
if (!hasDefault) {
|
||||
observer.onError(new Error(sequenceContainsNoElements));
|
||||
} else {
|
||||
observer.onNext(defaultValue);
|
||||
observer.onCompleted();
|
||||
}
|
||||
});
|
||||
});
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns the first element of an observable sequence that satisfies the condition in the predicate if present else the first item in the sequence.
|
||||
*
|
||||
* @example
|
||||
* 1 - res = source.first();
|
||||
* 2 - res = source.first(function (x) { return x > 3; });
|
||||
* @memberOf Observable#
|
||||
* @param {Function} [predicate] A predicate function to evaluate for elements in the source sequence.
|
||||
* @param {Any} [thisArg] Object to use as `this` when executing the predicate.
|
||||
* @returns {Observable} Sequence containing the first element in the observable sequence that satisfies the condition in the predicate if provided, else the first item in the sequence.
|
||||
*/
|
||||
observableProto.first = function (predicate, thisArg) {
|
||||
if (predicate) {
|
||||
return this.where(predicate, thisArg).first();
|
||||
}
|
||||
return firstOrDefaultAsync(this, false);
|
||||
};
|
||||
|
||||
/**
|
||||
* Returns the first element of an observable sequence that satisfies the condition in the predicate, or a default value if no such element exists.
|
||||
*
|
||||
* @example
|
||||
* 1 - res = source.firstOrDefault();
|
||||
* 2 - res = source.firstOrDefault(function (x) { return x > 3; });
|
||||
* 3 - res = source.firstOrDefault(function (x) { return x > 3; }, 0);
|
||||
* 4 - res = source.firstOrDefault(null, 0);
|
||||
* @memberOf Observable#
|
||||
* @param {Function} [predicate] A predicate function to evaluate for elements in the source sequence.
|
||||
* @param {Any} [defaultValue] The default value if no such element exists. If not specified, defaults to null.
|
||||
* @param {Any} [thisArg] Object to use as `this` when executing the predicate.
|
||||
* @returns {Observable} Sequence containing the first element in the observable sequence that satisfies the condition in the predicate, or a default value if no such element exists.
|
||||
*/
|
||||
observableProto.firstOrDefault = function (predicate, defaultValue, thisArg) {
|
||||
if (predicate) {
|
||||
return this.where(predicate).firstOrDefault(null, defaultValue);
|
||||
}
|
||||
return firstOrDefaultAsync(this, true, defaultValue);
|
||||
};
|
||||
|
||||
function lastOrDefaultAsync(source, hasDefault, defaultValue) {
|
||||
return new AnonymousObservable(function (observer) {
|
||||
var value = defaultValue, seenValue = false;
|
||||
return source.subscribe(function (x) {
|
||||
value = x;
|
||||
seenValue = true;
|
||||
}, observer.onError.bind(observer), function () {
|
||||
if (!seenValue && !hasDefault) {
|
||||
observer.onError(new Error(sequenceContainsNoElements));
|
||||
} else {
|
||||
observer.onNext(value);
|
||||
observer.onCompleted();
|
||||
}
|
||||
});
|
||||
});
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns the last element of an observable sequence that satisfies the condition in the predicate if specified, else the last element.
|
||||
*
|
||||
* @example
|
||||
* 1 - res = source.last();
|
||||
* 2 - res = source.last(function (x) { return x > 3; });
|
||||
* @memberOf Observable#
|
||||
* @param {Function} [predicate] A predicate function to evaluate for elements in the source sequence.
|
||||
* @param {Any} [thisArg] Object to use as `this` when executing the predicate.
|
||||
* @returns {Observable} Sequence containing the last element in the observable sequence that satisfies the condition in the predicate.
|
||||
*/
|
||||
observableProto.last = function (predicate, thisArg) {
|
||||
if (predicate) {
|
||||
return this.where(predicate, thisArg).last();
|
||||
}
|
||||
return lastOrDefaultAsync(this, false);
|
||||
};
|
||||
|
||||
/**
|
||||
* Returns the last element of an observable sequence that satisfies the condition in the predicate, or a default value if no such element exists.
|
||||
*
|
||||
* @example
|
||||
* 1 - res = source.lastOrDefault();
|
||||
* 2 - res = source.lastOrDefault(function (x) { return x > 3; });
|
||||
* 3 - res = source.lastOrDefault(function (x) { return x > 3; }, 0);
|
||||
* 4 - res = source.lastOrDefault(null, 0);
|
||||
* @memberOf Observable#
|
||||
* @param {Function} [predicate] A predicate function to evaluate for elements in the source sequence.
|
||||
* @param [defaultValue] The default value if no such element exists. If not specified, defaults to null.
|
||||
* @param {Any} [thisArg] Object to use as `this` when executing the predicate.
|
||||
* @returns {Observable} Sequence containing the last element in the observable sequence that satisfies the condition in the predicate, or a default value if no such element exists.
|
||||
*/
|
||||
observableProto.lastOrDefault = function (predicate, defaultValue, thisArg) {
|
||||
if (predicate) {
|
||||
return this.where(predicate, thisArg).lastOrDefault(null, defaultValue);
|
||||
}
|
||||
return lastOrDefaultAsync(this, true, defaultValue);
|
||||
};
|
||||
|
||||
function findValue (source, predicate, thisArg, yieldIndex) {
|
||||
return new AnonymousObservable(function (observer) {
|
||||
var i = 0;
|
||||
return source.subscribe(function (x) {
|
||||
var shouldRun;
|
||||
try {
|
||||
shouldRun = predicate.call(thisArg, x, i, source);
|
||||
} catch(e) {
|
||||
observer.onError(e);
|
||||
return;
|
||||
}
|
||||
if (shouldRun) {
|
||||
observer.onNext(yieldIndex ? i : x);
|
||||
observer.onCompleted();
|
||||
} else {
|
||||
i++;
|
||||
}
|
||||
}, observer.onError.bind(observer), function () {
|
||||
observer.onNext(yieldIndex ? -1 : undefined);
|
||||
observer.onCompleted();
|
||||
});
|
||||
});
|
||||
}
|
||||
|
||||
/**
|
||||
* Searches for an element that matches the conditions defined by the specified predicate, and returns the first occurrence within the entire Observable sequence.
|
||||
*
|
||||
* @memberOf Observable#
|
||||
* @param {Function} predicate The predicate that defines the conditions of the element to search for.
|
||||
* @param {Any} [thisArg] Object to use as `this` when executing the predicate.
|
||||
* @returns {Observable} An Observable sequence with the first element that matches the conditions defined by the specified predicate, if found; otherwise, undefined.
|
||||
*/
|
||||
observableProto.find = function (predicate, thisArg) {
|
||||
return findValue(this, predicate, thisArg, false);
|
||||
};
|
||||
|
||||
/**
|
||||
* Searches for an element that matches the conditions defined by the specified predicate, and returns
|
||||
* an Observable sequence with the zero-based index of the first occurrence within the entire Observable sequence.
|
||||
*
|
||||
* @memberOf Observable#
|
||||
* @param {Function} predicate The predicate that defines the conditions of the element to search for.
|
||||
* @param {Any} [thisArg] Object to use as `this` when executing the predicate.
|
||||
* @returns {Observable} An Observable sequence with the zero-based index of the first occurrence of an element that matches the conditions defined by match, if found; otherwise, –1.
|
||||
*/
|
||||
observableProto.findIndex = function (predicate, thisArg) {
|
||||
return findValue(this, predicate, thisArg, true);
|
||||
};
|
||||
return Rx;
|
||||
}));
|
||||
+1
File diff suppressed because one or more lines are too long
@@ -0,0 +1,534 @@
|
||||
// Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information.
|
||||
|
||||
(function (root, factory) {
|
||||
var freeExports = typeof exports == 'object' && exports,
|
||||
freeModule = typeof module == 'object' && module && module.exports == freeExports && module,
|
||||
freeGlobal = typeof global == 'object' && global;
|
||||
if (freeGlobal.global === freeGlobal) {
|
||||
window = freeGlobal;
|
||||
}
|
||||
|
||||
// Because of build optimizers
|
||||
if (typeof define === 'function' && define.amd) {
|
||||
define(['rx', 'exports'], function (Rx, exports) {
|
||||
root.Rx = factory(root, exports, Rx);
|
||||
return root.Rx;
|
||||
});
|
||||
} else if (typeof module === 'object' && module && module.exports === freeExports) {
|
||||
module.exports = factory(root, module.exports, require('./rx'));
|
||||
} else {
|
||||
root.Rx = factory(root, {}, root.Rx);
|
||||
}
|
||||
}(this, function (global, exp, Rx, undefined) {
|
||||
|
||||
var Observable = Rx.Observable,
|
||||
observableProto = Observable.prototype,
|
||||
AnonymousObservable = Rx.Internals.AnonymousObservable,
|
||||
Subject = Rx.Subject,
|
||||
AsyncSubject = Rx.AsyncSubject,
|
||||
Observer = Rx.Observer,
|
||||
ScheduledObserver = Rx.Internals.ScheduledObserver,
|
||||
disposableCreate = Rx.Disposable.create,
|
||||
disposableEmpty = Rx.Disposable.empty,
|
||||
CompositeDisposable = Rx.CompositeDisposable,
|
||||
currentThreadScheduler = Rx.Scheduler.currentThread,
|
||||
inherits = Rx.Internals.inherits,
|
||||
addProperties = Rx.Internals.addProperties;
|
||||
|
||||
// Utilities
|
||||
var objectDisposed = 'Object has been disposed';
|
||||
function checkDisposed() {
|
||||
if (this.isDisposed) {
|
||||
throw new Error(objectDisposed);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Multicasts the source sequence notifications through an instantiated subject into all uses of the sequence within a selector function. Each
|
||||
* subscription to the resulting sequence causes a separate multicast invocation, exposing the sequence resulting from the selector function's
|
||||
* invocation. For specializations with fixed subject types, see Publish, PublishLast, and Replay.
|
||||
*
|
||||
* @example
|
||||
* 1 - res = source.multicast(observable);
|
||||
* 2 - res = source.multicast(function () { return new Subject(); }, function (x) { return x; });
|
||||
*
|
||||
* @param {Mixed} subjectOrSubjectSelector
|
||||
* Factory function to create an intermediate subject through which the source sequence's elements will be multicast to the selector function.
|
||||
* Or:
|
||||
* Subject to push source elements into.
|
||||
*
|
||||
* @param {Function} [selector] Optional selector function which can use the multicasted source sequence subject to the policies enforced by the created subject. Specified only if <paramref name="subjectOrSubjectSelector" is a factory function.
|
||||
* @returns {Observable} An observable sequence that contains the elements of a sequence produced by multicasting the source sequence within a selector function.
|
||||
*/
|
||||
observableProto.multicast = function (subjectOrSubjectSelector, selector) {
|
||||
var source = this;
|
||||
return typeof subjectOrSubjectSelector === 'function' ?
|
||||
new AnonymousObservable(function (observer) {
|
||||
var connectable = source.multicast(subjectOrSubjectSelector());
|
||||
return new CompositeDisposable(selector(connectable).subscribe(observer), connectable.connect());
|
||||
}) :
|
||||
new ConnectableObservable(source, subjectOrSubjectSelector);
|
||||
};
|
||||
|
||||
/**
|
||||
* Returns an observable sequence that is the result of invoking the selector on a connectable observable sequence that shares a single subscription to the underlying sequence.
|
||||
* This operator is a specialization of Multicast using a regular Subject.
|
||||
*
|
||||
* @example
|
||||
* 1 - res = source.publish();
|
||||
* 2 - res = source.publish(function (x) { return x; });
|
||||
*
|
||||
* @param {Function} [selector] Selector function which can use the multicasted source sequence as many times as needed, without causing multiple subscriptions to the source sequence. Subscribers to the given source will receive all notifications of the source from the time of the subscription on.
|
||||
* @returns {Observable} An observable sequence that contains the elements of a sequence produced by multicasting the source sequence within a selector function.
|
||||
*/
|
||||
observableProto.publish = function (selector) {
|
||||
return !selector ?
|
||||
this.multicast(new Subject()) :
|
||||
this.multicast(function () {
|
||||
return new Subject();
|
||||
}, selector);
|
||||
};
|
||||
|
||||
/**
|
||||
* Returns an observable sequence that is the result of invoking the selector on a connectable observable sequence that shares a single subscription to the underlying sequence containing only the last notification.
|
||||
* This operator is a specialization of Multicast using a AsyncSubject.
|
||||
*
|
||||
* @example
|
||||
* 1 - res = source.publishLast();
|
||||
* 2 - res = source.publishLast(function (x) { return x; });
|
||||
*
|
||||
* @param selector [Optional] Selector function which can use the multicasted source sequence as many times as needed, without causing multiple subscriptions to the source sequence. Subscribers to the given source will only receive the last notification of the source.
|
||||
* @returns {Observable} An observable sequence that contains the elements of a sequence produced by multicasting the source sequence within a selector function.
|
||||
*/
|
||||
observableProto.publishLast = function (selector) {
|
||||
return !selector ?
|
||||
this.multicast(new AsyncSubject()) :
|
||||
this.multicast(function () {
|
||||
return new AsyncSubject();
|
||||
}, selector);
|
||||
};
|
||||
|
||||
/**
|
||||
* Returns an observable sequence that is the result of invoking the selector on a connectable observable sequence that shares a single subscription to the underlying sequence and starts with initialValue.
|
||||
* This operator is a specialization of Multicast using a BehaviorSubject.
|
||||
*
|
||||
* @example
|
||||
* 1 - res = source.publishValue(42);
|
||||
* 2 - res = source.publishLast(function (x) { return x.select(function (y) { return y * y; }) }, 42);
|
||||
*
|
||||
* @param {Function} [selector] Optional selector function which can use the multicasted source sequence as many times as needed, without causing multiple subscriptions to the source sequence. Subscribers to the given source will receive immediately receive the initial value, followed by all notifications of the source from the time of the subscription on.
|
||||
* @param {Mixed} initialValue Initial value received by observers upon subscription.
|
||||
* @returns {Observable} An observable sequence that contains the elements of a sequence produced by multicasting the source sequence within a selector function.
|
||||
*/
|
||||
observableProto.publishValue = function (initialValueOrSelector, initialValue) {
|
||||
return arguments.length === 2 ?
|
||||
this.multicast(function () {
|
||||
return new BehaviorSubject(initialValue);
|
||||
}, initialValueOrSelector) :
|
||||
this.multicast(new BehaviorSubject(initialValueOrSelector));
|
||||
};
|
||||
|
||||
/**
|
||||
* Returns an observable sequence that is the result of invoking the selector on a connectable observable sequence that shares a single subscription to the underlying sequence replaying notifications subject to a maximum time length for the replay buffer.
|
||||
* This operator is a specialization of Multicast using a ReplaySubject.
|
||||
*
|
||||
* @example
|
||||
* 1 - res = source.replay(null, 3);
|
||||
* 2 - res = source.replay(null, 3, 500);
|
||||
* 3 - res = source.replay(null, 3, 500, scheduler);
|
||||
* 4 - res = source.replay(function (x) { return x.take(6).repeat(); }, 3, 500, scheduler);
|
||||
*
|
||||
* @param selector [Optional] Selector function which can use the multicasted source sequence as many times as needed, without causing multiple subscriptions to the source sequence. Subscribers to the given source will receive all the notifications of the source subject to the specified replay buffer trimming policy.
|
||||
* @param bufferSize [Optional] Maximum element count of the replay buffer.
|
||||
* @param window [Optional] Maximum time length of the replay buffer.
|
||||
* @param scheduler [Optional] Scheduler where connected observers within the selector function will be invoked on.
|
||||
* @returns {Observable} An observable sequence that contains the elements of a sequence produced by multicasting the source sequence within a selector function.
|
||||
*/
|
||||
observableProto.replay = function (selector, bufferSize, window, scheduler) {
|
||||
return !selector ?
|
||||
this.multicast(new ReplaySubject(bufferSize, window, scheduler)) :
|
||||
this.multicast(function () {
|
||||
return new ReplaySubject(bufferSize, window, scheduler);
|
||||
}, selector);
|
||||
};
|
||||
|
||||
/** @private */
|
||||
var InnerSubscription = function (subject, observer) {
|
||||
this.subject = subject;
|
||||
this.observer = observer;
|
||||
};
|
||||
|
||||
/**
|
||||
* @private
|
||||
* @memberOf InnerSubscription
|
||||
*/
|
||||
InnerSubscription.prototype.dispose = function () {
|
||||
if (!this.subject.isDisposed && this.observer !== null) {
|
||||
var idx = this.subject.observers.indexOf(this.observer);
|
||||
this.subject.observers.splice(idx, 1);
|
||||
this.observer = null;
|
||||
}
|
||||
};
|
||||
|
||||
/**
|
||||
* Represents a value that changes over time.
|
||||
* Observers can subscribe to the subject to receive the last (or initial) value and all subsequent notifications.
|
||||
*/
|
||||
var BehaviorSubject = Rx.BehaviorSubject = (function (_super) {
|
||||
function subscribe(observer) {
|
||||
var ex;
|
||||
checkDisposed.call(this);
|
||||
if (!this.isStopped) {
|
||||
this.observers.push(observer);
|
||||
observer.onNext(this.value);
|
||||
return new InnerSubscription(this, observer);
|
||||
}
|
||||
ex = this.exception;
|
||||
if (ex) {
|
||||
observer.onError(ex);
|
||||
} else {
|
||||
observer.onCompleted();
|
||||
}
|
||||
return disposableEmpty;
|
||||
}
|
||||
|
||||
inherits(BehaviorSubject, _super);
|
||||
|
||||
/**
|
||||
* Initializes a new instance of the BehaviorSubject class which creates a subject that caches its last value and starts with the specified value.
|
||||
*
|
||||
* @param value Initial value sent to observers when no other value has been received by the subject yet.
|
||||
*/
|
||||
function BehaviorSubject(value) {
|
||||
_super.call(this, subscribe);
|
||||
|
||||
this.value = value,
|
||||
this.observers = [],
|
||||
this.isDisposed = false,
|
||||
this.isStopped = false,
|
||||
this.exception = null;
|
||||
}
|
||||
|
||||
addProperties(BehaviorSubject.prototype, Observer, {
|
||||
/**
|
||||
* Indicates whether the subject has observers subscribed to it.
|
||||
*
|
||||
* @memberOf BehaviorSubject#
|
||||
* @returns {Boolean} Indicates whether the subject has observers subscribed to it.
|
||||
*/
|
||||
hasObservers: function () {
|
||||
return this.observers.length > 0;
|
||||
},
|
||||
/**
|
||||
* Notifies all subscribed observers about the end of the sequence.
|
||||
*
|
||||
* @memberOf BehaviorSubject#
|
||||
*/
|
||||
onCompleted: function () {
|
||||
checkDisposed.call(this);
|
||||
if (!this.isStopped) {
|
||||
var os = this.observers.slice(0);
|
||||
this.isStopped = true;
|
||||
for (var i = 0, len = os.length; i < len; i++) {
|
||||
os[i].onCompleted();
|
||||
}
|
||||
|
||||
this.observers = [];
|
||||
}
|
||||
},
|
||||
/**
|
||||
* Notifies all subscribed observers about the exception.
|
||||
*
|
||||
* @memberOf BehaviorSubject#
|
||||
* @param {Mixed} error The exception to send to all observers.
|
||||
*/
|
||||
onError: function (error) {
|
||||
checkDisposed.call(this);
|
||||
if (!this.isStopped) {
|
||||
var os = this.observers.slice(0);
|
||||
this.isStopped = true;
|
||||
this.exception = error;
|
||||
|
||||
for (var i = 0, len = os.length; i < len; i++) {
|
||||
os[i].onError(error);
|
||||
}
|
||||
|
||||
this.observers = [];
|
||||
}
|
||||
},
|
||||
/**
|
||||
* Notifies all subscribed observers about the arrival of the specified element in the sequence.
|
||||
*
|
||||
* @memberOf BehaviorSubject#
|
||||
* @param {Mixed} value The value to send to all observers.
|
||||
*/
|
||||
onNext: function (value) {
|
||||
checkDisposed.call(this);
|
||||
if (!this.isStopped) {
|
||||
this.value = value;
|
||||
var os = this.observers.slice(0);
|
||||
for (var i = 0, len = os.length; i < len; i++) {
|
||||
os[i].onNext(value);
|
||||
}
|
||||
}
|
||||
},
|
||||
/**
|
||||
* Unsubscribe all observers and release resources.
|
||||
*
|
||||
* @memberOf BehaviorSubject#
|
||||
*/
|
||||
dispose: function () {
|
||||
this.isDisposed = true;
|
||||
this.observers = null;
|
||||
this.value = null;
|
||||
this.exception = null;
|
||||
}
|
||||
});
|
||||
|
||||
return BehaviorSubject;
|
||||
}(Observable));
|
||||
|
||||
/**
|
||||
* Represents an object that is both an observable sequence as well as an observer.
|
||||
* Each notification is broadcasted to all subscribed and future observers, subject to buffer trimming policies.
|
||||
*/
|
||||
var ReplaySubject = Rx.ReplaySubject = (function (_super) {
|
||||
/**
|
||||
* @private
|
||||
* @constructor
|
||||
*/
|
||||
var RemovableDisposable = function (subject, observer) {
|
||||
this.subject = subject;
|
||||
this.observer = observer;
|
||||
};
|
||||
|
||||
/*
|
||||
* @private
|
||||
* @memberOf RemovableDisposable#
|
||||
*/
|
||||
RemovableDisposable.prototype.dispose = function () {
|
||||
this.observer.dispose();
|
||||
if (!this.subject.isDisposed) {
|
||||
var idx = this.subject.observers.indexOf(this.observer);
|
||||
this.subject.observers.splice(idx, 1);
|
||||
}
|
||||
};
|
||||
|
||||
function subscribe(observer) {
|
||||
var so = new ScheduledObserver(this.scheduler, observer),
|
||||
subscription = new RemovableDisposable(this, so);
|
||||
checkDisposed.call(this);
|
||||
this._trim(this.scheduler.now());
|
||||
this.observers.push(so);
|
||||
|
||||
var n = this.q.length;
|
||||
|
||||
for (var i = 0, len = this.q.length; i < len; i++) {
|
||||
so.onNext(this.q[i].value);
|
||||
}
|
||||
|
||||
if (this.hasError) {
|
||||
n++;
|
||||
so.onError(this.error);
|
||||
} else if (this.isStopped) {
|
||||
n++;
|
||||
so.onCompleted();
|
||||
}
|
||||
|
||||
so.ensureActive(n);
|
||||
return subscription;
|
||||
}
|
||||
|
||||
inherits(ReplaySubject, _super);
|
||||
|
||||
/**
|
||||
* Initializes a new instance of the ReplaySubject class with the specified buffer size, window and scheduler.
|
||||
*
|
||||
* @param {Number} [bufferSize] Maximum element count of the replay buffer.
|
||||
* @param {Number} [window] Maximum time length of the replay buffer.
|
||||
* @param {Scheduler} [scheduler] Scheduler the observers are invoked on.
|
||||
*/
|
||||
function ReplaySubject(bufferSize, window, scheduler) {
|
||||
this.bufferSize = bufferSize == null ? Number.MAX_VALUE : bufferSize;
|
||||
this.window = window == null ? Number.MAX_VALUE : window;
|
||||
this.scheduler = scheduler || currentThreadScheduler;
|
||||
this.q = [];
|
||||
this.observers = [];
|
||||
this.isStopped = false;
|
||||
this.isDisposed = false;
|
||||
this.hasError = false;
|
||||
this.error = null;
|
||||
_super.call(this, subscribe);
|
||||
}
|
||||
|
||||
addProperties(ReplaySubject.prototype, Observer, {
|
||||
/**
|
||||
* Indicates whether the subject has observers subscribed to it.
|
||||
*
|
||||
* @memberOf ReplaySubject#
|
||||
* @returns {Boolean} Indicates whether the subject has observers subscribed to it.
|
||||
*/
|
||||
hasObservers: function () {
|
||||
return this.observers.length > 0;
|
||||
},
|
||||
/*
|
||||
* @private
|
||||
* @memberOf ReplaySubject#
|
||||
*/
|
||||
_trim: function (now) {
|
||||
while (this.q.length > this.bufferSize) {
|
||||
this.q.shift();
|
||||
}
|
||||
while (this.q.length > 0 && (now - this.q[0].interval) > this.window) {
|
||||
this.q.shift();
|
||||
}
|
||||
},
|
||||
/**
|
||||
* Notifies all subscribed observers about the arrival of the specified element in the sequence.
|
||||
*
|
||||
* @memberOf ReplaySubject#
|
||||
* @param {Mixed} value The value to send to all observers.
|
||||
*/
|
||||
onNext: function (value) {
|
||||
var observer;
|
||||
checkDisposed.call(this);
|
||||
if (!this.isStopped) {
|
||||
var now = this.scheduler.now();
|
||||
this.q.push({ interval: now, value: value });
|
||||
this._trim(now);
|
||||
|
||||
var o = this.observers.slice(0);
|
||||
for (var i = 0, len = o.length; i < len; i++) {
|
||||
observer = o[i];
|
||||
observer.onNext(value);
|
||||
observer.ensureActive();
|
||||
}
|
||||
}
|
||||
},
|
||||
/**
|
||||
* Notifies all subscribed observers about the exception.
|
||||
*
|
||||
* @memberOf ReplaySubject#
|
||||
* @param {Mixed} error The exception to send to all observers.
|
||||
*/
|
||||
onError: function (error) {
|
||||
var observer;
|
||||
checkDisposed.call(this);
|
||||
if (!this.isStopped) {
|
||||
this.isStopped = true;
|
||||
this.error = error;
|
||||
this.hasError = true;
|
||||
var now = this.scheduler.now();
|
||||
this._trim(now);
|
||||
var o = this.observers.slice(0);
|
||||
for (var i = 0, len = o.length; i < len; i++) {
|
||||
observer = o[i];
|
||||
observer.onError(error);
|
||||
observer.ensureActive();
|
||||
}
|
||||
this.observers = [];
|
||||
}
|
||||
},
|
||||
/**
|
||||
* Notifies all subscribed observers about the end of the sequence.
|
||||
*
|
||||
* @memberOf ReplaySubject#
|
||||
*/
|
||||
onCompleted: function () {
|
||||
var observer;
|
||||
checkDisposed.call(this);
|
||||
if (!this.isStopped) {
|
||||
this.isStopped = true;
|
||||
var now = this.scheduler.now();
|
||||
this._trim(now);
|
||||
var o = this.observers.slice(0);
|
||||
for (var i = 0, len = o.length; i < len; i++) {
|
||||
observer = o[i];
|
||||
observer.onCompleted();
|
||||
observer.ensureActive();
|
||||
}
|
||||
this.observers = [];
|
||||
}
|
||||
},
|
||||
/**
|
||||
* Unsubscribe all observers and release resources.
|
||||
*
|
||||
* @memberOf ReplaySubject#
|
||||
*/
|
||||
dispose: function () {
|
||||
this.isDisposed = true;
|
||||
this.observers = null;
|
||||
}
|
||||
});
|
||||
|
||||
return ReplaySubject;
|
||||
}(Observable));
|
||||
|
||||
/** @private */
|
||||
var ConnectableObservable = (function (_super) {
|
||||
inherits(ConnectableObservable, _super);
|
||||
|
||||
/**
|
||||
* @constructor
|
||||
* @private
|
||||
*/
|
||||
function ConnectableObservable(source, subject) {
|
||||
var state = {
|
||||
subject: subject,
|
||||
source: source.asObservable(),
|
||||
hasSubscription: false,
|
||||
subscription: null
|
||||
};
|
||||
|
||||
this.connect = function () {
|
||||
if (!state.hasSubscription) {
|
||||
state.hasSubscription = true;
|
||||
state.subscription = new CompositeDisposable(state.source.subscribe(state.subject), disposableCreate(function () {
|
||||
state.hasSubscription = false;
|
||||
}));
|
||||
}
|
||||
return state.subscription;
|
||||
};
|
||||
|
||||
function subscribe(observer) {
|
||||
return state.subject.subscribe(observer);
|
||||
}
|
||||
|
||||
_super.call(this, subscribe);
|
||||
}
|
||||
|
||||
/**
|
||||
* @private
|
||||
* @memberOf ConnectableObservable
|
||||
*/
|
||||
ConnectableObservable.prototype.connect = function () { return this.connect(); };
|
||||
|
||||
/**
|
||||
* @private
|
||||
* @memberOf ConnectableObservable
|
||||
*/
|
||||
ConnectableObservable.prototype.refCount = function () {
|
||||
var connectableSubscription = null, count = 0, source = this;
|
||||
return new AnonymousObservable(function (observer) {
|
||||
var shouldConnect, subscription;
|
||||
count++;
|
||||
shouldConnect = count === 1;
|
||||
subscription = source.subscribe(observer);
|
||||
if (shouldConnect) {
|
||||
connectableSubscription = source.connect();
|
||||
}
|
||||
return disposableCreate(function () {
|
||||
subscription.dispose();
|
||||
count--;
|
||||
if (count === 0) {
|
||||
connectableSubscription.dispose();
|
||||
}
|
||||
});
|
||||
});
|
||||
};
|
||||
|
||||
return ConnectableObservable;
|
||||
}(Observable));
|
||||
|
||||
return Rx;
|
||||
}));
|
||||
+1
File diff suppressed because one or more lines are too long
@@ -0,0 +1,679 @@
|
||||
// Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information.
|
||||
|
||||
(function (root, factory) {
|
||||
var freeExports = typeof exports == 'object' && exports,
|
||||
freeModule = typeof module == 'object' && module && module.exports == freeExports && module,
|
||||
freeGlobal = typeof global == 'object' && global;
|
||||
if (freeGlobal.global === freeGlobal) {
|
||||
window = freeGlobal;
|
||||
}
|
||||
|
||||
// Because of build optimizers
|
||||
if (typeof define === 'function' && define.amd) {
|
||||
define(['rx', 'exports'], function (Rx, exports) {
|
||||
root.Rx = factory(root, exports, Rx);
|
||||
return root.Rx;
|
||||
});
|
||||
} else if (typeof module === 'object' && module && module.exports === freeExports) {
|
||||
module.exports = factory(root, module.exports, require('./rx'));
|
||||
} else {
|
||||
root.Rx = factory(root, {}, root.Rx);
|
||||
}
|
||||
}(this, function (global, exp, Rx, undefined) {
|
||||
|
||||
var Observable = Rx.Observable,
|
||||
CompositeDisposable = Rx.CompositeDisposable,
|
||||
RefCountDisposable = Rx.RefCountDisposable,
|
||||
SingleAssignmentDisposable = Rx.SingleAssignmentDisposable,
|
||||
SerialDisposable = Rx.SerialDisposable,
|
||||
Subject = Rx.Subject,
|
||||
observableProto = Observable.prototype,
|
||||
observableEmpty = Observable.empty,
|
||||
AnonymousObservable = Rx.Internals.AnonymousObservable,
|
||||
observerCreate = Rx.Observer.create,
|
||||
addRef = Rx.Internals.addRef;
|
||||
|
||||
// defaults
|
||||
function noop() { }
|
||||
function defaultComparer(x, y) { return x === y; }
|
||||
|
||||
// Real Dictionary
|
||||
var primes = [1, 3, 7, 13, 31, 61, 127, 251, 509, 1021, 2039, 4093, 8191, 16381, 32749, 65521, 131071, 262139, 524287, 1048573, 2097143, 4194301, 8388593, 16777213, 33554393, 67108859, 134217689, 268435399, 536870909, 1073741789, 2147483647];
|
||||
var noSuchkey = "no such key";
|
||||
var duplicatekey = "duplicate key";
|
||||
|
||||
function isPrime(candidate) {
|
||||
if (candidate & 1 === 0) {
|
||||
return candidate === 2;
|
||||
}
|
||||
var num1 = Math.sqrt(candidate),
|
||||
num2 = 3;
|
||||
while (num2 <= num1) {
|
||||
if (candidate % num2 === 0) {
|
||||
return false;
|
||||
}
|
||||
num2 += 2;
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
function getPrime(min) {
|
||||
var index, num, candidate;
|
||||
for (index = 0; index < primes.length; ++index) {
|
||||
num = primes[index];
|
||||
if (num >= min) {
|
||||
return num;
|
||||
}
|
||||
}
|
||||
candidate = min | 1;
|
||||
while (candidate < primes[primes.length - 1]) {
|
||||
if (isPrime(candidate)) {
|
||||
return candidate;
|
||||
}
|
||||
candidate += 2;
|
||||
}
|
||||
return min;
|
||||
}
|
||||
|
||||
function stringHashFn(str) {
|
||||
var hash = 757602046;
|
||||
if (!str.length) {
|
||||
return hash;
|
||||
}
|
||||
for (var i = 0, len = str.length; i < len; i++) {
|
||||
var character = str.charCodeAt(i);
|
||||
hash = ((hash<<5)-hash)+character;
|
||||
hash = hash & hash;
|
||||
}
|
||||
return hash;
|
||||
}
|
||||
|
||||
function numberHashFn(key) {
|
||||
var c2 = 0x27d4eb2d;
|
||||
key = (key ^ 61) ^ (key >>> 16);
|
||||
key = key + (key << 3);
|
||||
key = key ^ (key >>> 4);
|
||||
key = key * c2;
|
||||
key = key ^ (key >>> 15);
|
||||
return key;
|
||||
}
|
||||
|
||||
var getHashCode = (function () {
|
||||
var uniqueIdCounter = 0;
|
||||
|
||||
return function (obj) {
|
||||
if (obj == null) {
|
||||
throw new Error(noSuchkey);
|
||||
}
|
||||
|
||||
// Check for built-ins before tacking on our own for any object
|
||||
if (typeof obj === 'string') {
|
||||
return stringHashFn(obj);
|
||||
}
|
||||
|
||||
if (typeof obj === 'number') {
|
||||
return numberHashFn(obj);
|
||||
}
|
||||
|
||||
if (typeof obj === 'boolean') {
|
||||
return obj === true ? 1 : 0;
|
||||
}
|
||||
|
||||
if (obj instanceof Date) {
|
||||
return obj.getTime();
|
||||
}
|
||||
|
||||
if (obj.getHashCode) {
|
||||
return obj.getHashCode();
|
||||
}
|
||||
|
||||
var id = 17 * uniqueIdCounter++;
|
||||
obj.getHashCode = function () { return id; };
|
||||
return id;
|
||||
};
|
||||
} ());
|
||||
|
||||
function newEntry() {
|
||||
return { key: null, value: null, next: 0, hashCode: 0 };
|
||||
}
|
||||
|
||||
// Dictionary implementation
|
||||
|
||||
var Dictionary = function (capacity, comparer) {
|
||||
if (capacity < 0) {
|
||||
throw new Error('out of range')
|
||||
}
|
||||
if (capacity > 0) {
|
||||
this._initialize(capacity);
|
||||
}
|
||||
|
||||
this.comparer = comparer || defaultComparer;
|
||||
this.freeCount = 0;
|
||||
this.size = 0;
|
||||
this.freeList = -1;
|
||||
};
|
||||
|
||||
Dictionary.prototype._initialize = function (capacity) {
|
||||
var prime = getPrime(capacity), i;
|
||||
this.buckets = new Array(prime);
|
||||
this.entries = new Array(prime);
|
||||
for (i = 0; i < prime; i++) {
|
||||
this.buckets[i] = -1;
|
||||
this.entries[i] = newEntry();
|
||||
}
|
||||
this.freeList = -1;
|
||||
};
|
||||
Dictionary.prototype.count = function () {
|
||||
return this.size;
|
||||
};
|
||||
Dictionary.prototype.add = function (key, value) {
|
||||
return this._insert(key, value, true);
|
||||
};
|
||||
Dictionary.prototype._insert = function (key, value, add) {
|
||||
if (!this.buckets) {
|
||||
this._initialize(0);
|
||||
}
|
||||
var index3;
|
||||
var num = getHashCode(key) & 2147483647;
|
||||
var index1 = num % this.buckets.length;
|
||||
for (var index2 = this.buckets[index1]; index2 >= 0; index2 = this.entries[index2].next) {
|
||||
if (this.entries[index2].hashCode === num && this.comparer(this.entries[index2].key, key)) {
|
||||
if (add) {
|
||||
throw new Error(duplicatekey);
|
||||
}
|
||||
this.entries[index2].value = value;
|
||||
return;
|
||||
}
|
||||
}
|
||||
if (this.freeCount > 0) {
|
||||
index3 = this.freeList;
|
||||
this.freeList = this.entries[index3].next;
|
||||
--this.freeCount;
|
||||
} else {
|
||||
if (this.size === this.entries.length) {
|
||||
this._resize();
|
||||
index1 = num % this.buckets.length;
|
||||
}
|
||||
index3 = this.size;
|
||||
++this.size;
|
||||
}
|
||||
this.entries[index3].hashCode = num;
|
||||
this.entries[index3].next = this.buckets[index1];
|
||||
this.entries[index3].key = key;
|
||||
this.entries[index3].value = value;
|
||||
this.buckets[index1] = index3;
|
||||
};
|
||||
|
||||
Dictionary.prototype._resize = function () {
|
||||
var prime = getPrime(this.size * 2),
|
||||
numArray = new Array(prime);
|
||||
for (index = 0; index < numArray.length; ++index) {
|
||||
numArray[index] = -1;
|
||||
}
|
||||
var entryArray = new Array(prime);
|
||||
for (index = 0; index < this.size; ++index) {
|
||||
entryArray[index] = this.entries[index];
|
||||
}
|
||||
for (var index = this.size; index < prime; ++index) {
|
||||
entryArray[index] = newEntry();
|
||||
}
|
||||
for (var index1 = 0; index1 < this.size; ++index1) {
|
||||
var index2 = entryArray[index1].hashCode % prime;
|
||||
entryArray[index1].next = numArray[index2];
|
||||
numArray[index2] = index1;
|
||||
}
|
||||
this.buckets = numArray;
|
||||
this.entries = entryArray;
|
||||
};
|
||||
|
||||
Dictionary.prototype.remove = function (key) {
|
||||
if (this.buckets) {
|
||||
var num = getHashCode(key) & 2147483647;
|
||||
var index1 = num % this.buckets.length;
|
||||
var index2 = -1;
|
||||
for (var index3 = this.buckets[index1]; index3 >= 0; index3 = this.entries[index3].next) {
|
||||
if (this.entries[index3].hashCode === num && this.comparer(this.entries[index3].key, key)) {
|
||||
if (index2 < 0) {
|
||||
this.buckets[index1] = this.entries[index3].next;
|
||||
} else {
|
||||
this.entries[index2].next = this.entries[index3].next;
|
||||
}
|
||||
this.entries[index3].hashCode = -1;
|
||||
this.entries[index3].next = this.freeList;
|
||||
this.entries[index3].key = null;
|
||||
this.entries[index3].value = null;
|
||||
this.freeList = index3;
|
||||
++this.freeCount;
|
||||
return true;
|
||||
} else {
|
||||
index2 = index3;
|
||||
}
|
||||
}
|
||||
}
|
||||
return false;
|
||||
};
|
||||
|
||||
Dictionary.prototype.clear = function () {
|
||||
var index, len;
|
||||
if (this.size <= 0) {
|
||||
return;
|
||||
}
|
||||
for (index = 0, len = this.buckets.length; index < len; ++index) {
|
||||
this.buckets[index] = -1;
|
||||
}
|
||||
for (index = 0; index < this.size; ++index) {
|
||||
this.entries[index] = newEntry();
|
||||
}
|
||||
this.freeList = -1;
|
||||
this.size = 0;
|
||||
};
|
||||
|
||||
Dictionary.prototype._findEntry = function (key) {
|
||||
if (this.buckets) {
|
||||
var num = getHashCode(key) & 2147483647;
|
||||
for (var index = this.buckets[num % this.buckets.length]; index >= 0; index = this.entries[index].next) {
|
||||
if (this.entries[index].hashCode === num && this.comparer(this.entries[index].key, key)) {
|
||||
return index;
|
||||
}
|
||||
}
|
||||
}
|
||||
return -1;
|
||||
};
|
||||
|
||||
Dictionary.prototype.count = function () {
|
||||
return this.size - this.freeCount;
|
||||
};
|
||||
|
||||
Dictionary.prototype.tryGetValue = function (key) {
|
||||
var entry = this._findEntry(key);
|
||||
if (entry >= 0) {
|
||||
return this.entries[entry].value;
|
||||
}
|
||||
return undefined;
|
||||
};
|
||||
|
||||
Dictionary.prototype.getValues = function () {
|
||||
var index = 0, results = [];
|
||||
if (this.entries) {
|
||||
for (var index1 = 0; index1 < this.size; index1++) {
|
||||
if (this.entries[index1].hashCode >= 0) {
|
||||
results[index++] = this.entries[index1].value;
|
||||
}
|
||||
}
|
||||
}
|
||||
return results;
|
||||
};
|
||||
|
||||
Dictionary.prototype.get = function (key) {
|
||||
var entry = this._findEntry(key);
|
||||
if (entry >= 0) {
|
||||
return this.entries[entry].value;
|
||||
}
|
||||
throw new Error(noSuchkey);
|
||||
};
|
||||
|
||||
Dictionary.prototype.set = function (key, value) {
|
||||
this._insert(key, value, false);
|
||||
};
|
||||
|
||||
Dictionary.prototype.containskey = function (key) {
|
||||
return this._findEntry(key) >= 0;
|
||||
};
|
||||
|
||||
/**
|
||||
* Correlates the elements of two sequences based on overlapping durations.
|
||||
*
|
||||
* @param {Observable} right The right observable sequence to join elements for.
|
||||
* @param {Function} leftDurationSelector A function to select the duration (expressed as an observable sequence) of each element of the left observable sequence, used to determine overlap.
|
||||
* @param {Function} rightDurationSelector A function to select the duration (expressed as an observable sequence) of each element of the right observable sequence, used to determine overlap.
|
||||
* @param {Function} resultSelector A function invoked to compute a result element for any two overlapping elements of the left and right observable sequences. The parameters passed to the function correspond with the elements from the left and right source sequences for which overlap occurs.
|
||||
* @returns {Observable} An observable sequence that contains result elements computed from source elements that have an overlapping duration.
|
||||
*/
|
||||
observableProto.join = function (right, leftDurationSelector, rightDurationSelector, resultSelector) {
|
||||
var left = this;
|
||||
return new AnonymousObservable(function (observer) {
|
||||
var group = new CompositeDisposable(),
|
||||
leftDone = false,
|
||||
leftId = 0,
|
||||
leftMap = new Dictionary(),
|
||||
rightDone = false,
|
||||
rightId = 0,
|
||||
rightMap = new Dictionary();
|
||||
group.add(left.subscribe(function (value) {
|
||||
var duration,
|
||||
expire,
|
||||
id = leftId++,
|
||||
md = new SingleAssignmentDisposable(),
|
||||
result,
|
||||
values;
|
||||
leftMap.add(id, value);
|
||||
group.add(md);
|
||||
expire = function () {
|
||||
if (leftMap.remove(id) && leftMap.count() === 0 && leftDone) {
|
||||
observer.onCompleted();
|
||||
}
|
||||
return group.remove(md);
|
||||
};
|
||||
try {
|
||||
duration = leftDurationSelector(value);
|
||||
} catch (e) {
|
||||
observer.onError(e);
|
||||
return;
|
||||
}
|
||||
md.disposable(duration.take(1).subscribe(noop, observer.onError.bind(observer), function () { expire(); }));
|
||||
values = rightMap.getValues();
|
||||
for (var i = 0; i < values.length; i++) {
|
||||
try {
|
||||
result = resultSelector(value, values[i]);
|
||||
} catch (exception) {
|
||||
observer.onError(exception);
|
||||
return;
|
||||
}
|
||||
observer.onNext(result);
|
||||
}
|
||||
}, observer.onError.bind(observer), function () {
|
||||
leftDone = true;
|
||||
if (rightDone || leftMap.count() === 0) {
|
||||
observer.onCompleted();
|
||||
}
|
||||
}));
|
||||
group.add(right.subscribe(function (value) {
|
||||
var duration,
|
||||
expire,
|
||||
id = rightId++,
|
||||
md = new SingleAssignmentDisposable(),
|
||||
result,
|
||||
values;
|
||||
rightMap.add(id, value);
|
||||
group.add(md);
|
||||
expire = function () {
|
||||
if (rightMap.remove(id) && rightMap.count() === 0 && rightDone) {
|
||||
observer.onCompleted();
|
||||
}
|
||||
return group.remove(md);
|
||||
};
|
||||
try {
|
||||
duration = rightDurationSelector(value);
|
||||
} catch (exception) {
|
||||
observer.onError(exception);
|
||||
return;
|
||||
}
|
||||
md.disposable(duration.take(1).subscribe(noop, observer.onError.bind(observer), function () { expire(); }));
|
||||
values = leftMap.getValues();
|
||||
for (var i = 0; i < values.length; i++) {
|
||||
try {
|
||||
result = resultSelector(values[i], value);
|
||||
} catch (exception) {
|
||||
observer.onError(exception);
|
||||
return;
|
||||
}
|
||||
observer.onNext(result);
|
||||
}
|
||||
}, observer.onError.bind(observer), function () {
|
||||
rightDone = true;
|
||||
if (leftDone || rightMap.count() === 0) {
|
||||
observer.onCompleted();
|
||||
}
|
||||
}));
|
||||
return group;
|
||||
});
|
||||
};
|
||||
|
||||
/**
|
||||
* Correlates the elements of two sequences based on overlapping durations, and groups the results.
|
||||
*
|
||||
* @param {Observable} right The right observable sequence to join elements for.
|
||||
* @param {Function} leftDurationSelector A function to select the duration (expressed as an observable sequence) of each element of the left observable sequence, used to determine overlap.
|
||||
* @param {Function} rightDurationSelector A function to select the duration (expressed as an observable sequence) of each element of the right observable sequence, used to determine overlap.
|
||||
* @param {Function} resultSelector A function invoked to compute a result element for any element of the left sequence with overlapping elements from the right observable sequence. The first parameter passed to the function is an element of the left sequence. The second parameter passed to the function is an observable sequence with elements from the right sequence that overlap with the left sequence's element.
|
||||
* @returns {Observable} An observable sequence that contains result elements computed from source elements that have an overlapping duration.
|
||||
*/
|
||||
observableProto.groupJoin = function (right, leftDurationSelector, rightDurationSelector, resultSelector) {
|
||||
var left = this;
|
||||
return new AnonymousObservable(function (observer) {
|
||||
var nothing = function () {};
|
||||
var group = new CompositeDisposable();
|
||||
var r = new RefCountDisposable(group);
|
||||
var leftMap = new Dictionary();
|
||||
var rightMap = new Dictionary();
|
||||
var leftID = 0;
|
||||
var rightID = 0;
|
||||
|
||||
group.add(left.subscribe(
|
||||
function (value) {
|
||||
var s = new Subject();
|
||||
var id = leftID++;
|
||||
leftMap.add(id, s);
|
||||
var i, len, leftValues, rightValues;
|
||||
|
||||
var result;
|
||||
try {
|
||||
result = resultSelector(value, addRef(s, r));
|
||||
} catch (e) {
|
||||
leftValues = leftMap.getValues();
|
||||
for (i = 0, len = leftValues.length; i < len; i++) {
|
||||
leftValues[i].onError(e);
|
||||
}
|
||||
observer.onError(e);
|
||||
return;
|
||||
}
|
||||
observer.onNext(result);
|
||||
|
||||
rightValues = rightMap.getValues();
|
||||
for (i = 0, len = rightValues.length; i < len; i++) {
|
||||
s.onNext(rightValues[i]);
|
||||
}
|
||||
|
||||
var md = new SingleAssignmentDisposable();
|
||||
group.add(md);
|
||||
|
||||
var expire = function () {
|
||||
if (leftMap.remove(id)) {
|
||||
s.onCompleted();
|
||||
}
|
||||
|
||||
group.remove(md);
|
||||
};
|
||||
|
||||
var duration;
|
||||
try {
|
||||
duration = leftDurationSelector(value);
|
||||
} catch (e) {
|
||||
leftValues = leftMap.getValues();
|
||||
for (i = 0, len = leftMap.length; i < len; i++) {
|
||||
leftValues[i].onError(e);
|
||||
}
|
||||
observer.onError(e);
|
||||
return;
|
||||
}
|
||||
|
||||
md.setDisposable(duration.take(1).subscribe(
|
||||
nothing,
|
||||
function (e) {
|
||||
leftValues = leftMap.getValues();
|
||||
for (i = 0, len = leftValues.length; i < len; i++) {
|
||||
leftValues[i].onError(e);
|
||||
}
|
||||
observer.onError(e);
|
||||
},
|
||||
expire)
|
||||
);
|
||||
},
|
||||
function (e) {
|
||||
var leftValues = leftMap.getValues();
|
||||
for (var i = 0, len = leftValues.length; i < len; i++) {
|
||||
leftValues[i].onError(e);
|
||||
}
|
||||
observer.onError(e);
|
||||
},
|
||||
observer.onCompleted.bind(observer)));
|
||||
|
||||
group.add(right.subscribe(
|
||||
function (value) {
|
||||
var leftValues, i, len;
|
||||
var id = rightID++;
|
||||
rightMap.add(id, value);
|
||||
|
||||
var md = new SingleAssignmentDisposable();
|
||||
group.add(md);
|
||||
|
||||
var expire = function () {
|
||||
rightMap.remove(id);
|
||||
group.remove(md);
|
||||
};
|
||||
|
||||
var duration;
|
||||
try {
|
||||
duration = rightDurationSelector(value);
|
||||
} catch (e) {
|
||||
leftValues = leftMap.getValues();
|
||||
for (i = 0, len = leftMap.length; i < len; i++) {
|
||||
leftValues[i].onError(e);
|
||||
}
|
||||
observer.onError(e);
|
||||
return;
|
||||
}
|
||||
md.setDisposable(duration.take(1).subscribe(
|
||||
nothing,
|
||||
function (e) {
|
||||
leftValues = leftMap.getValues();
|
||||
for (i = 0, len = leftMap.length; i < len; i++) {
|
||||
leftValues[i].onError(e);
|
||||
}
|
||||
observer.onError(e);
|
||||
},
|
||||
expire)
|
||||
);
|
||||
|
||||
leftValues = leftMap.getValues();
|
||||
for (i = 0, len = leftValues.length; i < len; i++) {
|
||||
leftValues[i].onNext(value);
|
||||
}
|
||||
},
|
||||
function (e) {
|
||||
var leftValues = leftMap.getValues();
|
||||
for (var i = 0, len = leftValues.length; i < len; i++) {
|
||||
leftValues[i].onError(e);
|
||||
}
|
||||
observer.onError(e);
|
||||
}));
|
||||
|
||||
return r;
|
||||
});
|
||||
}
|
||||
|
||||
/**
|
||||
* Projects each element of an observable sequence into zero or more buffers.
|
||||
*
|
||||
* @param {Mixed} bufferOpeningsOrClosingSelector Observable sequence whose elements denote the creation of new windows, or, a function invoked to define the boundaries of the produced windows (a new window is started when the previous one is closed, resulting in non-overlapping windows).
|
||||
* @param {Function} [bufferClosingSelector] A function invoked to define the closing of each produced window. If a closing selector function is specified for the first parameter, this parameter is ignored.
|
||||
* @returns {Observable} An observable sequence of windows.
|
||||
*/
|
||||
observableProto.buffer = function (bufferOpeningsOrClosingSelector, bufferClosingSelector) {
|
||||
return this.window.apply(this, arguments).selectMany(function (x) { return x.toArray(); });
|
||||
};
|
||||
|
||||
/**
|
||||
* Projects each element of an observable sequence into zero or more windows.
|
||||
*
|
||||
* @param {Mixed} windowOpeningsOrClosingSelector Observable sequence whose elements denote the creation of new windows, or, a function invoked to define the boundaries of the produced windows (a new window is started when the previous one is closed, resulting in non-overlapping windows).
|
||||
* @param {Function} [windowClosingSelector] A function invoked to define the closing of each produced window. If a closing selector function is specified for the first parameter, this parameter is ignored.
|
||||
* @returns {Observable} An observable sequence of windows.
|
||||
*/
|
||||
observableProto.window = function (windowOpeningsOrClosingSelector, windowClosingSelector) {
|
||||
if (arguments.length === 1 && typeof arguments[0] !== 'function') {
|
||||
return observableWindowWithBounaries.call(this, windowOpeningsOrClosingSelector);
|
||||
}
|
||||
return typeof windowOpeningsOrClosingSelector === 'function' ?
|
||||
observableWindowWithClosingSelector.call(this, windowOpeningsOrClosingSelector) :
|
||||
observableWindowWithOpenings.call(this, windowOpeningsOrClosingSelector, windowClosingSelector);
|
||||
};
|
||||
|
||||
function observableWindowWithOpenings(windowOpenings, windowClosingSelector) {
|
||||
return windowOpenings.groupJoin(this, windowClosingSelector, function () {
|
||||
return observableEmpty();
|
||||
}, function (_, window) {
|
||||
return window;
|
||||
});
|
||||
}
|
||||
|
||||
function observableWindowWithBounaries(windowBoundaries) {
|
||||
var source = this;
|
||||
return new AnonymousObservable(function (observer) {
|
||||
var window = new Subject(),
|
||||
d = new CompositeDisposable(),
|
||||
r = new RefCountDisposable(d);
|
||||
|
||||
observer.onNext(addRef(window, r));
|
||||
|
||||
d.add(source.subscribe(function (x) {
|
||||
window.onNext(x);
|
||||
}, function (err) {
|
||||
window.onError(err);
|
||||
observer.onError(err);
|
||||
}, function () {
|
||||
window.onCompleted();
|
||||
observer.onCompleted();
|
||||
}));
|
||||
|
||||
d.add(windowBoundaries.subscribe(function (w) {
|
||||
window.onCompleted();
|
||||
window = new Subject();
|
||||
observer.onNext(addRef(window, r));
|
||||
}, function (err) {
|
||||
window.onError(err);
|
||||
observer.onError(err);
|
||||
}, function () {
|
||||
window.onCompleted();
|
||||
observer.onCompleted();
|
||||
}));
|
||||
|
||||
return r;
|
||||
});
|
||||
}
|
||||
|
||||
function observableWindowWithClosingSelector(windowClosingSelector) {
|
||||
var source = this;
|
||||
return new AnonymousObservable(function (observer) {
|
||||
var createWindowClose,
|
||||
m = new SerialDisposable(),
|
||||
d = new CompositeDisposable(m),
|
||||
r = new RefCountDisposable(d),
|
||||
window = new Subject();
|
||||
observer.onNext(addRef(window, r));
|
||||
d.add(source.subscribe(function (x) {
|
||||
window.onNext(x);
|
||||
}, function (ex) {
|
||||
window.onError(ex);
|
||||
observer.onError(ex);
|
||||
}, function () {
|
||||
window.onCompleted();
|
||||
observer.onCompleted();
|
||||
}));
|
||||
createWindowClose = function () {
|
||||
var m1, windowClose;
|
||||
try {
|
||||
windowClose = windowClosingSelector();
|
||||
} catch (exception) {
|
||||
observer.onError(exception);
|
||||
return;
|
||||
}
|
||||
m1 = new SingleAssignmentDisposable();
|
||||
m.disposable(m1);
|
||||
m1.disposable(windowClose.take(1).subscribe(noop, function (ex) {
|
||||
window.onError(ex);
|
||||
observer.onError(ex);
|
||||
}, function () {
|
||||
window.onCompleted();
|
||||
window = new Subject();
|
||||
observer.onNext(addRef(window, r));
|
||||
createWindowClose();
|
||||
}));
|
||||
};
|
||||
createWindowClose();
|
||||
return r;
|
||||
});
|
||||
}
|
||||
|
||||
return Rx;
|
||||
}));
|
||||
+1
File diff suppressed because one or more lines are too long
@@ -0,0 +1,454 @@
|
||||
// Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information.
|
||||
|
||||
(function (root, factory) {
|
||||
var freeExports = typeof exports == 'object' && exports,
|
||||
freeModule = typeof module == 'object' && module && module.exports == freeExports && module,
|
||||
freeGlobal = typeof global == 'object' && global;
|
||||
if (freeGlobal.global === freeGlobal) {
|
||||
window = freeGlobal;
|
||||
}
|
||||
|
||||
// Because of build optimizers
|
||||
if (typeof define === 'function' && define.amd) {
|
||||
define(['rx', 'exports'], function (Rx, exports) {
|
||||
root.Rx = factory(root, exports, Rx);
|
||||
return root.Rx;
|
||||
});
|
||||
} else if (typeof module === 'object' && module && module.exports === freeExports) {
|
||||
module.exports = factory(root, module.exports, require('./rx'));
|
||||
} else {
|
||||
root.Rx = factory(root, {}, root.Rx);
|
||||
}
|
||||
}(this, function (global, exp, Rx, undefined) {
|
||||
|
||||
// Aliases
|
||||
var Observable = Rx.Observable,
|
||||
observableProto = Observable.prototype,
|
||||
observableCreateWithDisposable = Observable.createWithDisposable,
|
||||
observableConcat = Observable.concat,
|
||||
observableDefer = Observable.defer,
|
||||
observableEmpty = Observable.empty,
|
||||
disposableEmpty = Rx.Disposable.empty,
|
||||
BinaryObserver = Rx.Internals.BinaryObserver,
|
||||
CompositeDisposable = Rx.CompositeDisposable,
|
||||
SerialDisposable = Rx.SerialDisposable,
|
||||
SingleAssignmentDisposable = Rx.SingleAssignmentDisposable,
|
||||
enumeratorCreate = Rx.Internals.Enumerator.create,
|
||||
Enumerable = Rx.Internals.Enumerable,
|
||||
enumerableForEach = Enumerable.forEach,
|
||||
immediateScheduler = Rx.Scheduler.immediate,
|
||||
currentThreadScheduler = Rx.Scheduler.currentThread,
|
||||
slice = Array.prototype.slice,
|
||||
AsyncSubject = Rx.AsyncSubject,
|
||||
Observer = Rx.Observer,
|
||||
inherits = Rx.Internals.inherits,
|
||||
addProperties = Rx.Internals.addProperties;
|
||||
|
||||
// Utilities
|
||||
function nothing () { }
|
||||
function argsOrArray(args, idx) {
|
||||
return args.length === 1 && Array.isArray(args[idx]) ?
|
||||
args[idx] :
|
||||
slice.call(args);
|
||||
}
|
||||
|
||||
function enumerableWhile(condition, source) {
|
||||
return new Enumerable(function () {
|
||||
var current;
|
||||
return enumeratorCreate(function () {
|
||||
if (condition()) {
|
||||
current = source;
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}, function () { return current; });
|
||||
});
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns an observable sequence that is the result of invoking the selector on the source sequence, without sharing subscriptions.
|
||||
* This operator allows for a fluent style of writing queries that use the same sequence multiple times.
|
||||
*
|
||||
* @memberOf Observable#
|
||||
* @param {Function} selector Selector function which can use the source sequence as many times as needed, without sharing subscriptions to the source sequence.
|
||||
* @returns {Observable} An observable sequence that contains the elements of a sequence produced by multicasting the source sequence within a selector function.
|
||||
*/
|
||||
observableProto.letBind = function (func) {
|
||||
return func(this);
|
||||
};
|
||||
|
||||
/**
|
||||
* Determines whether an observable collection contains values. There is an alias for this method called 'ifThen' for browsers <IE9
|
||||
*
|
||||
* @example
|
||||
* 1 - res = Rx.Observable.if(condition, obs1);
|
||||
* 2 - res = Rx.Observable.if(condition, obs1, obs2);
|
||||
* 3 - res = Rx.Observable.if(condition, obs1, scheduler);
|
||||
* @static
|
||||
* @memberOf Observable
|
||||
* @param {Function} condition The condition which determines if the thenSource or elseSource will be run.
|
||||
* @param {Observable} thenSource The observable sequence that will be run if the condition function returns true.
|
||||
* @param {Observable} [elseSource] The observable sequence that will be run if the condition function returns false. If this is not provided, it defaults to Rx.Observabe.Empty with the specified scheduler.
|
||||
* @returns {Observable} An observable sequence which is either the thenSource or elseSource.
|
||||
*/
|
||||
Observable['if'] = Observable.ifThen = function (condition, thenSource, elseSourceOrScheduler) {
|
||||
return observableDefer(function () {
|
||||
elseSourceOrScheduler || (elseSourceOrScheduler = observableEmpty());
|
||||
if (elseSourceOrScheduler.now) {
|
||||
var scheduler = elseSourceOrScheduler;
|
||||
elseSourceOrScheduler = observableEmpty(scheduler);
|
||||
}
|
||||
return condition() ? thenSource : elseSourceOrScheduler;
|
||||
});
|
||||
};
|
||||
|
||||
/**
|
||||
* Concatenates the observable sequences obtained by running the specified result selector for each element in source.
|
||||
* There is an alias for this method called 'forIn' for browsers <IE9
|
||||
* @static
|
||||
* @memberOf Observable
|
||||
* @param {Array} sources An array of values to turn into an observable sequence.
|
||||
* @param {Function} resultSelector A function to apply to each item in the sources array to turn it into an observable sequence.
|
||||
* @returns {Observable} An observable sequence from the concatenated observable sequences.
|
||||
*/
|
||||
Observable['for'] = Observable.forIn = function (sources, resultSelector) {
|
||||
return enumerableForEach(sources, resultSelector).concat();
|
||||
};
|
||||
|
||||
/**
|
||||
* Repeats source as long as condition holds emulating a while loop.
|
||||
* There is an alias for this method called 'whileDo' for browsers <IE9
|
||||
* @static
|
||||
* @memberOf Observable
|
||||
* @param {Function} condition The condition which determines if the source will be repeated.
|
||||
* @param {Observable} source The observable sequence that will be run if the condition function returns true.
|
||||
* @returns {Observable} An observable sequence which is repeated as long as the condition holds.
|
||||
*/
|
||||
var observableWhileDo = Observable['while'] = Observable.whileDo = function (condition, source) {
|
||||
return enumerableWhile(condition, source).concat();
|
||||
};
|
||||
|
||||
/**
|
||||
* Repeats source as long as condition holds emulating a do while loop.
|
||||
*
|
||||
* @memberOf Observable#
|
||||
* @param {Function} condition The condition which determines if the source will be repeated.
|
||||
* @param {Observable} source The observable sequence that will be run if the condition function returns true.
|
||||
* @returns {Observable} An observable sequence which is repeated as long as the condition holds.
|
||||
*/
|
||||
observableProto.doWhile = function (condition) {
|
||||
return observableConcat([this, observableWhileDo(condition, this)]);
|
||||
};
|
||||
|
||||
/**
|
||||
* Uses selector to determine which source in sources to use.
|
||||
* There is an alias 'switchCase' for browsers <IE9.
|
||||
*
|
||||
* @example
|
||||
* 1 - res = Rx.Observable.case(selector, { '1': obs1, '2': obs2 });
|
||||
* 1 - res = Rx.Observable.case(selector, { '1': obs1, '2': obs2 }, obs0);
|
||||
* 1 - res = Rx.Observable.case(selector, { '1': obs1, '2': obs2 }, scheduler);
|
||||
*
|
||||
* @static
|
||||
* @memberOf Observable
|
||||
* @param {Function} selector The function which extracts the value for to test in a case statement.
|
||||
* @param {Array} sources A object which has keys which correspond to the case statement labels.
|
||||
* @param {Observable} [elseSource] The observable sequence that will be run if the sources are not matched. If this is not provided, it defaults to Rx.Observabe.Empty with the specified scheduler.
|
||||
*
|
||||
* @returns {Observable} An observable sequence which is determined by a case statement.
|
||||
*/
|
||||
Observable['case'] = Observable.switchCase = function (selector, sources, defaultSourceOrScheduler) {
|
||||
return observableDefer(function () {
|
||||
defaultSourceOrScheduler || (defaultSourceOrScheduler = observableEmpty());
|
||||
if (defaultSourceOrScheduler.now) {
|
||||
var scheduler = defaultSourceOrScheduler;
|
||||
defaultSourceOrScheduler = observableEmpty(scheduler);
|
||||
}
|
||||
var result = sources[selector()];
|
||||
return result !== undefined ? result : defaultSourceOrScheduler;
|
||||
});
|
||||
};
|
||||
|
||||
/**
|
||||
* Expands an observable sequence by recursively invoking selector.
|
||||
*
|
||||
* @memberOf Observable#
|
||||
* @param {Function} selector Selector function to invoke for each produced element, resulting in another sequence to which the selector will be invoked recursively again.
|
||||
* @param {Scheduler} [scheduler] Scheduler on which to perform the expansion. If not provided, this defaults to the current thread scheduler.
|
||||
* @returns {Observable} An observable sequence containing all the elements produced by the recursive expansion.
|
||||
*/
|
||||
observableProto.expand = function (selector, scheduler) {
|
||||
scheduler || (scheduler = immediateScheduler);
|
||||
var source = this;
|
||||
return observableCreateWithDisposable(function (observer) {
|
||||
var q = [],
|
||||
m = new SerialDisposable(),
|
||||
d = new CompositeDisposable(m),
|
||||
activeCount = 0,
|
||||
isAcquired = false;
|
||||
|
||||
var ensureActive = function () {
|
||||
var isOwner = false;
|
||||
if (q.length > 0) {
|
||||
isOwner = !isAcquired;
|
||||
isAcquired = true;
|
||||
}
|
||||
if (isOwner) {
|
||||
m.setDisposable(scheduler.scheduleRecursive(function (self) {
|
||||
var work;
|
||||
if (q.length > 0) {
|
||||
work = q.shift();
|
||||
} else {
|
||||
isAcquired = false;
|
||||
return;
|
||||
}
|
||||
var m1 = new SingleAssignmentDisposable();
|
||||
d.add(m1);
|
||||
m1.setDisposable(work.subscribe(function (x) {
|
||||
observer.onNext(x);
|
||||
var result = null;
|
||||
try {
|
||||
result = selector(x);
|
||||
} catch (e) {
|
||||
observer.onError(e);
|
||||
}
|
||||
q.push(result);
|
||||
activeCount++;
|
||||
ensureActive();
|
||||
}, observer.onError.bind(observer), function () {
|
||||
d.remove(m1);
|
||||
activeCount--;
|
||||
if (activeCount === 0) {
|
||||
observer.onCompleted();
|
||||
}
|
||||
}));
|
||||
self();
|
||||
}));
|
||||
}
|
||||
};
|
||||
|
||||
q.push(source);
|
||||
activeCount++;
|
||||
ensureActive();
|
||||
return d;
|
||||
});
|
||||
};
|
||||
|
||||
/**
|
||||
* Runs all observable sequences in parallel and collect their last elements.
|
||||
*
|
||||
* @example
|
||||
* 1 - res = Rx.Observable.forkJoin([obs1, obs2]);
|
||||
* 1 - res = Rx.Observable.forkJoin(obs1, obs2, ...);
|
||||
* @static
|
||||
* @memberOf Observable
|
||||
* @returns {Observable} An observable sequence with an array collecting the last elements of all the input sequences.
|
||||
*/
|
||||
Observable.forkJoin = function () {
|
||||
var allSources = argsOrArray(arguments, 0);
|
||||
return observableCreateWithDisposable(function (subscriber) {
|
||||
var count = allSources.length;
|
||||
if (count === 0) {
|
||||
subscriber.onCompleted();
|
||||
return disposableEmpty;
|
||||
}
|
||||
var group = new CompositeDisposable(),
|
||||
finished = false,
|
||||
hasResults = new Array(count),
|
||||
hasCompleted = new Array(count),
|
||||
results = new Array(count);
|
||||
|
||||
for (var idx = 0; idx < count; idx++) {
|
||||
(function (i) {
|
||||
var source = allSources[i];
|
||||
group.add(source.subscribe(function (value) {
|
||||
if (!finished) {
|
||||
hasResults[i] = true;
|
||||
results[i] = value;
|
||||
}
|
||||
}, function (e) {
|
||||
finished = true;
|
||||
subscriber.onError(e);
|
||||
group.dispose();
|
||||
}, function () {
|
||||
if (!finished) {
|
||||
if (!hasResults[i]) {
|
||||
subscriber.onCompleted();
|
||||
return;
|
||||
}
|
||||
hasCompleted[i] = true;
|
||||
for (var ix = 0; ix < count; ix++) {
|
||||
if (!hasCompleted[ix]) {
|
||||
return;
|
||||
}
|
||||
}
|
||||
finished = true;
|
||||
subscriber.onNext(results);
|
||||
subscriber.onCompleted();
|
||||
}
|
||||
}));
|
||||
})(idx);
|
||||
}
|
||||
|
||||
return group;
|
||||
});
|
||||
};
|
||||
|
||||
/**
|
||||
* Runs two observable sequences in parallel and combines their last elemenets.
|
||||
*
|
||||
* @memberOf Observable#
|
||||
* @param {Observable} second Second observable sequence.
|
||||
* @param {Function} resultSelector Result selector function to invoke with the last elements of both sequences.
|
||||
* @returns {Observable} An observable sequence with the result of calling the selector function with the last elements of both input sequences.
|
||||
*/
|
||||
observableProto.forkJoin = function (second, resultSelector) {
|
||||
var first = this;
|
||||
|
||||
return observableCreateWithDisposable(function (observer) {
|
||||
var leftStopped = false, rightStopped = false,
|
||||
hasLeft = false, hasRight = false,
|
||||
lastLeft, lastRight,
|
||||
leftSubscription = new SingleAssignmentDisposable(), rightSubscription = new SingleAssignmentDisposable();
|
||||
|
||||
leftSubscription.setDisposable(
|
||||
first.subscribe(function (left) {
|
||||
hasLeft = true;
|
||||
lastLeft = left;
|
||||
}, function (err) {
|
||||
rightSubscription.dispose();
|
||||
observer.onError(err);
|
||||
}, function () {
|
||||
leftStopped = true;
|
||||
if (rightStopped) {
|
||||
if (!hasLeft) {
|
||||
observer.onCompleted();
|
||||
} else if (!hasRight) {
|
||||
observer.onCompleted();
|
||||
} else {
|
||||
var result;
|
||||
try {
|
||||
result = resultSelector(lastLeft, lastRight);
|
||||
} catch (e) {
|
||||
observer.onError(e);
|
||||
return;
|
||||
}
|
||||
observer.onNext(result);
|
||||
observer.onCompleted();
|
||||
}
|
||||
}
|
||||
})
|
||||
);
|
||||
|
||||
rightSubscription.setDisposable(
|
||||
second.subscribe(function (right) {
|
||||
hasRight = true;
|
||||
lastRight = right;
|
||||
}, function (err) {
|
||||
leftSubscription.dispose();
|
||||
observer.onError(err);
|
||||
}, function () {
|
||||
rightStopped = true;
|
||||
if (leftStopped) {
|
||||
if (!hasLeft) {
|
||||
observer.onCompleted();
|
||||
} else if (!hasRight) {
|
||||
observer.onCompleted();
|
||||
} else {
|
||||
var result;
|
||||
try {
|
||||
result = resultSelector(lastLeft, lastRight);
|
||||
} catch (e) {
|
||||
observer.onError(e);
|
||||
return;
|
||||
}
|
||||
observer.onNext(result);
|
||||
observer.onCompleted();
|
||||
}
|
||||
}
|
||||
})
|
||||
);
|
||||
|
||||
return new CompositeDisposable(leftSubscription, rightSubscription);
|
||||
});
|
||||
};
|
||||
|
||||
/**
|
||||
* Comonadic bind operator.
|
||||
* @param {Function} selector A transform function to apply to each element.
|
||||
* @param {Object} scheduler Scheduler used to execute the operation. If not specified, defaults to the ImmediateScheduler.
|
||||
* @returns {Observable} An observable sequence which results from the comonadic bind operation.
|
||||
*/
|
||||
observableProto.manySelect = function (selector, scheduler) {
|
||||
scheduler || (scheduler = immediateScheduler);
|
||||
var source = this;
|
||||
return Observable.defer(function () {
|
||||
var chain;
|
||||
|
||||
return source
|
||||
.select(
|
||||
function (x) {
|
||||
var curr = new ChainObservable(x);
|
||||
if (chain) {
|
||||
chain.onNext(x);
|
||||
}
|
||||
chain = curr;
|
||||
|
||||
return curr;
|
||||
})
|
||||
.doAction(
|
||||
nothing,
|
||||
function (e) {
|
||||
if (chain) {
|
||||
chain.onError(e);
|
||||
}
|
||||
},
|
||||
function () {
|
||||
if (chain) {
|
||||
chain.onCompleted();
|
||||
}
|
||||
})
|
||||
.observeOn(scheduler)
|
||||
.select(function (x, i, o) { return selector(x, i, o); });
|
||||
});
|
||||
};
|
||||
|
||||
var ChainObservable = (function (_super) {
|
||||
|
||||
function subscribe (observer) {
|
||||
var self = this, g = new CompositeDisposable();
|
||||
g.add(currentThreadScheduler.schedule(function () {
|
||||
observer.onNext(self.head);
|
||||
g.add(self.tail.mergeObservable().subscribe(observer));
|
||||
}));
|
||||
|
||||
return g;
|
||||
}
|
||||
|
||||
inherits(ChainObservable, _super);
|
||||
|
||||
function ChainObservable(head) {
|
||||
_super.call(this, subscribe);
|
||||
this.head = head;
|
||||
this.tail = new AsyncSubject();
|
||||
}
|
||||
|
||||
addProperties(ChainObservable.prototype, Observer, {
|
||||
onCompleted: function () {
|
||||
this.onNext(Observable.empty());
|
||||
},
|
||||
onError: function (e) {
|
||||
this.onNext(Observable.throwException(e));
|
||||
},
|
||||
onNext: function (v) {
|
||||
this.tail.onNext(v);
|
||||
this.tail.onCompleted();
|
||||
}
|
||||
});
|
||||
|
||||
return ChainObservable;
|
||||
|
||||
}(Observable));
|
||||
|
||||
return Rx;
|
||||
}));
|
||||
@@ -0,0 +1 @@
|
||||
(function(t,e){var n="object"==typeof exports&&exports,r=("object"==typeof module&&module&&module.exports==n&&module,"object"==typeof global&&global);r.global===r&&(window=r),"function"==typeof define&&define.amd?define(["rx","exports"],function(n,r){return t.Rx=e(t,r,n),t.Rx}):"object"==typeof module&&module&&module.exports===n?module.exports=e(t,module.exports,require("./rx")):t.Rx=e(t,{},t.Rx)})(this,function(t,e,n,r){function i(){}function o(t,e){return 1===t.length&&Array.isArray(t[e])?t[e]:x.call(t)}function s(t,e){return new y(function(){var n;return m(function(){return t()?(n=e,!0):!1},function(){return n})})}var u=n.Observable,c=u.prototype,a=u.createWithDisposable,h=u.concat,l=u.defer,f=u.empty,p=n.Disposable.empty,d=(n.Internals.BinaryObserver,n.CompositeDisposable),b=n.SerialDisposable,v=n.SingleAssignmentDisposable,m=n.Internals.Enumerator.create,y=n.Internals.Enumerable,w=y.forEach,g=n.Scheduler.immediate,E=n.Scheduler.currentThread,x=Array.prototype.slice,C=n.AsyncSubject,D=n.Observer,A=n.Internals.inherits,S=n.Internals.addProperties;c.letBind=function(t){return t(this)},u["if"]=u.ifThen=function(t,e,n){return l(function(){if(n||(n=f()),n.now){var r=n;n=f(r)}return t()?e:n})},u["for"]=u.forIn=function(t,e){return w(t,e).concat()};var N=u["while"]=u.whileDo=function(t,e){return s(t,e).concat()};c.doWhile=function(t){return h([this,N(t,this)])},u["case"]=u.switchCase=function(t,e,n){return l(function(){if(n||(n=f()),n.now){var i=n;n=f(i)}var o=e[t()];return o!==r?o:n})},c.expand=function(t,e){e||(e=g);var n=this;return a(function(i){var o=[],s=new b,u=new d(s),c=0,a=!1,h=function(){var n=!1;o.length>0&&(n=!a,a=!0),n&&s.setDisposable(e.scheduleRecursive(function(e){var n;if(!(o.length>0))return a=!1,r;n=o.shift();var s=new v;u.add(s),s.setDisposable(n.subscribe(function(e){i.onNext(e);var n=null;try{n=t(e)}catch(r){i.onError(r)}o.push(n),c++,h()},i.onError.bind(i),function(){u.remove(s),c--,0===c&&i.onCompleted()})),e()}))};return o.push(n),c++,h(),u})},u.forkJoin=function(){var t=o(arguments,0);return a(function(e){var n=t.length;if(0===n)return e.onCompleted(),p;for(var i=new d,o=!1,s=Array(n),u=Array(n),c=Array(n),a=0;n>a;a++)(function(a){var h=t[a];i.add(h.subscribe(function(t){o||(s[a]=!0,c[a]=t)},function(t){o=!0,e.onError(t),i.dispose()},function(){if(!o){if(!s[a])return e.onCompleted(),r;u[a]=!0;for(var t=0;n>t;t++)if(!u[t])return;o=!0,e.onNext(c),e.onCompleted()}}))})(a);return i})},c.forkJoin=function(t,e){var n=this;return a(function(i){var o,s,u=!1,c=!1,a=!1,h=!1,l=new v,f=new v;return l.setDisposable(n.subscribe(function(t){a=!0,o=t},function(t){f.dispose(),i.onError(t)},function(){if(u=!0,c)if(a)if(h){var t;try{t=e(o,s)}catch(n){return i.onError(n),r}i.onNext(t),i.onCompleted()}else i.onCompleted();else i.onCompleted()})),f.setDisposable(t.subscribe(function(t){h=!0,s=t},function(t){l.dispose(),i.onError(t)},function(){if(c=!0,u)if(a)if(h){var t;try{t=e(o,s)}catch(n){return i.onError(n),r}i.onNext(t),i.onCompleted()}else i.onCompleted();else i.onCompleted()})),new d(l,f)})},c.manySelect=function(t,e){e||(e=g);var n=this;return u.defer(function(){var r;return n.select(function(t){var e=new _(t);return r&&r.onNext(t),r=e,e}).doAction(i,function(t){r&&r.onError(t)},function(){r&&r.onCompleted()}).observeOn(e).select(function(e,n,r){return t(e,n,r)})})};var _=function(t){function e(t){var e=this,n=new d;return n.add(E.schedule(function(){t.onNext(e.head),n.add(e.tail.mergeObservable().subscribe(t))})),n}function n(n){t.call(this,e),this.head=n,this.tail=new C}return A(n,t),S(n.prototype,D,{onCompleted:function(){this.onNext(u.empty())},onError:function(t){this.onNext(u.throwException(t))},onNext:function(t){this.tail.onNext(t),this.tail.onCompleted()}}),n}(u);return n});
|
||||
@@ -0,0 +1,408 @@
|
||||
// Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information.
|
||||
|
||||
(function (root, factory) {
|
||||
var freeExports = typeof exports == 'object' && exports,
|
||||
freeModule = typeof module == 'object' && module && module.exports == freeExports && module,
|
||||
freeGlobal = typeof global == 'object' && global;
|
||||
if (freeGlobal.global === freeGlobal) {
|
||||
window = freeGlobal;
|
||||
}
|
||||
|
||||
// Because of build optimizers
|
||||
if (typeof define === 'function' && define.amd) {
|
||||
define(['rx', 'exports'], function (Rx, exports) {
|
||||
root.Rx = factory(root, exports, Rx);
|
||||
return root.Rx;
|
||||
});
|
||||
} else if (typeof module === 'object' && module && module.exports === freeExports) {
|
||||
module.exports = factory(root, module.exports, require('./rx'));
|
||||
} else {
|
||||
root.Rx = factory(root, {}, root.Rx);
|
||||
}
|
||||
}(this, function (global, exp, Rx, undefined) {
|
||||
|
||||
// Aliases
|
||||
var Observable = Rx.Observable,
|
||||
observableProto = Observable.prototype,
|
||||
AnonymousObservable = Rx.Internals.AnonymousObservable,
|
||||
observableThrow = Observable.throwException,
|
||||
observerCreate = Rx.Observer.create,
|
||||
SingleAssignmentDisposable = Rx.SingleAssignmentDisposable,
|
||||
CompositeDisposable = Rx.CompositeDisposable,
|
||||
AbstractObserver = Rx.Internals.AbstractObserver,
|
||||
isEqual = Rx.Internals.isEqual;
|
||||
|
||||
// Defaults
|
||||
function defaultComparer(x, y) { return isEqual(x, y); }
|
||||
function noop() { }
|
||||
|
||||
// Utilities
|
||||
var inherits = Rx.Internals.inherits;
|
||||
var slice = Array.prototype.slice;
|
||||
function argsOrArray(args, idx) {
|
||||
return args.length === 1 && Array.isArray(args[idx]) ?
|
||||
args[idx] :
|
||||
slice.call(args);
|
||||
}
|
||||
|
||||
/** @private */
|
||||
var Map = (function () {
|
||||
|
||||
/**
|
||||
* @constructor
|
||||
* @private
|
||||
*/
|
||||
function Map() {
|
||||
this.keys = [];
|
||||
this.values = [];
|
||||
}
|
||||
|
||||
/**
|
||||
* @private
|
||||
* @memberOf Map#
|
||||
*/
|
||||
Map.prototype['delete'] = function (key) {
|
||||
var i = this.keys.indexOf(key);
|
||||
if (i !== -1) {
|
||||
this.keys.splice(i, 1);
|
||||
this.values.splice(i, 1);
|
||||
}
|
||||
return i !== -1;
|
||||
};
|
||||
|
||||
/**
|
||||
* @private
|
||||
* @memberOf Map#
|
||||
*/
|
||||
Map.prototype.get = function (key, fallback) {
|
||||
var i = this.keys.indexOf(key);
|
||||
return i !== -1 ? this.values[i] : fallback;
|
||||
};
|
||||
|
||||
/**
|
||||
* @private
|
||||
* @memberOf Map#
|
||||
*/
|
||||
Map.prototype.set = function (key, value) {
|
||||
var i = this.keys.indexOf(key);
|
||||
if (i !== -1) {
|
||||
this.values[i] = value;
|
||||
}
|
||||
this.values[this.keys.push(key) - 1] = value;
|
||||
};
|
||||
|
||||
/**
|
||||
* @private
|
||||
* @memberOf Map#
|
||||
*/
|
||||
Map.prototype.size = function () { return this.keys.length; };
|
||||
|
||||
/**
|
||||
* @private
|
||||
* @memberOf Map#
|
||||
*/
|
||||
Map.prototype.has = function (key) {
|
||||
return this.keys.indexOf(key) !== -1;
|
||||
};
|
||||
|
||||
/**
|
||||
* @private
|
||||
* @memberOf Map#
|
||||
*/
|
||||
Map.prototype.getKeys = function () { return this.keys.slice(0); };
|
||||
|
||||
/**
|
||||
* @private
|
||||
* @memberOf Map#
|
||||
*/
|
||||
Map.prototype.getValues = function () { return this.values.slice(0); };
|
||||
|
||||
return Map;
|
||||
}());
|
||||
|
||||
/**
|
||||
* @constructor
|
||||
* Represents a join pattern over observable sequences.
|
||||
*/
|
||||
function Pattern(patterns) {
|
||||
this.patterns = patterns;
|
||||
}
|
||||
|
||||
/**
|
||||
* Creates a pattern that matches the current plan matches and when the specified observable sequences has an available value.
|
||||
*
|
||||
* @param other Observable sequence to match in addition to the current pattern.
|
||||
* @return Pattern object that matches when all observable sequences in the pattern have an available value.
|
||||
*/
|
||||
Pattern.prototype.and = function (other) {
|
||||
var patterns = this.patterns.slice(0);
|
||||
patterns.push(other);
|
||||
return new Pattern(patterns);
|
||||
};
|
||||
|
||||
/**
|
||||
* Matches when all observable sequences in the pattern (specified using a chain of and operators) have an available value and projects the values.
|
||||
*
|
||||
* @param selector Selector that will be invoked with available values from the source sequences, in the same order of the sequences in the pattern.
|
||||
* @return Plan that produces the projected values, to be fed (with other plans) to the when operator.
|
||||
*/
|
||||
Pattern.prototype.then = function (selector) {
|
||||
return new Plan(this, selector);
|
||||
};
|
||||
|
||||
// Plan
|
||||
function Plan(expression, selector) {
|
||||
this.expression = expression;
|
||||
this.selector = selector;
|
||||
}
|
||||
Plan.prototype.activate = function (externalSubscriptions, observer, deactivate) {
|
||||
var self = this;
|
||||
var joinObservers = [];
|
||||
for (var i = 0, len = this.expression.patterns.length; i < len; i++) {
|
||||
joinObservers.push(planCreateObserver(externalSubscriptions, this.expression.patterns[i], observer.onError.bind(observer)));
|
||||
}
|
||||
var activePlan = new ActivePlan(joinObservers, function () {
|
||||
var result;
|
||||
try {
|
||||
result = self.selector.apply(self, arguments);
|
||||
} catch (exception) {
|
||||
observer.onError(exception);
|
||||
return;
|
||||
}
|
||||
observer.onNext(result);
|
||||
}, function () {
|
||||
for (var j = 0, jlen = joinObservers.length; j < jlen; j++) {
|
||||
joinObservers[j].removeActivePlan(activePlan);
|
||||
}
|
||||
deactivate(activePlan);
|
||||
});
|
||||
for (i = 0, len = joinObservers.length; i < len; i++) {
|
||||
joinObservers[i].addActivePlan(activePlan);
|
||||
}
|
||||
return activePlan;
|
||||
};
|
||||
|
||||
function planCreateObserver(externalSubscriptions, observable, onError) {
|
||||
var entry = externalSubscriptions.get(observable);
|
||||
if (!entry) {
|
||||
var observer = new JoinObserver(observable, onError);
|
||||
externalSubscriptions.set(observable, observer);
|
||||
return observer;
|
||||
}
|
||||
return entry;
|
||||
}
|
||||
|
||||
// Active Plan
|
||||
function ActivePlan(joinObserverArray, onNext, onCompleted) {
|
||||
var i, joinObserver;
|
||||
this.joinObserverArray = joinObserverArray;
|
||||
this.onNext = onNext;
|
||||
this.onCompleted = onCompleted;
|
||||
this.joinObservers = new Map();
|
||||
for (i = 0; i < this.joinObserverArray.length; i++) {
|
||||
joinObserver = this.joinObserverArray[i];
|
||||
this.joinObservers.set(joinObserver, joinObserver);
|
||||
}
|
||||
}
|
||||
|
||||
ActivePlan.prototype.dequeue = function () {
|
||||
var values = this.joinObservers.getValues();
|
||||
for (var i = 0, len = values.length; i < len; i++) {
|
||||
values[i].queue.shift();
|
||||
}
|
||||
};
|
||||
ActivePlan.prototype.match = function () {
|
||||
var firstValues, i, len, isCompleted, values, hasValues = true;
|
||||
for (i = 0, len = this.joinObserverArray.length; i < len; i++) {
|
||||
if (this.joinObserverArray[i].queue.length === 0) {
|
||||
hasValues = false;
|
||||
break;
|
||||
}
|
||||
}
|
||||
if (hasValues) {
|
||||
firstValues = [];
|
||||
isCompleted = false;
|
||||
for (i = 0, len = this.joinObserverArray.length; i < len; i++) {
|
||||
firstValues.push(this.joinObserverArray[i].queue[0]);
|
||||
if (this.joinObserverArray[i].queue[0].kind === 'C') {
|
||||
isCompleted = true;
|
||||
}
|
||||
}
|
||||
if (isCompleted) {
|
||||
this.onCompleted();
|
||||
} else {
|
||||
this.dequeue();
|
||||
values = [];
|
||||
for (i = 0; i < firstValues.length; i++) {
|
||||
values.push(firstValues[i].value);
|
||||
}
|
||||
this.onNext.apply(this, values);
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
/** @private */
|
||||
var JoinObserver = (function (_super) {
|
||||
|
||||
inherits(JoinObserver, _super);
|
||||
|
||||
/**
|
||||
* @constructor
|
||||
* @private
|
||||
*/
|
||||
function JoinObserver(source, onError) {
|
||||
_super.call(this);
|
||||
this.source = source;
|
||||
this.onError = onError;
|
||||
this.queue = [];
|
||||
this.activePlans = [];
|
||||
this.subscription = new SingleAssignmentDisposable();
|
||||
this.isDisposed = false;
|
||||
}
|
||||
|
||||
var JoinObserverPrototype = JoinObserver.prototype;
|
||||
|
||||
/**
|
||||
* @memberOf JoinObserver#
|
||||
* @private
|
||||
*/
|
||||
JoinObserverPrototype.next = function (notification) {
|
||||
if (!this.isDisposed) {
|
||||
if (notification.kind === 'E') {
|
||||
this.onError(notification.exception);
|
||||
return;
|
||||
}
|
||||
this.queue.push(notification);
|
||||
var activePlans = this.activePlans.slice(0);
|
||||
for (var i = 0, len = activePlans.length; i < len; i++) {
|
||||
activePlans[i].match();
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
/**
|
||||
* @memberOf JoinObserver#
|
||||
* @private
|
||||
*/
|
||||
JoinObserverPrototype.error = noop;
|
||||
|
||||
/**
|
||||
* @memberOf JoinObserver#
|
||||
* @private
|
||||
*/
|
||||
JoinObserverPrototype.completed = noop;
|
||||
|
||||
/**
|
||||
* @memberOf JoinObserver#
|
||||
* @private
|
||||
*/
|
||||
JoinObserverPrototype.addActivePlan = function (activePlan) {
|
||||
this.activePlans.push(activePlan);
|
||||
};
|
||||
|
||||
/**
|
||||
* @memberOf JoinObserver#
|
||||
* @private
|
||||
*/
|
||||
JoinObserverPrototype.subscribe = function () {
|
||||
this.subscription.disposable(this.source.materialize().subscribe(this));
|
||||
};
|
||||
|
||||
/**
|
||||
* @memberOf JoinObserver#
|
||||
* @private
|
||||
*/
|
||||
JoinObserverPrototype.removeActivePlan = function (activePlan) {
|
||||
var idx = this.activePlans.indexOf(activePlan);
|
||||
this.activePlans.splice(idx, 1);
|
||||
if (this.activePlans.length === 0) {
|
||||
this.dispose();
|
||||
}
|
||||
};
|
||||
|
||||
/**
|
||||
* @memberOf JoinObserver#
|
||||
* @private
|
||||
*/
|
||||
JoinObserverPrototype.dispose = function () {
|
||||
_super.prototype.dispose.call(this);
|
||||
if (!this.isDisposed) {
|
||||
this.isDisposed = true;
|
||||
this.subscription.dispose();
|
||||
}
|
||||
};
|
||||
|
||||
return JoinObserver;
|
||||
} (AbstractObserver));
|
||||
|
||||
// Observable extensions
|
||||
|
||||
/**
|
||||
* Creates a pattern that matches when both observable sequences have an available value.
|
||||
*
|
||||
* @param right Observable sequence to match with the current sequence.
|
||||
* @return {Pattern} Pattern object that matches when both observable sequences have an available value.
|
||||
*/
|
||||
observableProto.and = function (right) {
|
||||
return new Pattern([this, right]);
|
||||
};
|
||||
|
||||
/**
|
||||
* Matches when the observable sequence has an available value and projects the value.
|
||||
*
|
||||
* @param selector Selector that will be invoked for values in the source sequence.
|
||||
* @returns {Plan} Plan that produces the projected values, to be fed (with other plans) to the when operator.
|
||||
*/
|
||||
observableProto.then = function (selector) {
|
||||
return new Pattern([this]).then(selector);
|
||||
};
|
||||
|
||||
/**
|
||||
* Joins together the results from several patterns.
|
||||
*
|
||||
* @param plans A series of plans (specified as an Array of as a series of arguments) created by use of the Then operator on patterns.
|
||||
* @returns {Observable} Observable sequence with the results form matching several patterns.
|
||||
*/
|
||||
Observable.when = function () {
|
||||
var plans = argsOrArray(arguments, 0);
|
||||
return new AnonymousObservable(function (observer) {
|
||||
var activePlans = [],
|
||||
externalSubscriptions = new Map(),
|
||||
group,
|
||||
i, len,
|
||||
joinObserver,
|
||||
joinValues,
|
||||
outObserver;
|
||||
outObserver = observerCreate(observer.onNext.bind(observer), function (exception) {
|
||||
var values = externalSubscriptions.getValues();
|
||||
for (var j = 0, jlen = values.length; j < jlen; j++) {
|
||||
values[j].onError(exception);
|
||||
}
|
||||
observer.onError(exception);
|
||||
}, observer.onCompleted.bind(observer));
|
||||
try {
|
||||
for (i = 0, len = plans.length; i < len; i++) {
|
||||
activePlans.push(plans[i].activate(externalSubscriptions, outObserver, function (activePlan) {
|
||||
var idx = activePlans.indexOf(activePlan);
|
||||
activePlans.splice(idx, 1);
|
||||
if (activePlans.length === 0) {
|
||||
outObserver.onCompleted();
|
||||
}
|
||||
}));
|
||||
}
|
||||
} catch (e) {
|
||||
observableThrow(e).subscribe(observer);
|
||||
}
|
||||
group = new CompositeDisposable();
|
||||
joinValues = externalSubscriptions.getValues();
|
||||
for (i = 0, len = joinValues.length; i < len; i++) {
|
||||
joinObserver = joinValues[i];
|
||||
joinObserver.subscribe();
|
||||
group.add(joinObserver);
|
||||
}
|
||||
return group;
|
||||
});
|
||||
};
|
||||
|
||||
return Rx;
|
||||
}));
|
||||
@@ -0,0 +1 @@
|
||||
(function(t,e){var n="object"==typeof exports&&exports,r=("object"==typeof module&&module&&module.exports==n&&module,"object"==typeof global&&global);r.global===r&&(window=r),"function"==typeof define&&define.amd?define(["rx","exports"],function(n,r){return t.Rx=e(t,r,n),t.Rx}):"object"==typeof module&&module&&module.exports===n?module.exports=e(t,module.exports,require("./rx")):t.Rx=e(t,{},t.Rx)})(this,function(t,e,n){function r(){}function i(t,e){return 1===t.length&&Array.isArray(t[e])?t[e]:y.call(t)}function o(t){this.patterns=t}function s(t,e){this.expression=t,this.selector=e}function u(t,e,n){var r=t.get(e);if(!r){var i=new g(e,n);return t.set(e,i),i}return r}function c(t,e,n){var r,i;for(this.joinObserverArray=t,this.onNext=e,this.onCompleted=n,this.joinObservers=new w,r=0;this.joinObserverArray.length>r;r++)i=this.joinObserverArray[r],this.joinObservers.set(i,i)}var a=n.Observable,h=a.prototype,l=n.Internals.AnonymousObservable,f=a.throwException,p=n.Observer.create,d=n.SingleAssignmentDisposable,b=n.CompositeDisposable,v=n.Internals.AbstractObserver;n.Internals.isEqual;var m=n.Internals.inherits,y=Array.prototype.slice,w=function(){function t(){this.keys=[],this.values=[]}return t.prototype["delete"]=function(t){var e=this.keys.indexOf(t);return-1!==e&&(this.keys.splice(e,1),this.values.splice(e,1)),-1!==e},t.prototype.get=function(t,e){var n=this.keys.indexOf(t);return-1!==n?this.values[n]:e},t.prototype.set=function(t,e){var n=this.keys.indexOf(t);-1!==n&&(this.values[n]=e),this.values[this.keys.push(t)-1]=e},t.prototype.size=function(){return this.keys.length},t.prototype.has=function(t){return-1!==this.keys.indexOf(t)},t.prototype.getKeys=function(){return this.keys.slice(0)},t.prototype.getValues=function(){return this.values.slice(0)},t}();o.prototype.and=function(t){var e=this.patterns.slice(0);return e.push(t),new o(e)},o.prototype.then=function(t){return new s(this,t)},s.prototype.activate=function(t,e,n){for(var r=this,i=[],o=0,s=this.expression.patterns.length;s>o;o++)i.push(u(t,this.expression.patterns[o],e.onError.bind(e)));var a=new c(i,function(){var t;try{t=r.selector.apply(r,arguments)}catch(n){return e.onError(n),undefined}e.onNext(t)},function(){for(var t=0,e=i.length;e>t;t++)i[t].removeActivePlan(a);n(a)});for(o=0,s=i.length;s>o;o++)i[o].addActivePlan(a);return a},c.prototype.dequeue=function(){for(var t=this.joinObservers.getValues(),e=0,n=t.length;n>e;e++)t[e].queue.shift()},c.prototype.match=function(){var t,e,n,r,i,o=!0;for(e=0,n=this.joinObserverArray.length;n>e;e++)if(0===this.joinObserverArray[e].queue.length){o=!1;break}if(o){for(t=[],r=!1,e=0,n=this.joinObserverArray.length;n>e;e++)t.push(this.joinObserverArray[e].queue[0]),"C"===this.joinObserverArray[e].queue[0].kind&&(r=!0);if(r)this.onCompleted();else{for(this.dequeue(),i=[],e=0;t.length>e;e++)i.push(t[e].value);this.onNext.apply(this,i)}}};var g=function(t){function e(e,n){t.call(this),this.source=e,this.onError=n,this.queue=[],this.activePlans=[],this.subscription=new d,this.isDisposed=!1}m(e,t);var n=e.prototype;return n.next=function(t){if(!this.isDisposed){if("E"===t.kind)return this.onError(t.exception),undefined;this.queue.push(t);for(var e=this.activePlans.slice(0),n=0,r=e.length;r>n;n++)e[n].match()}},n.error=r,n.completed=r,n.addActivePlan=function(t){this.activePlans.push(t)},n.subscribe=function(){this.subscription.disposable(this.source.materialize().subscribe(this))},n.removeActivePlan=function(t){var e=this.activePlans.indexOf(t);this.activePlans.splice(e,1),0===this.activePlans.length&&this.dispose()},n.dispose=function(){t.prototype.dispose.call(this),this.isDisposed||(this.isDisposed=!0,this.subscription.dispose())},e}(v);return h.and=function(t){return new o([this,t])},h.then=function(t){return new o([this]).then(t)},a.when=function(){var t=i(arguments,0);return new l(function(e){var n,r,i,o,s,u,c=[],a=new w;u=p(e.onNext.bind(e),function(t){for(var n=a.getValues(),r=0,i=n.length;i>r;r++)n[r].onError(t);e.onError(t)},e.onCompleted.bind(e));try{for(r=0,i=t.length;i>r;r++)c.push(t[r].activate(a,u,function(t){var e=c.indexOf(t);c.splice(e,1),0===c.length&&u.onCompleted()}))}catch(h){f(h).subscribe(e)}for(n=new b,s=a.getValues(),r=0,i=s.length;i>r;r++)o=s[r],o.subscribe(),n.add(o);return n})},n});
|
||||
File diff suppressed because it is too large
Load Diff
Vendored
+2
File diff suppressed because one or more lines are too long
File diff suppressed because it is too large
Load Diff
+2
File diff suppressed because one or more lines are too long
@@ -0,0 +1,9 @@
|
||||
var Rx = require('./rx');
|
||||
require('./rx.aggregates');
|
||||
require('./rx.binding');
|
||||
require('./rx.coincidence');
|
||||
require('./rx.experimental');
|
||||
require('./rx.joinpatterns');
|
||||
require('./rx.testing');
|
||||
require('./rx.time');
|
||||
module.exports = Rx;
|
||||
@@ -0,0 +1,487 @@
|
||||
// Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information.
|
||||
|
||||
(function (root, factory) {
|
||||
var freeExports = typeof exports == 'object' && exports,
|
||||
freeModule = typeof module == 'object' && module && module.exports == freeExports && module,
|
||||
freeGlobal = typeof global == 'object' && global;
|
||||
if (freeGlobal.global === freeGlobal) {
|
||||
window = freeGlobal;
|
||||
}
|
||||
|
||||
// Because of build optimizers
|
||||
if (typeof define === 'function' && define.amd) {
|
||||
define(['rx', 'exports'], function (Rx, exports) {
|
||||
root.Rx = factory(root, exports, Rx);
|
||||
return root.Rx;
|
||||
});
|
||||
} else if (typeof module === 'object' && module && module.exports === freeExports) {
|
||||
module.exports = factory(root, module.exports, require('./rx'));
|
||||
} else {
|
||||
root.Rx = factory(root, {}, root.Rx);
|
||||
}
|
||||
}(this, function (global, exp, Rx, undefined) {
|
||||
|
||||
// Defaults
|
||||
var Observer = Rx.Observer,
|
||||
Observable = Rx.Observable,
|
||||
Notification = Rx.Notification,
|
||||
VirtualTimeScheduler = Rx.VirtualTimeScheduler,
|
||||
Disposable = Rx.Disposable,
|
||||
disposableEmpty = Disposable.empty,
|
||||
disposableCreate = Disposable.create,
|
||||
CompositeDisposable = Rx.CompositeDisposable,
|
||||
SingleAssignmentDisposable = Rx.SingleAssignmentDisposable,
|
||||
slice = Array.prototype.slice,
|
||||
inherits = Rx.Internals.inherits,
|
||||
isEqual = Rx.Internals.isEqual;
|
||||
|
||||
// Utilities
|
||||
function defaultComparer(x, y) {
|
||||
return isEqual(x, y);
|
||||
}
|
||||
|
||||
function argsOrArray(args, idx) {
|
||||
return args.length === 1 && Array.isArray(args[idx]) ?
|
||||
args[idx] :
|
||||
slice.call(args);
|
||||
}
|
||||
|
||||
/**
|
||||
* @private
|
||||
* @constructor
|
||||
*/
|
||||
function OnNextPredicate(predicate) {
|
||||
this.predicate = predicate;
|
||||
};
|
||||
|
||||
/**
|
||||
* @private
|
||||
* @memberOf OnNextPredicate#
|
||||
*/
|
||||
OnNextPredicate.prototype.equals = function (other) {
|
||||
if (other === this) { return true; }
|
||||
if (other == null) { return false; }
|
||||
if (other.kind !== 'N') { return false; }
|
||||
return this.predicate(other.value);
|
||||
};
|
||||
|
||||
/**
|
||||
* @private
|
||||
* @constructor
|
||||
*/
|
||||
function OnErrorPredicate(predicate) {
|
||||
this.predicate = predicate;
|
||||
};
|
||||
|
||||
/**
|
||||
* @private
|
||||
* @memberOf OnErrorPredicate#
|
||||
*/
|
||||
OnErrorPredicate.prototype.equals = function (other) {
|
||||
if (other === this) { return true; }
|
||||
if (other == null) { return false; }
|
||||
if (other.kind !== 'E') { return false; }
|
||||
return this.predicate(other.exception);
|
||||
};
|
||||
|
||||
/**
|
||||
* @static
|
||||
* type Object
|
||||
*/
|
||||
var ReactiveTest = Rx.ReactiveTest = {
|
||||
/** Default virtual time used for creation of observable sequences in unit tests. */
|
||||
created: 100,
|
||||
/** Default virtual time used to subscribe to observable sequences in unit tests. */
|
||||
subscribed: 200,
|
||||
/** Default virtual time used to dispose subscriptions in <see cref="ReactiveTest"/>-based unit tests. */
|
||||
disposed: 1000,
|
||||
|
||||
/**
|
||||
* Factory method for an OnNext notification record at a given time with a given value or a predicate function.
|
||||
*
|
||||
* 1 - ReactiveTest.onNext(200, 42);
|
||||
* 2 - ReactiveTest.onNext(200, function (x) { return x.length == 2; });
|
||||
*
|
||||
* @param ticks Recorded virtual time the OnNext notification occurs.
|
||||
* @param value Recorded value stored in the OnNext notification or a predicate.
|
||||
* @return Recorded OnNext notification.
|
||||
*/
|
||||
onNext: function (ticks, value) {
|
||||
if (typeof value === 'function') {
|
||||
return new Recorded(ticks, new OnNextPredicate(value));
|
||||
}
|
||||
return new Recorded(ticks, Notification.createOnNext(value));
|
||||
},
|
||||
/**
|
||||
* Factory method for an OnError notification record at a given time with a given error.
|
||||
*
|
||||
* 1 - ReactiveTest.onNext(200, new Error('error'));
|
||||
* 2 - ReactiveTest.onNext(200, function (e) { return e.message === 'error'; });
|
||||
*
|
||||
* @param ticks Recorded virtual time the OnError notification occurs.
|
||||
* @param exception Recorded exception stored in the OnError notification.
|
||||
* @return Recorded OnError notification.
|
||||
*/
|
||||
onError: function (ticks, exception) {
|
||||
if (typeof exception === 'function') {
|
||||
return new Recorded(ticks, new OnErrorPredicate(exception));
|
||||
}
|
||||
return new Recorded(ticks, Notification.createOnError(exception));
|
||||
},
|
||||
/**
|
||||
* Factory method for an OnCompleted notification record at a given time.
|
||||
*
|
||||
* @param ticks Recorded virtual time the OnCompleted notification occurs.
|
||||
* @return Recorded OnCompleted notification.
|
||||
*/
|
||||
onCompleted: function (ticks) {
|
||||
return new Recorded(ticks, Notification.createOnCompleted());
|
||||
},
|
||||
/**
|
||||
* Factory method for a subscription record based on a given subscription and disposal time.
|
||||
*
|
||||
* @param start Virtual time indicating when the subscription was created.
|
||||
* @param end Virtual time indicating when the subscription was disposed.
|
||||
* @return Subscription object.
|
||||
*/
|
||||
subscribe: function (start, end) {
|
||||
return new Subscription(start, end);
|
||||
}
|
||||
};
|
||||
|
||||
/**
|
||||
* Creates a new object recording the production of the specified value at the given virtual time.
|
||||
*
|
||||
* @constructor
|
||||
* @param {Number} time Virtual time the value was produced on.
|
||||
* @param {Mixed} value Value that was produced.
|
||||
* @param {Function} comparer An optional comparer.
|
||||
*/
|
||||
var Recorded = Rx.Recorded = function (time, value, comparer) {
|
||||
this.time = time;
|
||||
this.value = value;
|
||||
this.comparer = comparer || defaultComparer;
|
||||
};
|
||||
|
||||
/**
|
||||
* Checks whether the given recorded object is equal to the current instance.
|
||||
*
|
||||
* @param {Recorded} other Recorded object to check for equality.
|
||||
* @returns {Boolean} true if both objects are equal; false otherwise.
|
||||
*/
|
||||
Recorded.prototype.equals = function (other) {
|
||||
return this.time === other.time && this.comparer(this.value, other.value);
|
||||
};
|
||||
|
||||
/**
|
||||
* Returns a string representation of the current Recorded value.
|
||||
*
|
||||
* @returns {String} String representation of the current Recorded value.
|
||||
*/
|
||||
Recorded.prototype.toString = function () {
|
||||
return this.value.toString() + '@' + this.time;
|
||||
};
|
||||
|
||||
/**
|
||||
* Creates a new subscription object with the given virtual subscription and unsubscription time.
|
||||
*
|
||||
* @constructor
|
||||
* @param {Number} subscribe Virtual time at which the subscription occurred.
|
||||
* @param {Number} unsubscribe Virtual time at which the unsubscription occurred.
|
||||
*/
|
||||
var Subscription = Rx.Subscription = function (start, end) {
|
||||
this.subscribe = start;
|
||||
this.unsubscribe = end || Number.MAX_VALUE;
|
||||
};
|
||||
|
||||
/**
|
||||
* Checks whether the given subscription is equal to the current instance.
|
||||
* @param other Subscription object to check for equality.
|
||||
* @returns {Boolean} true if both objects are equal; false otherwise.
|
||||
*/
|
||||
Subscription.prototype.equals = function (other) {
|
||||
return this.subscribe === other.subscribe && this.unsubscribe === other.unsubscribe;
|
||||
};
|
||||
|
||||
/**
|
||||
* Returns a string representation of the current Subscription value.
|
||||
* @returns {String} String representation of the current Subscription value.
|
||||
*/
|
||||
Subscription.prototype.toString = function () {
|
||||
return '(' + this.subscribe + ', ' + this.unsubscribe === Number.MAX_VALUE ? 'Infinite' : this.unsubscribe + ')';
|
||||
};
|
||||
|
||||
/** @private */
|
||||
var MockDisposable = Rx.MockDisposable = function (scheduler) {
|
||||
this.scheduler = scheduler;
|
||||
this.disposes = [];
|
||||
this.disposes.push(this.scheduler.clock);
|
||||
};
|
||||
|
||||
/*
|
||||
* @memberOf MockDisposable#
|
||||
* @prviate
|
||||
*/
|
||||
MockDisposable.prototype.dispose = function () {
|
||||
this.disposes.push(this.scheduler.clock);
|
||||
};
|
||||
|
||||
/** @private */
|
||||
var MockObserver = (function (_super) {
|
||||
inherits(MockObserver, _super);
|
||||
|
||||
/*
|
||||
* @constructor
|
||||
* @prviate
|
||||
*/
|
||||
function MockObserver(scheduler) {
|
||||
_super.call(this);
|
||||
this.scheduler = scheduler;
|
||||
this.messages = [];
|
||||
}
|
||||
|
||||
var MockObserverPrototype = MockObserver.prototype;
|
||||
|
||||
/*
|
||||
* @memberOf MockObserverPrototype#
|
||||
* @prviate
|
||||
*/
|
||||
MockObserverPrototype.onNext = function (value) {
|
||||
this.messages.push(new Recorded(this.scheduler.clock, Notification.createOnNext(value)));
|
||||
};
|
||||
|
||||
/*
|
||||
* @memberOf MockObserverPrototype#
|
||||
* @prviate
|
||||
*/
|
||||
MockObserverPrototype.onError = function (exception) {
|
||||
this.messages.push(new Recorded(this.scheduler.clock, Notification.createOnError(exception)));
|
||||
};
|
||||
|
||||
/*
|
||||
* @memberOf MockObserverPrototype#
|
||||
* @prviate
|
||||
*/
|
||||
MockObserverPrototype.onCompleted = function () {
|
||||
this.messages.push(new Recorded(this.scheduler.clock, Notification.createOnCompleted()));
|
||||
};
|
||||
|
||||
return MockObserver;
|
||||
})(Observer);
|
||||
|
||||
/** @private */
|
||||
var HotObservable = (function (_super) {
|
||||
|
||||
function subscribe(observer) {
|
||||
var observable = this;
|
||||
this.observers.push(observer);
|
||||
this.subscriptions.push(new Subscription(this.scheduler.clock));
|
||||
var index = this.subscriptions.length - 1;
|
||||
return disposableCreate(function () {
|
||||
var idx = observable.observers.indexOf(observer);
|
||||
observable.observers.splice(idx, 1);
|
||||
observable.subscriptions[index] = new Subscription(observable.subscriptions[index].subscribe, observable.scheduler.clock);
|
||||
});
|
||||
}
|
||||
|
||||
inherits(HotObservable, _super);
|
||||
|
||||
/**
|
||||
* @private
|
||||
* @constructor
|
||||
*/
|
||||
function HotObservable(scheduler, messages) {
|
||||
_super.call(this, subscribe);
|
||||
var message, notification, observable = this;
|
||||
this.scheduler = scheduler;
|
||||
this.messages = messages;
|
||||
this.subscriptions = [];
|
||||
this.observers = [];
|
||||
for (var i = 0, len = this.messages.length; i < len; i++) {
|
||||
message = this.messages[i];
|
||||
notification = message.value;
|
||||
(function (innerNotification) {
|
||||
scheduler.scheduleAbsoluteWithState(null, message.time, function () {
|
||||
for (var j = 0; j < observable.observers.length; j++) {
|
||||
innerNotification.accept(observable.observers[j]);
|
||||
}
|
||||
return disposableEmpty;
|
||||
});
|
||||
})(notification);
|
||||
}
|
||||
}
|
||||
|
||||
return HotObservable;
|
||||
})(Observable);
|
||||
|
||||
/** @private */
|
||||
var ColdObservable = (function (_super) {
|
||||
|
||||
function subscribe(observer) {
|
||||
var message, notification, observable = this;
|
||||
this.subscriptions.push(new Subscription(this.scheduler.clock));
|
||||
var index = this.subscriptions.length - 1;
|
||||
var d = new CompositeDisposable();
|
||||
for (var i = 0, len = this.messages.length; i < len; i++) {
|
||||
message = this.messages[i];
|
||||
notification = message.value;
|
||||
(function (innerNotification) {
|
||||
d.add(observable.scheduler.scheduleRelativeWithState(null, message.time, function () {
|
||||
innerNotification.accept(observer);
|
||||
return disposableEmpty;
|
||||
}));
|
||||
})(notification);
|
||||
}
|
||||
return disposableCreate(function () {
|
||||
observable.subscriptions[index] = new Subscription(observable.subscriptions[index].subscribe, observable.scheduler.clock);
|
||||
d.dispose();
|
||||
});
|
||||
}
|
||||
|
||||
inherits(ColdObservable, _super);
|
||||
|
||||
/**
|
||||
* @private
|
||||
* @constructor
|
||||
*/
|
||||
function ColdObservable(scheduler, messages) {
|
||||
_super.call(this, subscribe);
|
||||
this.scheduler = scheduler;
|
||||
this.messages = messages;
|
||||
this.subscriptions = [];
|
||||
}
|
||||
|
||||
return ColdObservable;
|
||||
})(Observable);
|
||||
|
||||
/** Virtual time scheduler used for testing applications and libraries built using Reactive Extensions. */
|
||||
Rx.TestScheduler = (function (_super) {
|
||||
inherits(TestScheduler, _super);
|
||||
|
||||
/** @constructor */
|
||||
function TestScheduler() {
|
||||
_super.call(this, 0, function (a, b) { return a - b; });
|
||||
}
|
||||
|
||||
/**
|
||||
* Schedules an action to be executed at the specified virtual time.
|
||||
*
|
||||
* @param state State passed to the action to be executed.
|
||||
* @param dueTime Absolute virtual time at which to execute the action.
|
||||
* @param action Action to be executed.
|
||||
* @return Disposable object used to cancel the scheduled action (best effort).
|
||||
*/
|
||||
TestScheduler.prototype.scheduleAbsoluteWithState = function (state, dueTime, action) {
|
||||
if (dueTime <= this.clock) {
|
||||
dueTime = this.clock + 1;
|
||||
}
|
||||
return _super.prototype.scheduleAbsoluteWithState.call(this, state, dueTime, action);
|
||||
};
|
||||
/**
|
||||
* Adds a relative virtual time to an absolute virtual time value.
|
||||
*
|
||||
* @param absolute Absolute virtual time value.
|
||||
* @param relative Relative virtual time value to add.
|
||||
* @return Resulting absolute virtual time sum value.
|
||||
*/
|
||||
TestScheduler.prototype.add = function (absolute, relative) {
|
||||
return absolute + relative;
|
||||
};
|
||||
/**
|
||||
* Converts the absolute virtual time value to a DateTimeOffset value.
|
||||
*
|
||||
* @param absolute Absolute virtual time value to convert.
|
||||
* @return Corresponding DateTimeOffset value.
|
||||
*/
|
||||
TestScheduler.prototype.toDateTimeOffset = function (absolute) {
|
||||
return new Date(absolute).getTime();
|
||||
};
|
||||
/**
|
||||
* Converts the TimeSpan value to a relative virtual time value.
|
||||
*
|
||||
* @param timeSpan TimeSpan value to convert.
|
||||
* @return Corresponding relative virtual time value.
|
||||
*/
|
||||
TestScheduler.prototype.toRelative = function (timeSpan) {
|
||||
return timeSpan;
|
||||
};
|
||||
/**
|
||||
* Starts the test scheduler and uses the specified virtual times to invoke the factory function, subscribe to the resulting sequence, and dispose the subscription.
|
||||
*
|
||||
* @param create Factory method to create an observable sequence.
|
||||
* @param created Virtual time at which to invoke the factory to create an observable sequence.
|
||||
* @param subscribed Virtual time at which to subscribe to the created observable sequence.
|
||||
* @param disposed Virtual time at which to dispose the subscription.
|
||||
* @return Observer with timestamped recordings of notification messages that were received during the virtual time window when the subscription to the source sequence was active.
|
||||
*/
|
||||
TestScheduler.prototype.startWithTiming = function (create, created, subscribed, disposed) {
|
||||
var observer = this.createObserver(), source, subscription;
|
||||
this.scheduleAbsoluteWithState(null, created, function () {
|
||||
source = create();
|
||||
return disposableEmpty;
|
||||
});
|
||||
this.scheduleAbsoluteWithState(null, subscribed, function () {
|
||||
subscription = source.subscribe(observer);
|
||||
return disposableEmpty;
|
||||
});
|
||||
this.scheduleAbsoluteWithState(null, disposed, function () {
|
||||
subscription.dispose();
|
||||
return disposableEmpty;
|
||||
});
|
||||
this.start();
|
||||
return observer;
|
||||
};
|
||||
/**
|
||||
* Starts the test scheduler and uses the specified virtual time to dispose the subscription to the sequence obtained through the factory function.
|
||||
* Default virtual times are used for factory invocation and sequence subscription.
|
||||
*
|
||||
* @param create Factory method to create an observable sequence.
|
||||
* @param disposed Virtual time at which to dispose the subscription.
|
||||
* @return Observer with timestamped recordings of notification messages that were received during the virtual time window when the subscription to the source sequence was active.
|
||||
*/
|
||||
TestScheduler.prototype.startWithDispose = function (create, disposed) {
|
||||
return this.startWithTiming(create, ReactiveTest.created, ReactiveTest.subscribed, disposed);
|
||||
};
|
||||
/**
|
||||
* Starts the test scheduler and uses default virtual times to invoke the factory function, to subscribe to the resulting sequence, and to dispose the subscription</see>.
|
||||
*
|
||||
* @param create Factory method to create an observable sequence.
|
||||
* @return Observer with timestamped recordings of notification messages that were received during the virtual time window when the subscription to the source sequence was active.
|
||||
*/
|
||||
TestScheduler.prototype.startWithCreate = function (create) {
|
||||
return this.startWithTiming(create, ReactiveTest.created, ReactiveTest.subscribed, ReactiveTest.disposed);
|
||||
};
|
||||
/**
|
||||
* Creates a hot observable using the specified timestamped notification messages either as an array or arguments.
|
||||
*
|
||||
* @param messages Notifications to surface through the created sequence at their specified absolute virtual times.
|
||||
* @return Hot observable sequence that can be used to assert the timing of subscriptions and notifications.
|
||||
*/
|
||||
TestScheduler.prototype.createHotObservable = function () {
|
||||
var messages = argsOrArray(arguments, 0);
|
||||
return new HotObservable(this, messages);
|
||||
};
|
||||
/**
|
||||
* Creates a cold observable using the specified timestamped notification messages either as an array or arguments.
|
||||
*
|
||||
* @param messages Notifications to surface through the created sequence at their specified virtual time offsets from the sequence subscription time.
|
||||
* @return Cold observable sequence that can be used to assert the timing of subscriptions and notifications.
|
||||
*/
|
||||
TestScheduler.prototype.createColdObservable = function () {
|
||||
var messages = argsOrArray(arguments, 0);
|
||||
return new ColdObservable(this, messages);
|
||||
};
|
||||
/**
|
||||
* Creates an observer that records received notification messages and timestamps those.
|
||||
*
|
||||
* @return Observer that can be used to assert the timing of received notifications.
|
||||
*/
|
||||
TestScheduler.prototype.createObserver = function () {
|
||||
return new MockObserver(this);
|
||||
};
|
||||
|
||||
return TestScheduler;
|
||||
})(VirtualTimeScheduler);
|
||||
|
||||
return Rx;
|
||||
}));
|
||||
+1
@@ -0,0 +1 @@
|
||||
(function(t,e){var n="object"==typeof exports&&exports,r=("object"==typeof module&&module&&module.exports==n&&module,"object"==typeof global&&global);r.global===r&&(window=r),"function"==typeof define&&define.amd?define(["rx","exports"],function(n,r){return t.Rx=e(t,r,n),t.Rx}):"object"==typeof module&&module&&module.exports===n?module.exports=e(t,module.exports,require("./rx")):t.Rx=e(t,{},t.Rx)})(this,function(t,e,n){function r(t,e){return m(t,e)}function i(t,e){return 1===t.length&&Array.isArray(t[e])?t[e]:b.call(t)}function o(t){this.predicate=t}function s(t){this.predicate=t}var u=n.Observer,c=n.Observable,a=n.Notification,h=n.VirtualTimeScheduler,l=n.Disposable,f=l.empty,p=l.create,d=n.CompositeDisposable,b=(n.SingleAssignmentDisposable,Array.prototype.slice),v=n.Internals.inherits,m=n.Internals.isEqual;o.prototype.equals=function(t){return t===this?!0:null==t?!1:"N"!==t.kind?!1:this.predicate(t.value)},s.prototype.equals=function(t){return t===this?!0:null==t?!1:"E"!==t.kind?!1:this.predicate(t.exception)};var y=n.ReactiveTest={created:100,subscribed:200,disposed:1e3,onNext:function(t,e){return"function"==typeof e?new w(t,new o(e)):new w(t,a.createOnNext(e))},onError:function(t,e){return"function"==typeof e?new w(t,new s(e)):new w(t,a.createOnError(e))},onCompleted:function(t){return new w(t,a.createOnCompleted())},subscribe:function(t,e){return new g(t,e)}},w=n.Recorded=function(t,e,n){this.time=t,this.value=e,this.comparer=n||r};w.prototype.equals=function(t){return this.time===t.time&&this.comparer(this.value,t.value)},w.prototype.toString=function(){return""+this.value+"@"+this.time};var g=n.Subscription=function(t,e){this.subscribe=t,this.unsubscribe=e||Number.MAX_VALUE};g.prototype.equals=function(t){return this.subscribe===t.subscribe&&this.unsubscribe===t.unsubscribe},g.prototype.toString=function(){return"("+this.subscribe+", "+this.unsubscribe===Number.MAX_VALUE?"Infinite":this.unsubscribe+")"};var E=n.MockDisposable=function(t){this.scheduler=t,this.disposes=[],this.disposes.push(this.scheduler.clock)};E.prototype.dispose=function(){this.disposes.push(this.scheduler.clock)};var x=function(t){function e(e){t.call(this),this.scheduler=e,this.messages=[]}v(e,t);var n=e.prototype;return n.onNext=function(t){this.messages.push(new w(this.scheduler.clock,a.createOnNext(t)))},n.onError=function(t){this.messages.push(new w(this.scheduler.clock,a.createOnError(t)))},n.onCompleted=function(){this.messages.push(new w(this.scheduler.clock,a.createOnCompleted()))},e}(u),C=function(t){function e(t){var e=this;this.observers.push(t),this.subscriptions.push(new g(this.scheduler.clock));var n=this.subscriptions.length-1;return p(function(){var r=e.observers.indexOf(t);e.observers.splice(r,1),e.subscriptions[n]=new g(e.subscriptions[n].subscribe,e.scheduler.clock)})}function n(n,r){t.call(this,e);var i,o,s=this;this.scheduler=n,this.messages=r,this.subscriptions=[],this.observers=[];for(var u=0,c=this.messages.length;c>u;u++)i=this.messages[u],o=i.value,function(t){n.scheduleAbsoluteWithState(null,i.time,function(){for(var e=0;s.observers.length>e;e++)t.accept(s.observers[e]);return f})}(o)}return v(n,t),n}(c),D=function(t){function e(t){var e,n,r=this;this.subscriptions.push(new g(this.scheduler.clock));for(var i=this.subscriptions.length-1,o=new d,s=0,u=this.messages.length;u>s;s++)e=this.messages[s],n=e.value,function(n){o.add(r.scheduler.scheduleRelativeWithState(null,e.time,function(){return n.accept(t),f}))}(n);return p(function(){r.subscriptions[i]=new g(r.subscriptions[i].subscribe,r.scheduler.clock),o.dispose()})}function n(n,r){t.call(this,e),this.scheduler=n,this.messages=r,this.subscriptions=[]}return v(n,t),n}(c);return n.TestScheduler=function(t){function e(){t.call(this,0,function(t,e){return t-e})}return v(e,t),e.prototype.scheduleAbsoluteWithState=function(e,n,r){return this.clock>=n&&(n=this.clock+1),t.prototype.scheduleAbsoluteWithState.call(this,e,n,r)},e.prototype.add=function(t,e){return t+e},e.prototype.toDateTimeOffset=function(t){return new Date(t).getTime()},e.prototype.toRelative=function(t){return t},e.prototype.startWithTiming=function(t,e,n,r){var i,o,s=this.createObserver();return this.scheduleAbsoluteWithState(null,e,function(){return i=t(),f}),this.scheduleAbsoluteWithState(null,n,function(){return o=i.subscribe(s),f}),this.scheduleAbsoluteWithState(null,r,function(){return o.dispose(),f}),this.start(),s},e.prototype.startWithDispose=function(t,e){return this.startWithTiming(t,y.created,y.subscribed,e)},e.prototype.startWithCreate=function(t){return this.startWithTiming(t,y.created,y.subscribed,y.disposed)},e.prototype.createHotObservable=function(){var t=i(arguments,0);return new C(this,t)},e.prototype.createColdObservable=function(){var t=i(arguments,0);return new D(this,t)},e.prototype.createObserver=function(){return new x(this)},e}(h),n});
|
||||
File diff suppressed because it is too large
Load Diff
Vendored
+1
File diff suppressed because one or more lines are too long
@@ -3,7 +3,7 @@
|
||||
"filename": "rx.min.js",
|
||||
"title": "Reactive Extensions for JavaScript (RxJS)",
|
||||
"description": "Library for composing asynchronous and event-based operations in JavaScript",
|
||||
"version": "2.1.11",
|
||||
"version": "2.1.15",
|
||||
"homepage": "http://rx.codeplex.com",
|
||||
"author": {
|
||||
"name": "Cloud Programmability Team",
|
||||
|
||||
Reference in New Issue
Block a user