You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
577 lines
15 KiB
577 lines
15 KiB
4 months ago
|
function _createForOfIteratorHelperLoose(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (it) return (it = it.call(o)).next.bind(it); if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; return function () { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
|
||
|
|
||
|
function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
|
||
|
|
||
|
function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
|
||
|
|
||
|
function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
|
||
|
|
||
|
function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
|
||
|
|
||
|
// === Symbol Support ===
|
||
|
var hasSymbols = function () {
|
||
|
return typeof Symbol === 'function';
|
||
|
};
|
||
|
|
||
|
var hasSymbol = function (name) {
|
||
|
return hasSymbols() && Boolean(Symbol[name]);
|
||
|
};
|
||
|
|
||
|
var getSymbol = function (name) {
|
||
|
return hasSymbol(name) ? Symbol[name] : '@@' + name;
|
||
|
};
|
||
|
|
||
|
if (hasSymbols() && !hasSymbol('observable')) {
|
||
|
Symbol.observable = Symbol('observable');
|
||
|
}
|
||
|
|
||
|
var SymbolIterator = getSymbol('iterator');
|
||
|
var SymbolObservable = getSymbol('observable');
|
||
|
var SymbolSpecies = getSymbol('species'); // === Abstract Operations ===
|
||
|
|
||
|
function getMethod(obj, key) {
|
||
|
var value = obj[key];
|
||
|
if (value == null) return undefined;
|
||
|
if (typeof value !== 'function') throw new TypeError(value + ' is not a function');
|
||
|
return value;
|
||
|
}
|
||
|
|
||
|
function getSpecies(obj) {
|
||
|
var ctor = obj.constructor;
|
||
|
|
||
|
if (ctor !== undefined) {
|
||
|
ctor = ctor[SymbolSpecies];
|
||
|
|
||
|
if (ctor === null) {
|
||
|
ctor = undefined;
|
||
|
}
|
||
|
}
|
||
|
|
||
|
return ctor !== undefined ? ctor : Observable;
|
||
|
}
|
||
|
|
||
|
function isObservable(x) {
|
||
|
return x instanceof Observable; // SPEC: Brand check
|
||
|
}
|
||
|
|
||
|
function hostReportError(e) {
|
||
|
if (hostReportError.log) {
|
||
|
hostReportError.log(e);
|
||
|
} else {
|
||
|
setTimeout(function () {
|
||
|
throw e;
|
||
|
});
|
||
|
}
|
||
|
}
|
||
|
|
||
|
function enqueue(fn) {
|
||
|
Promise.resolve().then(function () {
|
||
|
try {
|
||
|
fn();
|
||
|
} catch (e) {
|
||
|
hostReportError(e);
|
||
|
}
|
||
|
});
|
||
|
}
|
||
|
|
||
|
function cleanupSubscription(subscription) {
|
||
|
var cleanup = subscription._cleanup;
|
||
|
if (cleanup === undefined) return;
|
||
|
subscription._cleanup = undefined;
|
||
|
|
||
|
if (!cleanup) {
|
||
|
return;
|
||
|
}
|
||
|
|
||
|
try {
|
||
|
if (typeof cleanup === 'function') {
|
||
|
cleanup();
|
||
|
} else {
|
||
|
var unsubscribe = getMethod(cleanup, 'unsubscribe');
|
||
|
|
||
|
if (unsubscribe) {
|
||
|
unsubscribe.call(cleanup);
|
||
|
}
|
||
|
}
|
||
|
} catch (e) {
|
||
|
hostReportError(e);
|
||
|
}
|
||
|
}
|
||
|
|
||
|
function closeSubscription(subscription) {
|
||
|
subscription._observer = undefined;
|
||
|
subscription._queue = undefined;
|
||
|
subscription._state = 'closed';
|
||
|
}
|
||
|
|
||
|
function flushSubscription(subscription) {
|
||
|
var queue = subscription._queue;
|
||
|
|
||
|
if (!queue) {
|
||
|
return;
|
||
|
}
|
||
|
|
||
|
subscription._queue = undefined;
|
||
|
subscription._state = 'ready';
|
||
|
|
||
|
for (var i = 0; i < queue.length; ++i) {
|
||
|
notifySubscription(subscription, queue[i].type, queue[i].value);
|
||
|
if (subscription._state === 'closed') break;
|
||
|
}
|
||
|
}
|
||
|
|
||
|
function notifySubscription(subscription, type, value) {
|
||
|
subscription._state = 'running';
|
||
|
var observer = subscription._observer;
|
||
|
|
||
|
try {
|
||
|
var m = getMethod(observer, type);
|
||
|
|
||
|
switch (type) {
|
||
|
case 'next':
|
||
|
if (m) m.call(observer, value);
|
||
|
break;
|
||
|
|
||
|
case 'error':
|
||
|
closeSubscription(subscription);
|
||
|
if (m) m.call(observer, value);else throw value;
|
||
|
break;
|
||
|
|
||
|
case 'complete':
|
||
|
closeSubscription(subscription);
|
||
|
if (m) m.call(observer);
|
||
|
break;
|
||
|
}
|
||
|
} catch (e) {
|
||
|
hostReportError(e);
|
||
|
}
|
||
|
|
||
|
if (subscription._state === 'closed') cleanupSubscription(subscription);else if (subscription._state === 'running') subscription._state = 'ready';
|
||
|
}
|
||
|
|
||
|
function onNotify(subscription, type, value) {
|
||
|
if (subscription._state === 'closed') return;
|
||
|
|
||
|
if (subscription._state === 'buffering') {
|
||
|
subscription._queue.push({
|
||
|
type: type,
|
||
|
value: value
|
||
|
});
|
||
|
|
||
|
return;
|
||
|
}
|
||
|
|
||
|
if (subscription._state !== 'ready') {
|
||
|
subscription._state = 'buffering';
|
||
|
subscription._queue = [{
|
||
|
type: type,
|
||
|
value: value
|
||
|
}];
|
||
|
enqueue(function () {
|
||
|
return flushSubscription(subscription);
|
||
|
});
|
||
|
return;
|
||
|
}
|
||
|
|
||
|
notifySubscription(subscription, type, value);
|
||
|
}
|
||
|
|
||
|
var Subscription = /*#__PURE__*/function () {
|
||
|
function Subscription(observer, subscriber) {
|
||
|
// ASSERT: observer is an object
|
||
|
// ASSERT: subscriber is callable
|
||
|
this._cleanup = undefined;
|
||
|
this._observer = observer;
|
||
|
this._queue = undefined;
|
||
|
this._state = 'initializing';
|
||
|
var subscriptionObserver = new SubscriptionObserver(this);
|
||
|
|
||
|
try {
|
||
|
this._cleanup = subscriber.call(undefined, subscriptionObserver);
|
||
|
} catch (e) {
|
||
|
subscriptionObserver.error(e);
|
||
|
}
|
||
|
|
||
|
if (this._state === 'initializing') this._state = 'ready';
|
||
|
}
|
||
|
|
||
|
var _proto = Subscription.prototype;
|
||
|
|
||
|
_proto.unsubscribe = function unsubscribe() {
|
||
|
if (this._state !== 'closed') {
|
||
|
closeSubscription(this);
|
||
|
cleanupSubscription(this);
|
||
|
}
|
||
|
};
|
||
|
|
||
|
_createClass(Subscription, [{
|
||
|
key: "closed",
|
||
|
get: function () {
|
||
|
return this._state === 'closed';
|
||
|
}
|
||
|
}]);
|
||
|
|
||
|
return Subscription;
|
||
|
}();
|
||
|
|
||
|
var SubscriptionObserver = /*#__PURE__*/function () {
|
||
|
function SubscriptionObserver(subscription) {
|
||
|
this._subscription = subscription;
|
||
|
}
|
||
|
|
||
|
var _proto2 = SubscriptionObserver.prototype;
|
||
|
|
||
|
_proto2.next = function next(value) {
|
||
|
onNotify(this._subscription, 'next', value);
|
||
|
};
|
||
|
|
||
|
_proto2.error = function error(value) {
|
||
|
onNotify(this._subscription, 'error', value);
|
||
|
};
|
||
|
|
||
|
_proto2.complete = function complete() {
|
||
|
onNotify(this._subscription, 'complete');
|
||
|
};
|
||
|
|
||
|
_createClass(SubscriptionObserver, [{
|
||
|
key: "closed",
|
||
|
get: function () {
|
||
|
return this._subscription._state === 'closed';
|
||
|
}
|
||
|
}]);
|
||
|
|
||
|
return SubscriptionObserver;
|
||
|
}();
|
||
|
|
||
|
var Observable = /*#__PURE__*/function () {
|
||
|
function Observable(subscriber) {
|
||
|
if (!(this instanceof Observable)) throw new TypeError('Observable cannot be called as a function');
|
||
|
if (typeof subscriber !== 'function') throw new TypeError('Observable initializer must be a function');
|
||
|
this._subscriber = subscriber;
|
||
|
}
|
||
|
|
||
|
var _proto3 = Observable.prototype;
|
||
|
|
||
|
_proto3.subscribe = function subscribe(observer) {
|
||
|
if (typeof observer !== 'object' || observer === null) {
|
||
|
observer = {
|
||
|
next: observer,
|
||
|
error: arguments[1],
|
||
|
complete: arguments[2]
|
||
|
};
|
||
|
}
|
||
|
|
||
|
return new Subscription(observer, this._subscriber);
|
||
|
};
|
||
|
|
||
|
_proto3.forEach = function forEach(fn) {
|
||
|
var _this = this;
|
||
|
|
||
|
return new Promise(function (resolve, reject) {
|
||
|
if (typeof fn !== 'function') {
|
||
|
reject(new TypeError(fn + ' is not a function'));
|
||
|
return;
|
||
|
}
|
||
|
|
||
|
function done() {
|
||
|
subscription.unsubscribe();
|
||
|
resolve();
|
||
|
}
|
||
|
|
||
|
var subscription = _this.subscribe({
|
||
|
next: function (value) {
|
||
|
try {
|
||
|
fn(value, done);
|
||
|
} catch (e) {
|
||
|
reject(e);
|
||
|
subscription.unsubscribe();
|
||
|
}
|
||
|
},
|
||
|
error: reject,
|
||
|
complete: resolve
|
||
|
});
|
||
|
});
|
||
|
};
|
||
|
|
||
|
_proto3.map = function map(fn) {
|
||
|
var _this2 = this;
|
||
|
|
||
|
if (typeof fn !== 'function') throw new TypeError(fn + ' is not a function');
|
||
|
var C = getSpecies(this);
|
||
|
return new C(function (observer) {
|
||
|
return _this2.subscribe({
|
||
|
next: function (value) {
|
||
|
try {
|
||
|
value = fn(value);
|
||
|
} catch (e) {
|
||
|
return observer.error(e);
|
||
|
}
|
||
|
|
||
|
observer.next(value);
|
||
|
},
|
||
|
error: function (e) {
|
||
|
observer.error(e);
|
||
|
},
|
||
|
complete: function () {
|
||
|
observer.complete();
|
||
|
}
|
||
|
});
|
||
|
});
|
||
|
};
|
||
|
|
||
|
_proto3.filter = function filter(fn) {
|
||
|
var _this3 = this;
|
||
|
|
||
|
if (typeof fn !== 'function') throw new TypeError(fn + ' is not a function');
|
||
|
var C = getSpecies(this);
|
||
|
return new C(function (observer) {
|
||
|
return _this3.subscribe({
|
||
|
next: function (value) {
|
||
|
try {
|
||
|
if (!fn(value)) return;
|
||
|
} catch (e) {
|
||
|
return observer.error(e);
|
||
|
}
|
||
|
|
||
|
observer.next(value);
|
||
|
},
|
||
|
error: function (e) {
|
||
|
observer.error(e);
|
||
|
},
|
||
|
complete: function () {
|
||
|
observer.complete();
|
||
|
}
|
||
|
});
|
||
|
});
|
||
|
};
|
||
|
|
||
|
_proto3.reduce = function reduce(fn) {
|
||
|
var _this4 = this;
|
||
|
|
||
|
if (typeof fn !== 'function') throw new TypeError(fn + ' is not a function');
|
||
|
var C = getSpecies(this);
|
||
|
var hasSeed = arguments.length > 1;
|
||
|
var hasValue = false;
|
||
|
var seed = arguments[1];
|
||
|
var acc = seed;
|
||
|
return new C(function (observer) {
|
||
|
return _this4.subscribe({
|
||
|
next: function (value) {
|
||
|
var first = !hasValue;
|
||
|
hasValue = true;
|
||
|
|
||
|
if (!first || hasSeed) {
|
||
|
try {
|
||
|
acc = fn(acc, value);
|
||
|
} catch (e) {
|
||
|
return observer.error(e);
|
||
|
}
|
||
|
} else {
|
||
|
acc = value;
|
||
|
}
|
||
|
},
|
||
|
error: function (e) {
|
||
|
observer.error(e);
|
||
|
},
|
||
|
complete: function () {
|
||
|
if (!hasValue && !hasSeed) return observer.error(new TypeError('Cannot reduce an empty sequence'));
|
||
|
observer.next(acc);
|
||
|
observer.complete();
|
||
|
}
|
||
|
});
|
||
|
});
|
||
|
};
|
||
|
|
||
|
_proto3.concat = function concat() {
|
||
|
var _this5 = this;
|
||
|
|
||
|
for (var _len = arguments.length, sources = new Array(_len), _key = 0; _key < _len; _key++) {
|
||
|
sources[_key] = arguments[_key];
|
||
|
}
|
||
|
|
||
|
var C = getSpecies(this);
|
||
|
return new C(function (observer) {
|
||
|
var subscription;
|
||
|
var index = 0;
|
||
|
|
||
|
function startNext(next) {
|
||
|
subscription = next.subscribe({
|
||
|
next: function (v) {
|
||
|
observer.next(v);
|
||
|
},
|
||
|
error: function (e) {
|
||
|
observer.error(e);
|
||
|
},
|
||
|
complete: function () {
|
||
|
if (index === sources.length) {
|
||
|
subscription = undefined;
|
||
|
observer.complete();
|
||
|
} else {
|
||
|
startNext(C.from(sources[index++]));
|
||
|
}
|
||
|
}
|
||
|
});
|
||
|
}
|
||
|
|
||
|
startNext(_this5);
|
||
|
return function () {
|
||
|
if (subscription) {
|
||
|
subscription.unsubscribe();
|
||
|
subscription = undefined;
|
||
|
}
|
||
|
};
|
||
|
});
|
||
|
};
|
||
|
|
||
|
_proto3.flatMap = function flatMap(fn) {
|
||
|
var _this6 = this;
|
||
|
|
||
|
if (typeof fn !== 'function') throw new TypeError(fn + ' is not a function');
|
||
|
var C = getSpecies(this);
|
||
|
return new C(function (observer) {
|
||
|
var subscriptions = [];
|
||
|
|
||
|
var outer = _this6.subscribe({
|
||
|
next: function (value) {
|
||
|
if (fn) {
|
||
|
try {
|
||
|
value = fn(value);
|
||
|
} catch (e) {
|
||
|
return observer.error(e);
|
||
|
}
|
||
|
}
|
||
|
|
||
|
var inner = C.from(value).subscribe({
|
||
|
next: function (value) {
|
||
|
observer.next(value);
|
||
|
},
|
||
|
error: function (e) {
|
||
|
observer.error(e);
|
||
|
},
|
||
|
complete: function () {
|
||
|
var i = subscriptions.indexOf(inner);
|
||
|
if (i >= 0) subscriptions.splice(i, 1);
|
||
|
completeIfDone();
|
||
|
}
|
||
|
});
|
||
|
subscriptions.push(inner);
|
||
|
},
|
||
|
error: function (e) {
|
||
|
observer.error(e);
|
||
|
},
|
||
|
complete: function () {
|
||
|
completeIfDone();
|
||
|
}
|
||
|
});
|
||
|
|
||
|
function completeIfDone() {
|
||
|
if (outer.closed && subscriptions.length === 0) observer.complete();
|
||
|
}
|
||
|
|
||
|
return function () {
|
||
|
subscriptions.forEach(function (s) {
|
||
|
return s.unsubscribe();
|
||
|
});
|
||
|
outer.unsubscribe();
|
||
|
};
|
||
|
});
|
||
|
};
|
||
|
|
||
|
_proto3[SymbolObservable] = function () {
|
||
|
return this;
|
||
|
};
|
||
|
|
||
|
Observable.from = function from(x) {
|
||
|
var C = typeof this === 'function' ? this : Observable;
|
||
|
if (x == null) throw new TypeError(x + ' is not an object');
|
||
|
var method = getMethod(x, SymbolObservable);
|
||
|
|
||
|
if (method) {
|
||
|
var observable = method.call(x);
|
||
|
if (Object(observable) !== observable) throw new TypeError(observable + ' is not an object');
|
||
|
if (isObservable(observable) && observable.constructor === C) return observable;
|
||
|
return new C(function (observer) {
|
||
|
return observable.subscribe(observer);
|
||
|
});
|
||
|
}
|
||
|
|
||
|
if (hasSymbol('iterator')) {
|
||
|
method = getMethod(x, SymbolIterator);
|
||
|
|
||
|
if (method) {
|
||
|
return new C(function (observer) {
|
||
|
enqueue(function () {
|
||
|
if (observer.closed) return;
|
||
|
|
||
|
for (var _iterator = _createForOfIteratorHelperLoose(method.call(x)), _step; !(_step = _iterator()).done;) {
|
||
|
var item = _step.value;
|
||
|
observer.next(item);
|
||
|
if (observer.closed) return;
|
||
|
}
|
||
|
|
||
|
observer.complete();
|
||
|
});
|
||
|
});
|
||
|
}
|
||
|
}
|
||
|
|
||
|
if (Array.isArray(x)) {
|
||
|
return new C(function (observer) {
|
||
|
enqueue(function () {
|
||
|
if (observer.closed) return;
|
||
|
|
||
|
for (var i = 0; i < x.length; ++i) {
|
||
|
observer.next(x[i]);
|
||
|
if (observer.closed) return;
|
||
|
}
|
||
|
|
||
|
observer.complete();
|
||
|
});
|
||
|
});
|
||
|
}
|
||
|
|
||
|
throw new TypeError(x + ' is not observable');
|
||
|
};
|
||
|
|
||
|
Observable.of = function of() {
|
||
|
for (var _len2 = arguments.length, items = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
|
||
|
items[_key2] = arguments[_key2];
|
||
|
}
|
||
|
|
||
|
var C = typeof this === 'function' ? this : Observable;
|
||
|
return new C(function (observer) {
|
||
|
enqueue(function () {
|
||
|
if (observer.closed) return;
|
||
|
|
||
|
for (var i = 0; i < items.length; ++i) {
|
||
|
observer.next(items[i]);
|
||
|
if (observer.closed) return;
|
||
|
}
|
||
|
|
||
|
observer.complete();
|
||
|
});
|
||
|
});
|
||
|
};
|
||
|
|
||
|
_createClass(Observable, null, [{
|
||
|
key: SymbolSpecies,
|
||
|
get: function () {
|
||
|
return this;
|
||
|
}
|
||
|
}]);
|
||
|
|
||
|
return Observable;
|
||
|
}();
|
||
|
|
||
|
if (hasSymbols()) {
|
||
|
Object.defineProperty(Observable, Symbol('extensions'), {
|
||
|
value: {
|
||
|
symbol: SymbolObservable,
|
||
|
hostReportError: hostReportError
|
||
|
},
|
||
|
configurable: true
|
||
|
});
|
||
|
}
|
||
|
|
||
|
export { Observable };
|